/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.harmony.luni.tests.java.lang;
import java.util.Vector;
//import dalvik.annotation.TestTargets;
//import dalvik.annotation.TestLevel;
//import dalvik.annotation.TestTargetNew;
//import dalvik.annotation.TestTargetClass;
//import dalvik.annotation.BrokenTest;
//import dalvik.annotation.SideEffect;
//@TestTargetClass(Object.class)
public class ObjectTest extends junit.framework.TestCase {
public boolean isCalled = false;
/**
* Test objects.
*/
Object obj1 = new Object();
Object obj2 = new Object();
/**
* Generic state indicator.
*/
int status = 0;
int ready = 0;
TestThread1 thr1;
TestThread2 thr2;
/**
* @tests java.lang.Object#Object()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "Object",
args = {}
)
*/
public void test_Constructor() {
// Test for method java.lang.Object()
assertNotNull("Constructor failed !!!", new Object());
}
/**
* @tests java.lang.Object#equals(java.lang.Object)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
*/
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));
}
/*
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "finalize",
args = {}
)
@SideEffect("Causes OutOfMemoryError to test finalization")
*/
public void test_finalize() {
isCalled = false;
class TestObject extends Object {
Vector<StringBuffer> v = new Vector<StringBuffer>();
public void add() {
v.add(new StringBuffer(10000));
}
protected void finalize() throws Throwable {
isCalled = true;
super.finalize();
}
}
TestObject to = new TestObject();
try {
while(true) {
to.add();
}
} catch(OutOfMemoryError oome) {
//expected
to = null;
}
System.gc();
System.runFinalization();
assertTrue(isCalled);
}
/*
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clone",
args = {}
)
*/
public void test_clone() {
MockCloneableObject mco = new MockCloneableObject();
try {
assertFalse(mco.equals(mco.clone()));
assertEquals(mco.getClass(), mco.clone().getClass());
} catch(CloneNotSupportedException cnse) {
fail("CloneNotSupportedException was thrown.");
}
MockObject mo = new MockObject();
try {
mo.clone();
fail("CloneNotSupportedException was not thrown.");
} catch(CloneNotSupportedException cnse) {
//expected
}
}
class MockCloneableObject extends Object implements Cloneable {
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class MockObject extends Object {
boolean isCalled = false;
public void finalize() throws Throwable {
super.finalize();
isCalled = true;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/**
* @tests java.lang.Object#getClass()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getClass",
args = {}
)
*/
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()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
*/
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()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "notify",
args = {}
)
*/
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 + ")");
}
}
try {
Object obj = new Object();
obj.notify();
fail("IllegalMonitorStateException was not thrown.");
} catch(IllegalMonitorStateException imse) {
//expected
}
}
/**
* @tests java.lang.Object#notifyAll()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "notifyAll",
args = {}
)
*/
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 + ")");
}
}
try {
Object obj = new Object();
obj.notifyAll();
fail("IllegalMonitorStateException was not thrown.");
} catch(IllegalMonitorStateException imse) {
//expected
}
}
/**
* @tests java.lang.Object#toString()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
*/
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()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "wait",
args = {}
)
*/
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 + ")");
}
}
try {
Object obj = new Object();
obj.wait();
fail("IllegalMonitorStateException was not thrown.");
} catch(IllegalMonitorStateException imse) {
//expected
} catch(InterruptedException ex) {
fail("InterruptedException was thrown.");
}
try {
thr1 = new TestThread1(TestThread1.CASE_WAIT);
thr2 = new TestThread2();
thr1.start();
thr2.start();
thr2.join();
thr1.join();
thr1 = null;
thr2 = null;
} catch(InterruptedException e) {
fail("InterruptedException was thrown.");
}
assertEquals(3, status);
}
class TestThread1 extends Thread {
static final int CASE_WAIT = 0;
static final int CASE_WAIT_LONG = 1;
static final int CASE_WAIT_LONG_INT = 2;
int testCase = CASE_WAIT;
public TestThread1(int option) {
testCase = option;
}
public void run() {
synchronized (obj1) {
try {
switch(testCase) {
case CASE_WAIT:
obj1.wait();// Wait for ever.
break;
case CASE_WAIT_LONG:
obj1.wait(5000L);
break;
case CASE_WAIT_LONG_INT:
obj1.wait(10000L, 999999);
break;
}
} catch (InterruptedException ex) {
status = 3;
}
}
}
}
class TestThread2 extends Thread {
public void run() {
thr1.interrupt();
}
}
/**
* @tests java.lang.Object#wait(long)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "wait",
args = {long.class}
)
*/
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 + ")");
}
}
try {
Object obj = new Object();
obj.wait(5000L);
fail("IllegalMonitorStateException was not thrown.");
} catch(IllegalMonitorStateException imse) {
//expected
} catch(InterruptedException ex) {
fail("InterruptedException was thrown.");
}
try {
thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG);
thr2 = new TestThread2();
thr1.start();
thr2.start();
thr2.join();
thr1.join();
thr1 = null;
thr2 = null;
} catch(InterruptedException e) {
fail("InterruptedException was thrown.");
}
assertEquals(3, status);
}
/**
* @tests java.lang.Object#wait(long, int)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "wait",
args = {long.class, int.class}
)
*/
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 + ")");
}
}
try {
Object obj = new Object();
obj.wait(5000L, 1);
fail("IllegalMonitorStateException was not thrown.");
} catch(IllegalMonitorStateException imse) {
//expected
} catch(InterruptedException ex) {
fail("InterruptedException was thrown.");
}
try {
thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG_INT);
thr2 = new TestThread2();
thr1.start();
thr2.start();
thr2.join();
thr1.join();
thr1 = null;
thr2 = null;
} catch(InterruptedException e) {
fail("InterruptedException was thrown.");
}
assertEquals(3, status);
}
}