harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r386058 [23/49] - in /incubator/harmony/enhanced/classlib/trunk: make/ modules/archive/make/common/ modules/archive/src/test/java/tests/ modules/archive/src/test/java/tests/api/ modules/archive/src/test/java/tests/api/java/ modules/archive/...
Date Wed, 15 Mar 2006 11:47:39 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThreadTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThreadTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThreadTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThreadTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,1146 @@
+/* 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 tests.api.java.lang;
+
+public class ThreadTest extends junit.framework.TestCase {
+
+	static class SimpleThread implements Runnable {
+		int delay;
+
+		public void run() {
+			try {
+				synchronized (this) {
+					this.notify();
+					this.wait(delay);
+				}
+			} catch (InterruptedException e) {
+				return;
+			}
+
+		}
+
+		public SimpleThread(int d) {
+			if (d >= 0)
+				delay = d;
+		}
+	}
+
+	static class YieldThread implements Runnable {
+		volatile int delay;
+
+		public void run() {
+			int x = 0;
+			while (true) {
+				++x;
+			}
+		}
+
+		public YieldThread(int d) {
+			if (d >= 0)
+				delay = d;
+		}
+	}
+
+	static class ResSupThread implements Runnable {
+		Thread parent;
+
+		volatile int checkVal = -1;
+
+		public void run() {
+			try {
+				synchronized (this) {
+					this.notify();
+				}
+				while (true) {
+					checkVal++;
+					zz();
+					Thread.sleep(100);
+				}
+			} catch (InterruptedException e) {
+				return;
+			} catch (BogusException e) {
+				try {
+					// Give parent a chance to sleep
+					Thread.sleep(500);
+				} catch (InterruptedException x) {
+				}
+				parent.interrupt();
+				while (!Thread.currentThread().isInterrupted()) {
+					// Don't hog the CPU
+					try {
+						Thread.sleep(50);
+					} catch (InterruptedException x) {
+						// This is what we've been waiting for...don't throw it
+						// away!
+						break;
+					}
+				}
+			}
+		}
+
+		public void zz() throws BogusException {
+		}
+
+		public ResSupThread(Thread t) {
+			parent = t;
+		}
+
+		public synchronized int getCheckVal() {
+			return checkVal;
+		}
+	}
+
+	static class BogusException extends Throwable {
+		public BogusException(String s) {
+			super(s);
+		}
+	}
+
+	Thread st, ct, spinner;
+
+	static boolean calledMySecurityManager = false;
+
+	/**
+	 * @tests java.lang.Thread#Thread()
+	 */
+	public void test_Constructor() {
+		// Test for method java.lang.Thread()
+
+		Thread t;
+		SecurityManager m = new SecurityManager() {
+			public ThreadGroup getThreadGroup() {
+				calledMySecurityManager = true;
+				return Thread.currentThread().getThreadGroup();
+			}
+		};
+		try {
+			// To see if it checks Thread creation with our SecurityManager
+			System.setSecurityManager(m);
+			t = new Thread();
+		} finally {
+			// restore original, no side-effects
+			System.setSecurityManager(null);
+		}
+		assertTrue("Did not call SecurityManager.getThreadGroup ()",
+				calledMySecurityManager);
+		t.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.Runnable)
+	 */
+	public void test_ConstructorLjava_lang_Runnable() {
+		// Test for method java.lang.Thread(java.lang.Runnable)
+		try {
+			ct = new Thread(new SimpleThread(10));
+			ct.start();
+		} catch (Exception e) {
+			fail("Failed to create subthread : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.Runnable, java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_RunnableLjava_lang_String() {
+		// Test for method java.lang.Thread(java.lang.Runnable,
+		// java.lang.String)
+		Thread st1 = new Thread(new SimpleThread(1), "SimpleThread1");
+		assertTrue("Constructed thread with incorrect thread name", st1
+				.getName().equals("SimpleThread1"));
+		st1.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// Test for method java.lang.Thread(java.lang.String)
+		Thread t = new Thread("Testing");
+		assertTrue("Created tread with incorrect name", t.getName().equals(
+				"Testing"));
+		t.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable)
+	 */
+	public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_Runnable() {
+		// Test for method java.lang.Thread(java.lang.ThreadGroup,
+		// java.lang.Runnable)
+		ThreadGroup tg = new ThreadGroup("Test Group1");
+		st = new Thread(tg, new SimpleThread(1), "SimpleThread2");
+		assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg);
+		st.start();
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+		}
+		tg.destroy();
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.Runnable,
+	 *        java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_RunnableLjava_lang_String() {
+		// Test for method java.lang.Thread(java.lang.ThreadGroup,
+		// java.lang.Runnable, java.lang.String)
+		ThreadGroup tg = new ThreadGroup("Test Group2");
+		st = new Thread(tg, new SimpleThread(1), "SimpleThread3");
+		assertTrue("Constructed incorrect thread", (st.getThreadGroup() == tg)
+				&& st.getName().equals("SimpleThread3"));
+		st.start();
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+		}
+		tg.destroy();
+
+		Runnable r = new Runnable() {
+			public void run() {
+			}
+		};
+
+		ThreadGroup foo = null;
+		try {
+			new Thread(foo = new ThreadGroup("foo"), r, null);
+			// Should not get here
+			fail("Null cannot be accepted as Thread name");
+		} catch (NullPointerException npe) {
+			assertTrue("Null cannot be accepted as Thread name", true);
+			foo.destroy();
+		}
+
+	}
+
+	/**
+	 * @tests java.lang.Thread#Thread(java.lang.ThreadGroup, java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_ThreadGroupLjava_lang_String() {
+		// Test for method java.lang.Thread(java.lang.ThreadGroup,
+		// java.lang.String)
+		st = new Thread(new SimpleThread(1), "SimpleThread4");
+		assertTrue("Returned incorrect thread name", st.getName().equals(
+				"SimpleThread4"));
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#activeCount()
+	 */
+	public void test_activeCount() {
+		// Test for method int java.lang.Thread.activeCount()
+		Thread t = new Thread(new SimpleThread(1));
+		int active = t.activeCount();
+		assertTrue("Incorrect read made: " + active, active > 0);
+		t.start();
+		try {
+			t.join();
+		} catch (InterruptedException e) {
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#checkAccess()
+	 */
+	public void test_checkAccess() {
+		// Test for method void java.lang.Thread.checkAccess()
+		ThreadGroup tg = new ThreadGroup("Test Group3");
+		try {
+			st = new Thread(tg, new SimpleThread(1), "SimpleThread5");
+			st.checkAccess();
+			assertTrue("CheckAccess passed", true);
+		} catch (SecurityException e) {
+			fail("CheckAccess failed : " + e.getMessage());
+		}
+		st.start();
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+		}
+		tg.destroy();
+	}
+
+	/**
+	 * @tests java.lang.Thread#countStackFrames()
+	 */
+	public void test_countStackFrames() {
+		// Test for method int java.lang.Thread.countStackFrames()
+		// SM.
+		assertTrue("Test failed.",
+				Thread.currentThread().countStackFrames() == 0);
+	}
+
+	/**
+	 * @tests java.lang.Thread#currentThread()
+	 */
+	public void test_currentThread() {
+		// Test for method java.lang.Thread java.lang.Thread.currentThread()
+		assertTrue("Current thread was not main thread: "
+				+ Thread.currentThread().getName(), Thread.currentThread()
+				.getName().equals("main"));
+	}
+
+	/**
+	 * @tests java.lang.Thread#destroy()
+	 */
+	public void test_destroy() {
+		// Test for method void java.lang.Thread.destroy()
+		assertTrue(
+				"The method 'destroy' is not implemented so nothing to test",
+				true);
+	}
+
+	/**
+	 * @tests java.lang.Thread#enumerate(java.lang.Thread[])
+	 */
+	public void test_enumerate$Ljava_lang_Thread() {
+		// Test for method int java.lang.Thread.enumerate(java.lang.Thread [])
+		Thread[] tarray = new Thread[10];
+		int initialCount = Thread.enumerate(tarray);
+		ThreadGroup mytg = new ThreadGroup("jp");
+		SimpleThread st1 = new SimpleThread(-1);
+		SimpleThread st2 = new SimpleThread(-1);
+		Thread firstOne = new Thread(mytg, st1, "firstOne2");
+		Thread secondOne = new Thread(mytg, st2, "secondOne1");
+		assertTrue("Incorrect value returned1",
+				Thread.enumerate(tarray) == initialCount);
+		synchronized (st1) {
+			firstOne.start();
+			try {
+				st1.wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		assertTrue("Incorrect value returned2",
+				Thread.enumerate(tarray) == (initialCount + 1));
+
+		synchronized (st2) {
+			secondOne.start();
+			try {
+				st2.wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		assertTrue("Incorrect value returned3",
+				Thread.enumerate(tarray) == (initialCount + 2));
+
+		synchronized (st1) {
+			firstOne.interrupt();
+		}
+		synchronized (st2) {
+			secondOne.interrupt();
+		}
+		try {
+			firstOne.join();
+			secondOne.join();
+		} catch (InterruptedException e) {
+		}
+		mytg.destroy();
+	}
+
+	/**
+	 * @tests java.lang.Thread#getContextClassLoader()
+	 */
+	public void test_getContextClassLoader() {
+		// Test for method java.lang.ClassLoader
+		// java.lang.Thread.getContextClassLoader()
+		Thread t = new Thread();
+		assertTrue("Incorrect class loader returned",
+				t.getContextClassLoader() == Thread.currentThread()
+						.getContextClassLoader());
+		t.start();
+
+	}
+
+	/**
+	 * @tests java.lang.Thread#getName()
+	 */
+	public void test_getName() {
+		// Test for method java.lang.String java.lang.Thread.getName()
+		st = new Thread(new SimpleThread(1), "SimpleThread6");
+		assertTrue("Returned incorrect thread name", st.getName().equals(
+				"SimpleThread6"));
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#getPriority()
+	 */
+	public void test_getPriority() {
+		// Test for method int java.lang.Thread.getPriority()
+		st = new Thread(new SimpleThread(1));
+		st.setPriority(Thread.MAX_PRIORITY);
+		assertTrue("Returned incorrect thread priority",
+				st.getPriority() == Thread.MAX_PRIORITY);
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#getThreadGroup()
+	 */
+	public void test_getThreadGroup() {
+		// Test for method java.lang.ThreadGroup
+		// java.lang.Thread.getThreadGroup()
+		ThreadGroup tg = new ThreadGroup("Test Group4");
+		st = new Thread(tg, new SimpleThread(1), "SimpleThread8");
+		assertTrue("Returned incorrect thread group", st.getThreadGroup() == tg);
+		st.start();
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+		}
+		assertTrue("group should be null", st.getThreadGroup() == null);
+		assertTrue("toString() should not be null", st.toString() != null);
+		tg.destroy();
+
+		final Object lock = new Object();
+		Thread t = new Thread() {
+			public void run() {
+				synchronized (lock) {
+					lock.notifyAll();
+				}
+			}
+		};
+		synchronized (lock) {
+			t.start();
+			try {
+				lock.wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		int running = 0;
+		while (t.isAlive())
+			running++;
+		ThreadGroup group = t.getThreadGroup();
+		assertTrue("ThreadGroup is not null", group == null);
+	}
+
+	/**
+	 * @tests java.lang.Thread#interrupt()
+	 */
+	public void test_interrupt() {
+		// Test for method void java.lang.Thread.interrupt()
+		final Object lock = new Object();
+		class ChildThread1 extends Thread {
+			Thread parent;
+
+			boolean sync;
+
+			public void run() {
+				if (sync) {
+					synchronized (lock) {
+						lock.notify();
+						try {
+							lock.wait();
+						} catch (InterruptedException e) {
+						}
+					}
+				}
+				parent.interrupt();
+			}
+
+			public ChildThread1(Thread p, String name, boolean sync) {
+				super(name);
+				parent = p;
+				this.sync = sync;
+			}
+		}
+		boolean interrupted = false;
+		try {
+			ct = new ChildThread1(Thread.currentThread(), "Interrupt Test1",
+					false);
+			synchronized (lock) {
+				ct.start();
+				lock.wait();
+			}
+		} catch (InterruptedException e) {
+			interrupted = true;
+		}
+		assertTrue("Failed to Interrupt thread1", interrupted);
+
+		interrupted = false;
+		try {
+			ct = new ChildThread1(Thread.currentThread(), "Interrupt Test2",
+					true);
+			synchronized (lock) {
+				ct.start();
+				lock.wait();
+				lock.notify();
+			}
+			Thread.sleep(20000);
+		} catch (InterruptedException e) {
+			interrupted = true;
+		}
+		assertTrue("Failed to Interrupt thread2", interrupted);
+
+	}
+
+	/**
+	 * @tests java.lang.Thread#interrupted()
+	 */
+	public void test_interrupted() {
+		// Test for method boolean java.lang.Thread.interrupted()
+
+		assertTrue("Interrupted returned true for non-interrupted thread",
+				Thread.interrupted() == false);
+		Thread.currentThread().interrupt();
+		assertTrue("Interrupted returned true for non-interrupted thread",
+				Thread.interrupted() == true);
+		assertTrue("Failed to clear interrupted flag",
+				Thread.interrupted() == false);
+	}
+
+	/**
+	 * @tests java.lang.Thread#isAlive()
+	 */
+	public void test_isAlive() {
+		// Test for method boolean java.lang.Thread.isAlive()
+		SimpleThread simple;
+		st = new Thread(simple = new SimpleThread(500));
+		assertTrue("Unstarted thread returned true", !st.isAlive());
+		synchronized (simple) {
+			st.start();
+			try {
+				simple.wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		assertTrue("Started thread returned false", st.isAlive());
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+			fail("Thread did not die");
+		}
+		assertTrue("Stopped thread returned true", !st.isAlive());
+	}
+
+	/**
+	 * @tests java.lang.Thread#isDaemon()
+	 */
+	public void test_isDaemon() {
+		// Test for method boolean java.lang.Thread.isDaemon()
+		st = new Thread(new SimpleThread(1), "SimpleThread10");
+		assertTrue("Non-Daemon thread returned true", !st.isDaemon());
+		st.setDaemon(true);
+		assertTrue("Daemon thread returned false", st.isDaemon());
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#isInterrupted()
+	 */
+	public void test_isInterrupted() {
+		// Test for method boolean java.lang.Thread.isInterrupted()
+		class SpinThread implements Runnable {
+			public volatile boolean done = false;
+
+			public void run() {
+				while (!Thread.currentThread().isInterrupted())
+					;
+				while (!done)
+					;
+			}
+		}
+
+		SpinThread spin = new SpinThread();
+		spinner = new Thread(spin);
+		spinner.start();
+		Thread.yield();
+		try {
+			assertTrue("Non-Interrupted thread returned true", !spinner
+					.isInterrupted());
+			spinner.interrupt();
+			assertTrue("Interrupted thread returned false", spinner
+					.isInterrupted());
+			spin.done = true;
+		} finally {
+			spinner.interrupt();
+			spin.done = true;
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#join()
+	 */
+	public void test_join() {
+		// Test for method void java.lang.Thread.join()
+		SimpleThread simple;
+		try {
+			st = new Thread(simple = new SimpleThread(100));
+			// cause isAlive() to be compiled by the jit, as it must be called
+			// within 100ms below.
+			assertTrue("Thread is alive", !st.isAlive());
+			synchronized (simple) {
+				st.start();
+				simple.wait();
+			}
+			st.join();
+		} catch (InterruptedException e) {
+			fail("Join failed ");
+		}
+		assertTrue("Joined thread is still alive", !st.isAlive());
+		boolean result = true;
+		Thread th = new Thread("test");
+		try {
+			th.join();
+		} catch (InterruptedException e) {
+			result = false;
+		}
+		assertTrue("Hung joining a non-started thread", result);
+		th.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#join(long)
+	 */
+	public void test_joinJ() {
+		// Test for method void java.lang.Thread.join(long)
+		SimpleThread simple;
+		try {
+			st = new Thread(simple = new SimpleThread(1000), "SimpleThread12");
+			// cause isAlive() to be compiled by the jit, as it must be called
+			// within 100ms below.
+			assertTrue("Thread is alive", !st.isAlive());
+			synchronized (simple) {
+				st.start();
+				simple.wait();
+			}
+			st.join(10);
+		} catch (InterruptedException e) {
+			fail("Join failed ");
+		}
+		assertTrue("Join failed to timeout", st.isAlive());
+
+		st.interrupt();
+		try {
+			st = new Thread(simple = new SimpleThread(100), "SimpleThread13");
+			synchronized (simple) {
+				st.start();
+				simple.wait();
+			}
+			st.join(1000);
+		} catch (InterruptedException e) {
+			fail("Join failed : " + e.getMessage());
+			return;
+		}
+		assertTrue("Joined thread is still alive", !st.isAlive());
+
+		final Object lock = new Object();
+		final Thread main = Thread.currentThread();
+		Thread killer = new Thread(new Runnable() {
+			public void run() {
+				try {
+					synchronized (lock) {
+						lock.notify();
+					}
+					Thread.sleep(100);
+				} catch (InterruptedException e) {
+					return;
+				}
+				main.interrupt();
+			}
+		});
+		boolean result = true;
+		Thread th = new Thread("test");
+		try {
+			synchronized (lock) {
+				killer.start();
+				lock.wait();
+			}
+			th.join(200);
+		} catch (InterruptedException e) {
+			result = false;
+		}
+		killer.interrupt();
+		assertTrue("Hung joining a non-started thread", result);
+		th.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#join(long, int)
+	 */
+	public void test_joinJI() {
+		// Test for method void java.lang.Thread.join(long, int)
+		SimpleThread simple;
+		try {
+			st = new Thread(simple = new SimpleThread(1000), "Squawk1");
+			assertTrue("Thread is alive", !st.isAlive());
+			synchronized (simple) {
+				st.start();
+				simple.wait();
+			}
+			
+			long firstRead = System.currentTimeMillis();
+			st.join(100, 999999);
+			long secondRead = System.currentTimeMillis();
+			assertTrue("Did not join by appropriate time: " + secondRead + "-"
+					+ firstRead + "=" + (secondRead - firstRead), secondRead
+					- firstRead <= 300);
+			assertTrue("Joined thread is not alive", st.isAlive());
+			st.interrupt();  
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+
+		final Object lock = new Object();
+		final Thread main = Thread.currentThread();
+		Thread killer = new Thread(new Runnable() {
+			public void run() {
+				try {
+					synchronized (lock) {
+						lock.notify();
+					}
+					Thread.sleep(100);
+				} catch (InterruptedException e) {
+					return;
+				}
+				main.interrupt();
+			}
+		});
+		boolean result = true;
+		Thread th = new Thread("test");
+		try {
+			synchronized (lock) {
+				killer.start();
+				lock.wait();
+			}
+			th.join(200, 20);
+		} catch (InterruptedException e) {
+			result = false;
+		}
+		killer.interrupt();
+		assertTrue("Hung joining a non-started thread", result);
+		th.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#resume()
+	 */
+	public void test_resume() {
+		// Test for method void java.lang.Thread.resume()
+		int orgval;
+		ResSupThread t;
+		try {
+			t = new ResSupThread(Thread.currentThread());
+			synchronized (t) {
+				ct = new Thread(t, "Interupt Test2");
+				ct.start();
+				t.wait();
+			}
+			ct.suspend();
+			// Wait to be sure the suspend has occurred
+			Thread.sleep(500);
+			orgval = t.getCheckVal();
+			// Wait to be sure the thread is suspended
+			Thread.sleep(500);
+			assertTrue("Failed to suspend thread", orgval == t.getCheckVal());
+			ct.resume();
+			// Wait to be sure the resume has occurred.
+			Thread.sleep(500);
+			assertTrue("Failed to resume thread", orgval != t.getCheckVal());
+			ct.interrupt();
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt occurred : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#run()
+	 */
+	public void test_run() {
+		// Test for method void java.lang.Thread.run()
+		class RunThread implements Runnable {
+			boolean didThreadRun = false;
+
+			public void run() {
+				didThreadRun = true;
+			}
+		}
+		RunThread rt = new RunThread();
+		Thread t = new Thread(rt);
+		try {
+			t.start();
+			int count = 0;
+			while (!rt.didThreadRun && count < 20) {
+				Thread.sleep(100);
+				count++;
+			}
+			assertTrue("Thread did not run", rt.didThreadRun);
+			t.join();
+		} catch (InterruptedException e) {
+			assertTrue("Joined thread was interrupted", true);
+		}
+		assertTrue("Joined thread is still alive", !t.isAlive());
+	}
+
+	/**
+	 * @tests java.lang.Thread#setDaemon(boolean)
+	 */
+	public void test_setDaemonZ() {
+		// Test for method void java.lang.Thread.setDaemon(boolean)
+		st = new Thread(new SimpleThread(1), "SimpleThread14");
+		st.setDaemon(true);
+		assertTrue("Failed to set thread as daemon thread", st.isDaemon());
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#setName(java.lang.String)
+	 */
+	public void test_setNameLjava_lang_String() {
+		// Test for method void java.lang.Thread.setName(java.lang.String)
+		st = new Thread(new SimpleThread(1), "SimpleThread15");
+		st.setName("Bogus Name");
+		assertTrue("Failed to set thread name", st.getName().equals(
+				"Bogus Name"));
+		try {
+			st.setName(null);
+			fail("Null should not be accepted as a valid name");
+		} catch (NullPointerException e) {
+			// success
+			assertTrue("Null should not be accepted as a valid name", true);
+		}
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#setPriority(int)
+	 */
+	public void test_setPriorityI() {
+		// Test for method void java.lang.Thread.setPriority(int)
+		st = new Thread(new SimpleThread(1));
+		st.setPriority(Thread.MAX_PRIORITY);
+		assertTrue("Failed to set priority",
+				st.getPriority() == Thread.MAX_PRIORITY);
+		st.start();
+	}
+
+	/**
+	 * @tests java.lang.Thread#sleep(long)
+	 */
+	public void test_sleepJ() {
+		// Test for method void java.lang.Thread.sleep(long)
+
+		// TODO : Test needs enhancing.
+		long stime = 0, ftime = 0;
+		try {
+			stime = System.currentTimeMillis();
+			Thread.currentThread().sleep(1000);
+			ftime = System.currentTimeMillis();
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt received");
+		}
+		assertTrue("Failed to sleep long enough", (ftime - stime) >= 800);
+	}
+
+	/**
+	 * @tests java.lang.Thread#sleep(long, int)
+	 */
+	public void test_sleepJI() {
+		// Test for method void java.lang.Thread.sleep(long, int)
+
+		// TODO : Test needs revisiting.
+		long stime = 0, ftime = 0;
+		try {
+			stime = System.currentTimeMillis();
+			Thread.currentThread().sleep(1000, 999999);
+			ftime = System.currentTimeMillis();
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt received");
+		}
+		long result = ftime - stime;
+		assertTrue("Failed to sleep long enough: " + result, result >= 900
+				&& result <= 1100);
+	}
+
+	/**
+	 * @tests java.lang.Thread#start()
+	 */
+	public void test_start() {
+		// Test for method void java.lang.Thread.start()
+		try {
+			ResSupThread t = new ResSupThread(Thread.currentThread());
+			synchronized (t) {
+				ct = new Thread(t, "Interrupt Test4");
+				ct.start();
+				t.wait();
+			}
+			assertTrue("Thread is not running1", ct.isAlive());
+			// Let the child thread get going.
+			int orgval = t.getCheckVal();
+			Thread.sleep(150);
+			assertTrue("Thread is not running2", orgval != t.getCheckVal());
+			ct.interrupt();
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt occurred");
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#stop()
+	 */
+	public void test_stop() {
+		// Test for method void java.lang.Thread.stop()
+		try {
+			Runnable r = new ResSupThread(null);
+			synchronized (r) {
+				st = new Thread(r, "Interupt Test5");
+				st.start();
+				r.wait();
+			}
+
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt received");
+		}
+		st.stop();
+
+		try {
+			st.join(10000);
+		} catch (InterruptedException e1) {
+			st.interrupt();
+			fail("Failed to stopThread before 10000 timeout");
+		}
+		assertTrue("Failed to stopThread", !st.isAlive());
+	}
+
+	/**
+	 * @tests java.lang.Thread#stop()
+	 */
+	public void test_stop_subtest0() {
+		Thread t = new Thread("t");
+		class MySecurityManager extends SecurityManager {
+			public boolean intest = false;
+
+			public void checkAccess(Thread t) {
+				if (intest) {
+					fail("checkAccess called");
+				}
+			}
+		}
+		MySecurityManager sm = new MySecurityManager();
+		System.setSecurityManager(sm);
+		try {
+			sm.intest = true;
+			try {
+				t.stop();
+				// Ignore any SecurityExceptions, may not have stopThread
+				// permission
+			} catch (SecurityException e) {
+			}
+			sm.intest = false;
+			t.start();
+			try {
+				t.join(2000);
+			} catch (InterruptedException e) {
+			}
+			sm.intest = true;
+			try {
+				t.stop();
+				// Ignore any SecurityExceptions, may not have stopThread
+				// permission
+			} catch (SecurityException e) {
+			}
+			sm.intest = false;
+		} finally {
+			System.setSecurityManager(null);
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#stop(java.lang.Throwable)
+	 */
+	public void test_stopLjava_lang_Throwable_subtest0() {
+		Thread t = new Thread("t");
+		class MySecurityManager extends SecurityManager {
+			public boolean intest = false;
+
+			public boolean checkAccess = false;
+
+			public void checkAccess(Thread t) {
+				if (intest) {
+					checkAccess = true;
+				}
+			}
+		}
+		MySecurityManager sm = new MySecurityManager();
+		System.setSecurityManager(sm);
+		try {
+			sm.intest = true;
+			try {
+				t.stop(new ThreadDeath());
+				// Ignore any SecurityExceptions, may not have stopThread
+				// permission
+			} catch (SecurityException e) {
+			}
+			sm.intest = false;
+			assertTrue("no checkAccess 1", sm.checkAccess);
+			t.start();
+			try {
+				t.join(2000);
+			} catch (InterruptedException e) {
+			}
+			sm.intest = true;
+			sm.checkAccess = false;
+			try {
+				t.stop(new ThreadDeath());
+				// Ignore any SecurityExceptions, may not have stopThread
+				// permission
+			} catch (SecurityException e) {
+			}
+			assertTrue("no checkAccess 2", sm.checkAccess);
+			sm.intest = false;
+		} finally {
+			System.setSecurityManager(null);
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#stop(java.lang.Throwable)
+	 */
+	public void test_stopLjava_lang_Throwable() {
+		// Test for method void java.lang.Thread.stop(java.lang.Throwable)
+		ResSupThread t = new ResSupThread(Thread.currentThread());
+		synchronized (t) {
+			st = new Thread(t, "StopThread");
+			st.setPriority(Thread.MAX_PRIORITY);
+			st.start();
+			try {
+				t.wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		try {
+			st.stop(new BogusException("Bogus"));
+			Thread.sleep(20000);
+		} catch (InterruptedException e) {
+			assertTrue("Stopped child with exception not alive", st.isAlive());
+			st.interrupt();
+			return;
+		}
+		st.interrupt();
+		fail("Stopped child did not throw exception");
+	}
+
+	/**
+	 * @tests java.lang.Thread#suspend()
+	 */
+	public void test_suspend() {
+		// Test for method void java.lang.Thread.suspend()
+		int orgval;
+		ResSupThread t = new ResSupThread(Thread.currentThread());
+		try {
+			synchronized (t) {
+				ct = new Thread(t, "Interupt Test6");
+				ct.start();
+				t.wait();
+			}
+			ct.suspend();
+			// Wait to be sure the suspend has occurred
+			Thread.sleep(500);
+			orgval = t.getCheckVal();
+			// Wait to be sure the thread is suspended
+			Thread.sleep(500);
+			assertTrue("Failed to suspend thread", orgval == t.getCheckVal());
+			ct.resume();
+			// Wait to be sure the resume has occurred.
+			Thread.sleep(500);
+			assertTrue("Failed to resume thread", orgval != t.getCheckVal());
+			ct.interrupt();
+		} catch (InterruptedException e) {
+			fail("Unexpected interrupt occurred");
+		}
+
+		final Object notify = new Object();
+		Thread t1 = new Thread(new Runnable() {
+			public void run() {
+				synchronized (notify) {
+					notify.notify();
+				}
+				Thread.currentThread().suspend();
+			}
+		});
+		try {
+			synchronized (notify) {
+				t1.start();
+				notify.wait();
+			}
+			// wait for Thread to suspend
+			Thread.sleep(500);
+			assertTrue("Thread should be alive", t1.isAlive());
+			t1.resume();
+			t1.join();
+		} catch (InterruptedException e) {
+		}
+	}
+
+	/**
+	 * @tests java.lang.Thread#toString()
+	 */
+	public void test_toString() {
+		// Test for method java.lang.String java.lang.Thread.toString()
+		ThreadGroup tg = new ThreadGroup("Test Group5");
+		st = new Thread(tg, new SimpleThread(1), "SimpleThread17");
+		final String stString = st.toString();
+		final String expected = "Thread[SimpleThread17,5,Test Group5]";
+		assertTrue("Returned incorrect string: " + stString + "\t(expecting :"
+				+ expected + ")", stString.equals(expected));
+		st.start();
+		try {
+			st.join();
+		} catch (InterruptedException e) {
+		}
+		tg.destroy();
+	}
+
+	/**
+	 * 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() {
+		try {
+			if (st != null)
+				st.interrupt();
+		} catch (Exception e) {
+		}
+		try {
+			if (spinner != null)
+				spinner.interrupt();
+		} catch (Exception e) {
+		}
+		try {
+			if (ct != null)
+				ct.interrupt();
+		} catch (Exception e) {
+		}
+
+		try {
+			spinner = null;
+			st = null;
+			ct = null;
+			System.runFinalization();
+		} catch (Exception e) {
+		}
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThrowableTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThrowableTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThrowableTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ThrowableTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,222 @@
+/* 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 tests.api.java.lang;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+
+public class ThrowableTest extends junit.framework.TestCase {
+
+	/**
+	 * @tests java.lang.Throwable#Throwable()
+	 */
+	public void test_Constructor() {
+		// Test for method java.lang.Throwable()
+		try {
+			if (true)
+				throw new Throwable();
+		} catch (Throwable e) {
+			return;
+		}
+		fail("Failed to throw Throwable");
+	}
+
+	/**
+	 * @tests java.lang.Throwable#Throwable(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// Test for method java.lang.Throwable(java.lang.String)
+		try {
+			if (true)
+				throw new Throwable("Throw");
+		} catch (Throwable e) {
+			assertTrue("Threw Throwable with incorrect message", e.getMessage()
+					.equals("Throw"));
+			return;
+		}
+		fail("Failed to throw Throwable");
+	}
+
+	/**
+	 * @tests java.lang.Throwable#fillInStackTrace()
+	 */
+	public void test_fillInStackTrace() {
+		// Test for method java.lang.Throwable
+		// java.lang.Throwable.fillInStackTrace()
+		class Test implements Runnable {
+			public int x;
+
+			public Test(int x) {
+				this.x = x;
+			}
+
+			public void anotherMethod() {
+				if (true)
+					throw new IndexOutOfBoundsException();
+			}
+
+			public void run() {
+				if (x == 0)
+					throw new IndexOutOfBoundsException();
+				try {
+					anotherMethod();
+				} catch (IndexOutOfBoundsException e) {
+					e.fillInStackTrace();
+					throw e;
+				}
+			}
+		}
+		ByteArrayOutputStream bao = new ByteArrayOutputStream();
+		PrintStream ps = new PrintStream(bao);
+		try {
+			new Test(0).run();
+		} catch (Throwable e) {
+			e.printStackTrace(ps);
+		}
+		ps.flush();
+		String s = fixStacktrace(new String(bao.toByteArray(), 0, bao.size()));
+
+		bao.reset();
+		try {
+			new Test(1).run();
+		} catch (Throwable e) {
+			e.printStackTrace(ps);
+		}
+		ps.close();
+		String s2 = fixStacktrace(new String(bao.toByteArray(), 0, bao.size()));
+		assertTrue("Invalid stackTrace? length: " + s2.length() + "\n" + s2, s2
+				.length() > 300);
+		assertTrue("Incorrect stackTrace printed: \n" + s2
+				+ "\n\nCompared with:\n" + s, s2.equals(s));
+	}
+
+	private String fixStacktrace(String trace) {
+		// remove linenumbers
+		StringBuffer sb = new StringBuffer();
+		int lastIndex = 0;
+		while (lastIndex < trace.length()) {
+			int index = trace.indexOf('\n', lastIndex);
+			if (index == -1)
+				index = trace.length();
+			String line = trace.substring(lastIndex, index);
+			lastIndex = index + 1;
+
+			index = line.indexOf("(");
+			if (index > -1) {
+				line = line.substring(0, index);
+			}
+			// Usually the construction of the exception is removed
+			// however if running with the JIT, it may not be removed
+			if (line.indexOf("java.lang.Throwable") > -1)
+				continue;
+			sb.append(line);
+			sb.append('\n');
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * @tests java.lang.Throwable#getMessage()
+	 */
+	public void test_getMessage() {
+		// Test for method java.lang.String java.lang.Throwable.getMessage()
+
+		Throwable x = new ClassNotFoundException("A Message");
+		assertTrue("Returned incorrect messasge string", x.getMessage().equals(
+				"A Message"));
+	}
+
+	/**
+	 * @tests java.lang.Throwable#printStackTrace()
+	 */
+	public void test_printStackTrace() {
+		// Test for method void java.lang.Throwable.printStackTrace()
+		Throwable x = new ClassNotFoundException("A Test Message");
+		ByteArrayOutputStream bao = new ByteArrayOutputStream();
+		PrintStream ps = new PrintStream(bao);
+		PrintStream err = System.err;
+		System.setErr(ps);
+		x.printStackTrace();
+		System.setErr(err);
+		ps.close();
+		String s = new String(bao.toByteArray(), 0, bao.size());
+		assertTrue("Incorrect stackTrace printed:\n" + s, s != null
+				&& s.length() > 400);
+	}
+
+	/**
+	 * @tests java.lang.Throwable#printStackTrace(java.io.PrintStream)
+	 */
+	public void test_printStackTraceLjava_io_PrintStream() {
+		// Test for method void
+		// java.lang.Throwable.printStackTrace(java.io.PrintStream)
+		ByteArrayOutputStream bao = new ByteArrayOutputStream();
+		PrintStream ps = new PrintStream(bao);
+		Throwable x = new java.net.UnknownHostException("A Message");
+		x.printStackTrace(ps);
+		ps.close();
+		String s = new String(bao.toByteArray(), 0, bao.size());
+		assertTrue("Incorrect stackTrace printed:\n" + s, s != null
+				&& s.length() > 400);
+	}
+
+	/**
+	 * @tests java.lang.Throwable#printStackTrace(java.io.PrintWriter)
+	 */
+	public void test_printStackTraceLjava_io_PrintWriter() {
+		// Test for method void
+		// java.lang.Throwable.printStackTrace(java.io.PrintWriter)
+		// SM
+		ByteArrayOutputStream bao = new ByteArrayOutputStream();
+		PrintWriter pw = new PrintWriter(bao);
+		Throwable x = new java.net.UnknownHostException("A Message");
+		x.printStackTrace(pw);
+		pw.close();
+		String s = new String(bao.toByteArray(), 0, bao.size());
+		assertTrue("Incorrect stackTrace printed:\n" + s, s != null
+				&& s.length() > 400);
+	}
+
+	/**
+	 * @tests java.lang.Throwable#toString()
+	 */
+	public void test_toString() {
+		// Test for method java.lang.String java.lang.Throwable.toString()
+		try {
+			if (true)
+				throw new Throwable("Throw");
+		} catch (Throwable e) {
+			assertTrue("Threw Throwable with incorrect string", e.toString()
+					.equals("java.lang.Throwable: Throw"));
+			return;
+		}
+		fail("Failed to throw Throwable");
+	}
+
+	/**
+	 * 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() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnknownErrorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnknownErrorTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnknownErrorTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnknownErrorTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,63 @@
+/* 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 tests.api.java.lang;
+
+public class UnknownErrorTest extends junit.framework.TestCase {
+
+	/**
+	 * @tests java.lang.UnknownError#UnknownError()
+	 */
+	public void test_Constructor() {
+		// Test for method java.lang.UnknownError()
+		try {
+			if (true)
+				throw new UnknownError();
+		} catch (UnknownError e) {
+			return;
+		}
+		fail("Failed to generate error");
+	}
+
+	/**
+	 * @tests java.lang.UnknownError#UnknownError(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// Test for method java.lang.UnknownError(java.lang.String)
+		try {
+			if (true)
+				throw new UnknownError("Unknown");
+		} catch (UnknownError e) {
+			assertTrue(" Incorrect msg string ", e.getMessage().equals(
+					"Unknown"));
+			return;
+		}
+		fail("Failed to generate error");
+	}
+
+	/**
+	 * 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() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsatisfiedLinkErrorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsatisfiedLinkErrorTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsatisfiedLinkErrorTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsatisfiedLinkErrorTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,58 @@
+/* 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 tests.api.java.lang;
+
+public class UnsatisfiedLinkErrorTest extends junit.framework.TestCase {
+
+	/**
+	 * @tests java.lang.UnsatisfiedLinkError#UnsatisfiedLinkError()
+	 */
+	public void test_Constructor() {
+		// SM.
+		try {
+			if (true)
+				throw new UnsatisfiedLinkError();
+		} catch (UnsatisfiedLinkError e) {
+			assertTrue("Initializer failed.", e.getMessage() == null);
+			assertTrue("To string failed.", e.toString().equals(
+					"java.lang.UnsatisfiedLinkError"));
+		}
+	}
+
+	/**
+	 * @tests java.lang.UnsatisfiedLinkError#UnsatisfiedLinkError(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// TODO : No method throws this error.
+		boolean exception = false;
+		try {
+			Runtime.getRuntime().loadLibrary("Hello World89797");
+		} catch (UnsatisfiedLinkError e) {
+			assertTrue("Does not set message", e.getMessage() != null);
+			exception = true;
+		}
+		assertTrue("Does not throw UnsatisfiedLinkError", exception);
+
+		UnsatisfiedLinkError err = new UnsatisfiedLinkError("my message");
+		assertTrue("Incorrect message", "my message".equals(err.getMessage()));
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsupportedOperationExceptionTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsupportedOperationExceptionTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsupportedOperationExceptionTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/UnsupportedOperationExceptionTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,79 @@
+/* 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 tests.api.java.lang;
+
+import java.util.AbstractCollection;
+import java.util.Iterator;
+
+public class UnsupportedOperationExceptionTest extends junit.framework.TestCase {
+
+	/**
+	 * @tests java.lang.UnsupportedOperationException#UnsupportedOperationException()
+	 */
+	public void test_Constructor() {
+		// Test for method java.lang.UnsupportedOperationException()
+		class UnsupportedCollection extends AbstractCollection {
+			public int size() {
+				return 0;
+			}
+
+			public Iterator iterator() {
+				return null;
+			}
+		}
+		try {
+			UnsupportedCollection uc = new UnsupportedCollection();
+			uc.add(new Object());
+		} catch (UnsupportedOperationException e) {
+			return;
+		} catch (Exception e) {
+			fail("Exception during Constructor : " + e.getMessage());
+		}
+		fail("Constructor failed.");
+	}
+
+	/**
+	 * @tests java.lang.UnsupportedOperationException#UnsupportedOperationException(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// Test for method
+		// java.lang.UnsupportedOperationException(java.lang.String)
+		try {
+			throw new UnsupportedOperationException("HelloWorld");
+		} catch (UnsupportedOperationException e) {
+			assertTrue("Wrong message given.", e.getMessage().equals(
+					"HelloWorld"));
+			return;
+		} catch (Exception e) {
+			fail("Exception during Constructor : " + e.getMessage());
+		}
+		fail("Constructor failed");
+	}
+
+	/**
+	 * 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() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VerifyErrorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VerifyErrorTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VerifyErrorTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VerifyErrorTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,53 @@
+/* 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 tests.api.java.lang;
+
+public class VerifyErrorTest extends junit.framework.TestCase {
+
+	/**
+	 * @tests java.lang.VerifyError#VerifyError()
+	 */
+	public void test_Constructor() {
+		try {
+			if (true)
+				throw new VerifyError();
+		} catch (VerifyError e) {
+			return;
+		}
+		fail("Constructor failed");
+	}
+
+	/**
+	 * @tests java.lang.VerifyError#VerifyError(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		try {
+			if (true)
+				throw new VerifyError("HelloWorld");
+		} catch (VerifyError e) {
+			assertTrue("VerifyError(String) failed.", e.getMessage().equals(
+					"HelloWorld"));
+			return;
+		}
+		fail("Constructor failed");
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VirtualMachineErrorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VirtualMachineErrorTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VirtualMachineErrorTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/VirtualMachineErrorTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,74 @@
+/* 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 tests.api.java.lang;
+
+public class VirtualMachineErrorTest extends junit.framework.TestCase {
+
+	public class TestVirtualMachineError extends VirtualMachineError {
+		public TestVirtualMachineError() {
+			super();
+		}
+
+		public TestVirtualMachineError(String detailMessage) {
+			super(detailMessage);
+		}
+	}
+
+	/**
+	 * @tests java.lang.VirtualMachineError#VirtualMachineError()
+	 */
+	public void test_Constructor() {
+		// Test for method java.lang.VirtualMachineError()
+		// Tested more via subclasses (i.e. StackOverFlowError).
+		try {
+			if (true)
+				throw new TestVirtualMachineError();
+		} catch (VirtualMachineError e) {
+			return;
+		}
+		fail("Constructor failed");
+	}
+
+	/**
+	 * @tests java.lang.VirtualMachineError#VirtualMachineError(java.lang.String)
+	 */
+	public void test_ConstructorLjava_lang_String() {
+		// Test for method java.lang.VirtualMachineError(java.lang.String)
+		// Tested more via subclasses (i.e. StackOverFlowError).
+		try {
+			if (true)
+				throw new TestVirtualMachineError("HelloWorld");
+		} catch (VirtualMachineError e) {
+			assertTrue("VerifyError(String) failed.", e.getMessage().equals(
+					"HelloWorld"));
+			return;
+		}
+		fail("Constructor failed");
+	}
+
+	/**
+	 * 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() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/AllTests.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/AllTests.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/AllTests.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/AllTests.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,41 @@
+/* Copyright 2004 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 tests.api.java.lang.ref;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Test suite for java.lang.ref package.
+ */
+public class AllTests {
+
+	public static void main(String[] args) {
+		junit.textui.TestRunner.run(suite());
+	}
+
+	public static Test suite() {
+		TestSuite suite = new TestSuite("Tests for java.lang.ref");
+		// $JUnit-BEGIN$
+		suite.addTestSuite(PhantomReferenceTest.class);
+		suite.addTestSuite(ReferenceTest.class);
+		suite.addTestSuite(ReferenceQueueTest.class);
+		suite.addTestSuite(SoftReferenceTest.class);
+		suite.addTestSuite(WeakReferenceTest.class);
+		// $JUnit-END$
+		return suite;
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,70 @@
+/* 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 tests.api.java.lang.ref;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+public class PhantomReferenceTest extends junit.framework.TestCase {
+	static Boolean bool;
+
+	protected void doneSuite() {
+		bool = null;
+	}
+
+	/**
+	 * @tests java.lang.ref.PhantomReference#get()
+	 */
+	public void test_get() {
+		ReferenceQueue rq = new ReferenceQueue();
+		bool = new Boolean(false);
+		PhantomReference pr = new PhantomReference(bool, rq);
+		assertTrue("Same object returned.", pr.get() == null);
+	}
+
+	/**
+	 * @tests java.lang.ref.PhantomReference#PhantomReference(java.lang.Object,
+	 *        java.lang.ref.ReferenceQueue)
+	 */
+	public void test_ConstructorLjava_lang_ObjectLjava_lang_ref_ReferenceQueue() {
+		ReferenceQueue rq = new ReferenceQueue();
+		bool = new Boolean(true);
+		try {
+			PhantomReference pr = new PhantomReference(bool, rq);
+			// Allow the finalizer to run to potentially enqueue
+			Thread.sleep(1000);
+			assertTrue("Initialization failed.", !pr.isEnqueued());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+		// need a reference to bool so the jit does not optimize it away
+		assertTrue("should always pass", bool.booleanValue());
+
+		boolean exception = false;
+		try {
+			new PhantomReference(bool, null);
+		} catch (NullPointerException e) {
+			exception = true;
+		}
+		assertTrue("Should not throw NullPointerException", !exception);
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,120 @@
+/* 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 tests.api.java.lang.ref;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class ReferenceQueueTest extends junit.framework.TestCase {
+	static Boolean b;
+
+	static Integer integer;
+
+	protected void doneSuite() {
+		b = null;
+		integer = null;
+	}
+
+	public class ChildThread implements Runnable {
+		public ChildThread() {
+		}
+
+		public void run() {
+			try {
+				rq.wait(1000);
+			} catch (Exception e) {
+			}
+			synchronized (rq) {
+				// store in a static so it won't be gc'ed because the jit
+				// optimized it out
+				integer = new Integer(667);
+				SoftReference sr = new SoftReference(integer, rq);
+				sr.enqueue();
+				rq.notify();
+			}
+		}
+	}
+
+	ReferenceQueue rq;
+
+	/**
+	 * @tests java.lang.ref.ReferenceQueue#poll()
+	 */
+	public void test_poll() {
+		// store in a static so it won't be gc'ed because the jit
+		// optimized it out
+		b = new Boolean(true);
+		SoftReference sr = new SoftReference(b, rq);
+		sr.enqueue();
+		try {
+			assertTrue("Remove failed.", ((Boolean) rq.poll().get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during the test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.ref.ReferenceQueue#remove()
+	 */
+	public void test_remove() {
+		// store in a static so it won't be gc'ed because the jit
+		// optimized it out
+		b = new Boolean(true);
+		SoftReference sr = new SoftReference(b, rq);
+		sr.enqueue();
+		try {
+			assertTrue("Remove failed.", ((Boolean) rq.remove().get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during the test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.ref.ReferenceQueue#remove(long)
+	 */
+	public void test_removeJ() {
+		try {
+			assertTrue("Queue is empty.", rq.poll() == null);
+			assertTrue("Queue is empty.", rq.remove((long) 1) == null);
+			Thread ct = new Thread(new ChildThread());
+			ct.start();
+			Reference ret = rq.remove(0L);
+			assertTrue("Delayed remove failed.", ret != null);
+		} catch (InterruptedException e) {
+			fail("InterruptedExeException during test : " + e.getMessage());
+		}
+		catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.ref.ReferenceQueue#ReferenceQueue()
+	 */
+	public void test_Constructor() {
+		assertTrue("Used for testing.", true);
+	}
+
+	protected void setUp() {
+		rq = new ReferenceQueue();
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,171 @@
+/* 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 tests.api.java.lang.ref;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+
+public class ReferenceTest extends junit.framework.TestCase {
+	Object tmpA, tmpB, obj;
+
+	volatile WeakReference wr;
+
+	protected void doneSuite() {
+		tmpA = tmpB = obj = null;
+	}
+
+	/**
+	 * @tests java.lang.ref.Reference#clear()
+	 */
+	public void test_clear() {
+		tmpA = new Object();
+		tmpB = new Object();
+		SoftReference sr = new SoftReference(tmpA, new ReferenceQueue());
+		WeakReference wr = new WeakReference(tmpB, new ReferenceQueue());
+		assertTrue("Start: Object not cleared.", (sr.get() != null)
+				&& (wr.get() != null));
+		sr.clear();
+		wr.clear();
+		assertTrue("End: Object cleared.", (sr.get() == null)
+				&& (wr.get() == null));
+		// Must reference tmpA and tmpB so the jit does not optimize them away
+		assertTrue("should always pass", tmpA != sr.get() && tmpB != wr.get());
+	}
+
+	/**
+	 * @tests java.lang.ref.Reference#enqueue()
+	 */
+	public void test_enqueue() {
+		ReferenceQueue rq = new ReferenceQueue();
+		obj = new Object();
+		Reference ref = new SoftReference(obj, rq);
+		assertTrue("Enqueue failed.", (!ref.isEnqueued())
+				&& ((ref.enqueue()) && (ref.isEnqueued())));
+		assertTrue("Not properly enqueued.", rq.poll().get() == obj);
+		// This fails...
+		assertTrue("Should remain enqueued.", !ref.isEnqueued());
+		assertTrue("Can not enqueue twice.", (!ref.enqueue())
+				&& (rq.poll() == null));
+
+		rq = new ReferenceQueue();
+		obj = new Object();
+		ref = new WeakReference(obj, rq);
+		assertTrue("Enqueue failed2.", (!ref.isEnqueued())
+				&& ((ref.enqueue()) && (ref.isEnqueued())));
+		assertTrue("Not properly enqueued2.", rq.poll().get() == obj);
+		assertTrue("Should remain enqueued2.", !ref.isEnqueued()); // This
+		// fails.
+		assertTrue("Can not enqueue twice2.", (!ref.enqueue())
+				&& (rq.poll() == null));
+	}
+
+	/**
+	 * @tests java.lang.ref.Reference#enqueue()
+	 */
+	public void test_general() {
+		// Test the general/overall functionality of Reference.
+
+		class TestObject {
+			public boolean finalized;
+
+			public TestObject() {
+				finalized = false;
+			}
+
+			protected void finalize() {
+				finalized = true;
+			}
+		}
+
+		final ReferenceQueue rq = new ReferenceQueue();
+
+		class TestThread extends Thread {
+			public void run() {
+				// Create the object in a separate thread to ensure it will be
+				// gc'ed
+				Object testObj = new TestObject();
+				wr = new WeakReference(testObj, rq);
+				testObj = null;
+			}
+		}
+
+		Reference ref;
+
+		try {
+			Thread t = new TestThread();
+			t.start();
+			t.join();
+			System.gc();
+			System.runFinalization();
+			ref = rq.remove();
+			assertTrue("Unexpected ref1", ref == wr);
+			assertTrue("Object not garbage collected1.", ref != null);
+			assertTrue("Object could not be reclaimed1.", wr.get() == null);
+		} catch (InterruptedException e) {
+			fail("InterruptedException : " + e.getMessage());
+		}
+
+		try {
+			Thread t = new TestThread();
+			t.start();
+			t.join();
+			System.gc();
+			System.runFinalization();
+			ref = rq.poll();
+			assertTrue("Unexpected ref2", ref == wr);
+			assertTrue("Object not garbage collected.", ref != null);
+			assertTrue("Object could not be reclaimed.", ref.get() == null);
+			// Reference wr so it does not get collected
+			assertTrue("Object could not be reclaimed.", wr.get() == null);
+		} catch (Exception e) {
+			fail("Exception : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.ref.Reference#get()
+	 */
+	public void test_get() {
+		// SM.
+		obj = new Object();
+		Reference ref = new WeakReference(obj, new ReferenceQueue());
+		assertTrue("Get succeeded.", ref.get() == obj);
+	}
+
+	/**
+	 * @tests java.lang.ref.Reference#isEnqueued()
+	 */
+	public void test_isEnqueued() {
+		ReferenceQueue rq = new ReferenceQueue();
+		obj = new Object();
+		Reference ref = new SoftReference(obj, rq);
+		assertTrue("Should start off not enqueued.", !ref.isEnqueued());
+		ref.enqueue();
+		assertTrue("Should now be enqueued.", ref.isEnqueued());
+		ref.enqueue();
+		assertTrue("Should still be enqueued.", ref.isEnqueued());
+		rq.poll();
+		// This fails ...
+		assertTrue("Should now be not enqueued.", !ref.isEnqueued());
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,79 @@
+/* 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 tests.api.java.lang.ref;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class SoftReferenceTest extends junit.framework.TestCase {
+	static Boolean bool;
+
+	protected void doneSuite() {
+		bool = null;
+	}
+
+	/**
+	 * @tests java.lang.ref.SoftReference#SoftReference(java.lang.Object,
+	 *        java.lang.ref.ReferenceQueue)
+	 */
+	public void test_ConstructorLjava_lang_ObjectLjava_lang_ref_ReferenceQueue() {
+		ReferenceQueue rq = new ReferenceQueue();
+		bool = new Boolean(true);
+		try {
+			SoftReference sr = new SoftReference(bool, rq);
+			assertTrue("Initialization failed.", ((Boolean) sr.get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+
+		boolean exception = false;
+		try {
+			new SoftReference(bool, null);
+		} catch (NullPointerException e) {
+			exception = true;
+		}
+		assertTrue("Should not throw NullPointerException", !exception);
+	}
+
+	/**
+	 * @tests java.lang.ref.SoftReference#SoftReference(java.lang.Object)
+	 */
+	public void test_ConstructorLjava_lang_Object() {
+		bool = new Boolean(true);
+		try {
+			SoftReference sr = new SoftReference(bool);
+			assertTrue("Initialization failed.", ((Boolean) sr.get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.ref.SoftReference#get()
+	 */
+	public void test_get() {
+		bool = new Boolean(false);
+		SoftReference sr = new SoftReference(bool);
+		assertTrue("Same object not returned.", bool == sr.get());
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/WeakReferenceTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/WeakReferenceTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/WeakReferenceTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/ref/WeakReferenceTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,78 @@
+/* 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 tests.api.java.lang.ref;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class WeakReferenceTest extends junit.framework.TestCase {
+	static Boolean bool;
+
+	protected void doneSuite() {
+		bool = null;
+	}
+
+	/**
+	 * @tests java.lang.ref.WeakReference#WeakReference(java.lang.Object,
+	 *        java.lang.ref.ReferenceQueue)
+	 */
+	public void test_ConstructorLjava_lang_ObjectLjava_lang_ref_ReferenceQueue() {
+		ReferenceQueue rq = new ReferenceQueue();
+		bool = new Boolean(true);
+		try {
+			// Allow the finalizer to run to potentially enqueue
+			WeakReference wr = new WeakReference(bool, rq);
+			assertTrue("Initialization failed.", ((Boolean) wr.get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+		// need a reference to bool so the jit does not optimize it away
+		assertTrue("should always pass", bool.booleanValue());
+
+		boolean exception = false;
+		try {
+			new WeakReference(bool, null);
+		} catch (NullPointerException e) {
+			exception = true;
+		}
+		assertTrue("Should not throw NullPointerException", !exception);
+	}
+
+	/**
+	 * @tests java.lang.ref.WeakReference#WeakReference(java.lang.Object)
+	 */
+	public void test_ConstructorLjava_lang_Object() {
+		bool = new Boolean(true);
+		try {
+			WeakReference wr = new WeakReference(bool);
+			// Allow the finalizer to run to potentially enqueue
+			Thread.sleep(1000);
+			assertTrue("Initialization failed.", ((Boolean) wr.get())
+					.booleanValue());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+		// need a reference to bool so the jit does not optimize it away
+		assertTrue("should always pass", bool.booleanValue());
+	}
+
+	protected void setUp() {
+	}
+
+	protected void tearDown() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AccessibleObjectTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AccessibleObjectTest.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AccessibleObjectTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AccessibleObjectTest.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,85 @@
+/* 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 tests.api.java.lang.reflect;
+
+import java.lang.reflect.AccessibleObject;
+
+public class AccessibleObjectTest extends junit.framework.TestCase {
+
+	public class TestClass {
+		public Object aField;
+	}
+
+	/**
+	 * @tests java.lang.reflect.AccessibleObject#isAccessible()
+	 */
+	public void test_isAccessible() {
+		// Test for method boolean
+		// java.lang.reflect.AccessibleObject.isAccessible()
+		try {
+			AccessibleObject ao = TestClass.class.getField("aField");
+			ao.setAccessible(true);
+			assertTrue("Returned false to isAccessible", ao.isAccessible());
+			ao.setAccessible(false);
+			assertTrue("Returned true to isAccessible", !ao.isAccessible());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.reflect.AccessibleObject#setAccessible(java.lang.reflect.AccessibleObject[],
+	 *        boolean)
+	 */
+	public void test_setAccessible$Ljava_lang_reflect_AccessibleObjectZ() {
+		// Test for method void
+		// java.lang.reflect.AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject
+		// [], boolean)
+		try {
+			AccessibleObject ao = TestClass.class.getField("aField");
+			AccessibleObject[] aoa = new AccessibleObject[] { ao };
+			AccessibleObject.setAccessible(aoa, true);
+			assertTrue("Returned false to isAccessible", ao.isAccessible());
+			AccessibleObject.setAccessible(aoa, false);
+			assertTrue("Returned true to isAccessible", !ao.isAccessible());
+		} catch (Exception e) {
+			fail("Exception during test : " + e.getMessage());
+		}
+	}
+
+	/**
+	 * @tests java.lang.reflect.AccessibleObject#setAccessible(boolean)
+	 */
+	public void test_setAccessibleZ() {
+		// Test for method void
+		// java.lang.reflect.AccessibleObject.setAccessible(boolean)
+		assertTrue("Used to test", true);
+	}
+
+	/**
+	 * 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() {
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AllTests.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AllTests.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AllTests.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/lang/reflect/AllTests.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,45 @@
+/* Copyright 2004 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 tests.api.java.lang.reflect;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Test suite for java.lang.reflect package.
+ */
+public class AllTests {
+
+	public static void main(String[] args) {
+		junit.textui.TestRunner.run(suite());
+	}
+
+	public static Test suite() {
+		TestSuite suite = new TestSuite("Tests for java.lang.reflect");
+		// $JUnit-BEGIN$
+		suite.addTestSuite(AccessibleObjectTest.class);
+		suite.addTestSuite(ArrayTest.class);
+		suite.addTestSuite(ConstructorTest.class);
+		suite.addTestSuite(FieldTest.class);
+		suite.addTestSuite(InvocationTargetExceptionTest.class);
+		suite.addTestSuite(MethodTest.class);
+		suite.addTestSuite(ModifierTest.class);
+		suite.addTestSuite(ProxyTest.class);
+		suite.addTestSuite(ReflectPermissionTest.class);
+		// $JUnit-END$
+		return suite;
+	}
+}



Mime
View raw message