ObjectTest.java :  » Scripting » java2script » net » sf » j2s » test » junit » Java Open Source

Java Open Source » Scripting » java2script 
java2script » net » sf » j2s » test » junit » ObjectTest.java
/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.sf.j2s.test.junit;

public class ObjectTest extends junit.framework.TestCase {

  /**
   * Test objects.
   */
  Object obj1 = new Object();

  Object obj2 = new Object();

  /**
   * Generic state indicator.
   */
  int status = 0;

  int ready = 0;

  /**
   * @tests java.lang.Object#Object()
   */
  public void test_Constructor() {
    // Test for method java.lang.Object()
    assertNotNull("Constructor failed !!!", new Object());
  }

  /**
   * @tests java.lang.Object#equals(java.lang.Object)
   */
  public void test_equalsLjava_lang_Object() {
    // Test for method boolean java.lang.Object.equals(java.lang.Object)
    assertTrue("Same object should be equal", obj1.equals(obj1));
    assertTrue("Different objects should not be equal", !obj1.equals(obj2));
  }

  /**
   * @tests java.lang.Object#getClass()
   */
  public void test_getClass() {
    // Test for method java.lang.Class java.lang.Object.getClass()
    String classNames[] = { "java.lang.Object", "java.lang.Throwable",
        "java.lang.StringBuffer" };
    Class classToTest = null;
    Object instanceToTest = null;

    status = 0;
    for (int i = 0; i < classNames.length; ++i) {
      try {
        classToTest = Class.forName(classNames[i]);
        instanceToTest = classToTest.newInstance();
        assertTrue("Instance didn't match creator class.",
            instanceToTest.getClass() == classToTest);
        assertTrue("Instance didn't match class with matching name.",
            instanceToTest.getClass() == Class
                .forName(classNames[i]));
      } catch (Exception ex) {
        fail("Unexpected exception : " + ex.getMessage());
      }
    }
  }

  /** 
   * @tests java.lang.Object#hashCode()
   */
  public void test_hashCode() {
    // Test for method int java.lang.Object.hashCode()
    assertTrue("Same object should have same hash.",
        obj1.hashCode() == obj1.hashCode());
    assertTrue("Same object should have same hash.",
        obj2.hashCode() == obj2.hashCode());
  }

  /**
   * @tests java.lang.Object#notify()
   */
  public void test_notify() {
    // Test for method void java.lang.Object.notify()

    // Inner class to run test thread.
    class TestThread implements Runnable {
      public void run() {
        synchronized (obj1) {
          try {
            ready += 1;
            obj1.wait();// Wait for ever.
            status += 1;
          } catch (InterruptedException ex) {
            status = -1000;
          }
        }
      }
    }
    ;

    // Start of test code.

    // Warning:
    // This code relies on each thread getting serviced within
    // 200 mSec of when it is notified. Although this
    // seems reasonable, it could lead to false-failures.

    ready = 0;
    status = 0;
    final int readyWaitSecs = 3;

    final int threadCount = 20;
    for (int i = 0; i < threadCount; ++i) {
      new Thread(new TestThread()).start();
    }
    synchronized (obj1) {
      try {

        // Wait up to readyWaitSeconds for all threads to be waiting on
        // monitor
        for (int i = 0; i < readyWaitSecs; i++) {
          obj1.wait(1000, 0);
          if (ready == threadCount) {
            break;
          }
        }

        // Check pre-conditions of testing notifyAll
        assertTrue("Not all launched threads are waiting. (ready = "
            + ready + ")", ready == threadCount);
        assertTrue("Thread woke too early. (status = " + status + ")",
            status == 0);

        for (int i = 1; i <= threadCount; ++i) {
          obj1.notify();
          obj1.wait(200, 0);
          assertTrue("Out of sync. (expected " + i + " but got "
              + status + ")", status == i);
        }

      } catch (InterruptedException ex) {
        fail(
            "Unexpectedly got an InterruptedException. (status = "
                + status + ")");
      }
    }
  }

  /**
   * @tests java.lang.Object#notifyAll()
   */
  public void test_notifyAll() {
    // Test for method void java.lang.Object.notifyAll()

    // Inner class to run test thread.
    class TestThread implements Runnable {
      public void run() {
        synchronized (obj1) {
          try {
            ready += 1;
            obj1.wait();// Wait for ever.
            status += 1;
          } catch (InterruptedException ex) {
            status = -1000;
          }
        }
      }
    }
    ;

    // Start of test code.

    // Warning:
    // This code relies on all threads getting serviced within
    // 5 seconds of when they are notified. Although this
    // seems reasonable, it could lead to false-failures.

    status = 0;
    ready = 0;
    final int readyWaitSecs = 3;
    final int threadCount = 20;
    for (int i = 0; i < threadCount; ++i) {
      new Thread(new TestThread()).start();
    }

    synchronized (obj1) {

      try {

        // Wait up to readyWaitSeconds for all threads to be waiting on
        // monitor
        for (int i = 0; i < readyWaitSecs; i++) {
          obj1.wait(1000, 0);
          if (ready == threadCount) {
            break;
          }
        }

        // Check pre-conditions of testing notifyAll
        assertTrue("Not all launched threads are waiting. (ready = "
            + ready + ")", ready == threadCount);
        assertTrue("At least one thread woke too early. (status = "
            + status + ")", status == 0);

        obj1.notifyAll();

        obj1.wait(5000, 0);

        assertTrue(
            "At least one thread did not get notified. (status = "
                + status + ")", status == threadCount);

      } catch (InterruptedException ex) {
        fail(
            "Unexpectedly got an InterruptedException. (status = "
                + status + ")");
      }

    }
  }

  /**
   * @tests java.lang.Object#toString()
   */
  public void test_toString() {
    // Test for method java.lang.String java.lang.Object.toString()
    assertNotNull("Object toString returned null.", obj1.toString());
  }

  /**
   * @tests java.lang.Object#wait()
   */
  public void test_wait() {
    // Test for method void java.lang.Object.wait()

    // Inner class to run test thread.
    class TestThread implements Runnable {
      public void run() {
        synchronized (obj1) {
          try {
            obj1.wait();// Wait for ever.
            status = 1;
          } catch (InterruptedException ex) {
            status = -1;
          }
        }
      }
    }
    ;

    // Start of test code.

    // Warning:
    // This code relies on threads getting serviced within
    // 1 second of when they are notified. Although this
    // seems reasonable, it could lead to false-failures.

    status = 0;
    new Thread(new TestThread()).start();
    synchronized (obj1) {
      try {
        obj1.wait(1000, 0);
        assertTrue("Thread woke too early. (status = " + status + ")",
            status == 0);
        obj1.notifyAll();
        obj1.wait(1000, 0);
        assertTrue("Thread did not get notified. (status = " + status
            + ")", status == 1);
      } catch (InterruptedException ex) {
        fail(
            "Unexpectedly got an InterruptedException. (status = "
                + status + ")");
      }
    }
  }

  /**
   * @tests java.lang.Object#wait(long)
   */
  public void test_waitJ() {
    // Test for method void java.lang.Object.wait(long)

    // Start of test code.

    final int loopCount = 20;
    final int allowableError = 100; // millesconds
    final int delay = 200; // milliseconds
    synchronized (obj1) {
      try {
        int count = 0;
        long[][] toLong = new long[3][3];
        for (int i = 0; i < loopCount; ++i) {
          long before = System.currentTimeMillis();
          obj1.wait(delay, 0);
          long after = System.currentTimeMillis();
          long error = (after - before - delay);
          if (error < 0)
            error = -error;
          if (i > 0 && error > allowableError) {
            // Allow jit to warm up before testing
            if (count < toLong.length) {
              toLong[count][0] = i;
              toLong[count][1] = before;
              toLong[count][2] = after;
              count++;
            }
            if (error > (1000 + delay) || count == toLong.length) {
              StringBuffer sb = new StringBuffer();
              for (int j = 0; j < count; j++) {
                sb
                    .append("wakeup time too inaccurate, iteration ");
                sb.append(toLong[j][0]);
                sb.append(", before: ");
                sb.append(toLong[j][1]);
                sb.append(" after: ");
                sb.append(toLong[j][2]);
                sb.append(" diff: ");
                sb.append(toLong[j][2] - toLong[j][1]);
                sb.append("\n");
              }
              fail(sb.toString());
            }
          }
        }
      } catch (InterruptedException ex) {
        fail(
            "Unexpectedly got an InterruptedException. (status = "
                + status + ")");
      }
    }
  }

  /**
   * @tests java.lang.Object#wait(long, int)
   */
  public void test_waitJI() {
    // Test for method void java.lang.Object.wait(long, int)

    // Inner class to run test thread.
    class TestThread implements Runnable {
      public void run() {
        synchronized (obj1) {
          try {
            obj1.wait(0, 1); // Don't wait very long.
            status = 1;
            obj1.wait(0, 0); // Wait for ever.
            status = 2;
          } catch (InterruptedException ex) {
            status = -1;
          }
        }
      }
    }
    ;

    // Start of test code.

    // Warning:
    // This code relies on threads getting serviced within
    // 1 second of when they are notified. Although this
    // seems reasonable, it could lead to false-failures.

    status = 0;
    new Thread(new TestThread()).start();
    synchronized (obj1) {
      try {
        obj1.wait(1000, 0);
        assertTrue("Thread did not wake after 1 ms. (status = "
            + status + ")", status == 1);
        obj1.notifyAll();
        obj1.wait(1000, 0);
        assertTrue("Thread did not get notified. (status = " + status
            + ")", status == 2);
      } catch (InterruptedException ex) {
        fail(
            "Unexpectedly got an InterruptedException. (status = "
                + status + ")");
      }
    }

  }

  /**
   * Sets up the fixture, for example, open a network connection. This method
   * is called before a test is executed.
   */
  protected void setUp() {
  }

  /**
   * Tears down the fixture, for example, close a network connection. This
   * method is called after a test is executed.
   */
  protected void tearDown() {
  }
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.