Initial load
diff --git a/test/java/lang/Thread/ThreadStateTest.java b/test/java/lang/Thread/ThreadStateTest.java
new file mode 100644
index 0000000..c658e0c
--- /dev/null
+++ b/test/java/lang/Thread/ThreadStateTest.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @test
+ * @bug 5014783
+ * @summary Basic unit test of thread states returned by
+ * Thread.getState().
+ *
+ * @author Mandy Chung
+ *
+ * @build ThreadStateTest
+ * @run main ThreadStateTest
+ */
+
+import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.Semaphore;
+
+public class ThreadStateTest {
+ private static boolean testFailed = false;
+
+ static class Lock {
+ private String name;
+ Lock(String name) {
+ this.name = name;
+ }
+ public String toString() {
+ return name;
+ }
+ }
+ private static Lock globalLock = new Lock("my lock");
+
+ public static void main(String[] argv) {
+ // Call Thread.getState to force all initialization done
+ // before test verification begins.
+ Thread.currentThread().getState();
+ MyThread myThread = new MyThread("MyThread");
+
+ // before myThread starts
+ checkThreadState(myThread, Thread.State.NEW);
+
+ myThread.start();
+ myThread.waitUntilStarted();
+ checkThreadState(myThread, Thread.State.RUNNABLE);
+
+ synchronized (globalLock) {
+ myThread.goBlocked();
+ checkThreadState(myThread, Thread.State.BLOCKED);
+ }
+
+ myThread.goWaiting();
+ checkThreadState(myThread, Thread.State.WAITING);
+
+ myThread.goTimedWaiting();
+ checkThreadState(myThread, Thread.State.TIMED_WAITING);
+
+
+ /*
+ *********** park and parkUntil seems not working
+ * ignore this case for now.
+ * Bug ID 5062095
+ ***********************************************
+
+ myThread.goParked();
+ checkThreadState(myThread, Thread.State.WAITING);
+
+ myThread.goTimedParked();
+ checkThreadState(myThread, Thread.State.TIMED_WAITING);
+ */
+
+
+ myThread.goSleeping();
+ checkThreadState(myThread, Thread.State.TIMED_WAITING);
+
+ myThread.terminate();
+ checkThreadState(myThread, Thread.State.TERMINATED);
+
+ try {
+ myThread.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ System.out.println("Unexpected exception.");
+ testFailed = true;
+ }
+ if (testFailed)
+ throw new RuntimeException("TEST FAILED.");
+ System.out.println("Test passed.");
+ }
+
+ private static void checkThreadState(Thread t, Thread.State expected) {
+ Thread.State state = t.getState();
+ System.out.println("Checking thread state " + state);
+ if (state == null) {
+ throw new RuntimeException(t.getName() + " expected to have " +
+ expected + " but got null.");
+ }
+
+ if (state != expected) {
+ throw new RuntimeException(t.getName() + " expected to have " +
+ expected + " but got " + state);
+ }
+ }
+
+ private static String getLockName(Object lock) {
+ if (lock == null) return null;
+
+ return lock.getClass().getName() + '@' +
+ Integer.toHexString(System.identityHashCode(lock));
+ }
+
+ private static void goSleep(long ms) {
+ try {
+ Thread.sleep(ms);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ System.out.println("Unexpected exception.");
+ testFailed = true;
+ }
+ }
+
+ static class MyThread extends Thread {
+ private ThreadExecutionSynchronizer thrsync = new ThreadExecutionSynchronizer();
+
+ MyThread(String name) {
+ super(name);
+ }
+
+ private final int RUNNABLE = 0;
+ private final int BLOCKED = 1;
+ private final int WAITING = 2;
+ private final int TIMED_WAITING = 3;
+ private final int PARKED = 4;
+ private final int TIMED_PARKED = 5;
+ private final int SLEEPING = 6;
+ private final int TERMINATE = 7;
+ private int state = RUNNABLE;
+
+ private boolean done = false;
+ public void run() {
+ // Signal main thread to continue.
+ thrsync.signal();
+ while (!done) {
+ switch (state) {
+ case RUNNABLE: {
+ double sum = 0;
+ for (int i = 0; i < 1000; i++) {
+ double r = Math.random();
+ double x = Math.pow(3, r);
+ sum += x - r;
+ }
+ break;
+ }
+ case BLOCKED: {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to block.");
+ synchronized (globalLock) {
+ // finish blocking
+ state = RUNNABLE;
+ }
+ break;
+ }
+ case WAITING: {
+ synchronized (globalLock) {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to wait.");
+ try {
+ globalLock.wait();
+ } catch (InterruptedException e) {
+ // ignore
+ }
+ }
+ break;
+ }
+ case TIMED_WAITING: {
+ synchronized (globalLock) {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to timed wait.");
+ try {
+ globalLock.wait(10000);
+ } catch (InterruptedException e) {
+ // ignore
+ }
+ }
+ break;
+ }
+ case PARKED: {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to park.");
+ LockSupport.park();
+ // give a chance for the main thread to block
+ goSleep(10);
+ break;
+ }
+ case TIMED_PARKED: {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to timed park.");
+ long deadline = System.currentTimeMillis() + 10000*1000;
+ LockSupport.parkUntil(deadline);
+
+ // give a chance for the main thread to block
+ goSleep(10);
+ break;
+ }
+ case SLEEPING: {
+ // signal main thread.
+ thrsync.signal();
+ System.out.println(" myThread is going to sleep.");
+ try {
+ Thread.sleep(1000000);
+ } catch (InterruptedException e) {
+ // finish sleeping
+ interrupted();
+ }
+ break;
+ }
+ case TERMINATE: {
+ done = true;
+ // signal main thread.
+ thrsync.signal();
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ }
+ public void waitUntilStarted() {
+ // wait for MyThread.
+ thrsync.waitForSignal();
+ goSleep(10);
+ }
+
+ public void goBlocked() {
+ System.out.println("Waiting myThread to go blocked.");
+ setState(BLOCKED);
+ // wait for MyThread to get blocked
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+
+ public void goWaiting() {
+ System.out.println("Waiting myThread to go waiting.");
+ setState(WAITING);
+ // wait for MyThread to wait on object.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+ public void goTimedWaiting() {
+ System.out.println("Waiting myThread to go timed waiting.");
+ setState(TIMED_WAITING);
+ // wait for MyThread timed wait call.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+ public void goParked() {
+ System.out.println("Waiting myThread to go parked.");
+ setState(PARKED);
+ // wait for MyThread state change to PARKED.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+ public void goTimedParked() {
+ System.out.println("Waiting myThread to go timed parked.");
+ setState(TIMED_PARKED);
+ // wait for MyThread.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+
+ public void goSleeping() {
+ System.out.println("Waiting myThread to go sleeping.");
+ setState(SLEEPING);
+ // wait for MyThread.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+ public void terminate() {
+ System.out.println("Waiting myThread to terminate.");
+ setState(TERMINATE);
+ // wait for MyThread.
+ thrsync.waitForSignal();
+ goSleep(20);
+ }
+
+ private void setState(int newState) {
+ switch (state) {
+ case BLOCKED:
+ while (state == BLOCKED) {
+ goSleep(20);
+ }
+ state = newState;
+ break;
+ case WAITING:
+ case TIMED_WAITING:
+ state = newState;
+ synchronized (globalLock) {
+ globalLock.notify();
+ }
+ break;
+ case PARKED:
+ case TIMED_PARKED:
+ state = newState;
+ LockSupport.unpark(this);
+ break;
+ case SLEEPING:
+ state = newState;
+ this.interrupt();
+ break;
+ default:
+ state = newState;
+ break;
+ }
+ }
+ }
+
+
+
+ static class ThreadExecutionSynchronizer {
+
+ private boolean waiting;
+ private Semaphore semaphore;
+
+ public ThreadExecutionSynchronizer() {
+ semaphore = new Semaphore(1);
+ waiting = false;
+ }
+
+ // Synchronizes two threads execution points.
+ // Basically any thread could get scheduled to run and
+ // it is not possible to know which thread reaches expected
+ // execution point. So whichever thread reaches a execution
+ // point first wait for the second thread. When the second thread
+ // reaches the expected execution point will wake up
+ // the thread which is waiting here.
+ void stopOrGo() {
+ semaphore.acquireUninterruptibly(); // Thread can get blocked.
+ if (!waiting) {
+ waiting = true;
+ // Wait for second thread to enter this method.
+ while(!semaphore.hasQueuedThreads()) {
+ try {
+ Thread.sleep(20);
+ } catch (InterruptedException xx) {}
+ }
+ semaphore.release();
+ } else {
+ waiting = false;
+ semaphore.release();
+ }
+ }
+
+ // Wrapper function just for code readability.
+ void waitForSignal() {
+ stopOrGo();
+ }
+
+ void signal() {
+ stopOrGo();
+ }
+ }
+}