--- old/test/java/lang/Thread/ThreadStateTest.java	Tue Nov  5 12:27:27 2013
+++ new/test/java/lang/Thread/ThreadStateTest.java	Tue Nov  5 12:27:27 2013
@@ -21,77 +21,64 @@
  * questions.
  */
 
+import static java.lang.Thread.State.*;
+
 /*
  * @test
- * @bug     5014783
+ * @bug     5014783 8022208
  * @summary Basic unit test of thread states returned by
  *          Thread.getState().
  *
  * @author  Mandy Chung
- *
- * @build ThreadStateTest
+ * @build ThreadStateTest ThreadStateController
  * @run main ThreadStateTest
  */
 
-import java.util.concurrent.locks.LockSupport;
-import java.util.concurrent.Phaser;
-
 public class ThreadStateTest {
-    // maximum number of retries when checking for thread state.
-    static final int MAX_RETRY = 500;
-
     private static boolean testFailed = false;
 
     // used to achieve waiting states
-    static final Object globalLock = new Object();
+    private static final Object globalLock = new Object();
 
-    public static void main(String[] argv) {
+    public static void main(String[] argv) throws Exception {
         // Call Thread.getState to force all initialization done
         // before test verification begins.
         Thread.currentThread().getState();
-        MyThread myThread = new MyThread("MyThread");
+        ThreadStateController thread = new ThreadStateController("StateChanger", globalLock);
+        thread.setDaemon(true);
 
         // before myThread starts
-        checkThreadState(myThread, Thread.State.NEW);
+        thread.checkThreadState(NEW);
 
-        myThread.start();
-        myThread.waitUntilStarted();
-        checkThreadState(myThread, Thread.State.RUNNABLE);
+        thread.start();
+        thread.transitionTo(RUNNABLE);
+        thread.checkThreadState(RUNNABLE);
 
         synchronized (globalLock) {
-            myThread.goBlocked();
-            checkThreadState(myThread, Thread.State.BLOCKED);
+            thread.transitionTo(BLOCKED);
+            thread.checkThreadState(BLOCKED);
         }
 
-        myThread.goWaiting();
-        checkThreadState(myThread, Thread.State.WAITING);
+        thread.transitionTo(WAITING);
+        thread.checkThreadState(WAITING);
 
-        myThread.goTimedWaiting();
-        checkThreadState(myThread, Thread.State.TIMED_WAITING);
+        thread.transitionTo(TIMED_WAITING);
+        thread.checkThreadState(TIMED_WAITING);
 
+        thread.transitionToPark(true /* timed park*/);
+        thread.checkThreadState(TIMED_WAITING);
 
-      /*
-       *********** park and parkUntil seems not working
-       * ignore this case for now.
-       * Bug ID 5062095
-       ***********************************************
+        thread.transitionToPark(false /* indefinite park */);
+        thread.checkThreadState(WAITING);
 
-        myThread.goParked();
-        checkThreadState(myThread, Thread.State.WAITING);
+        thread.transitionToSleep();
+        thread.checkThreadState(TIMED_WAITING);
 
-        myThread.goTimedParked();
-        checkThreadState(myThread, Thread.State.TIMED_WAITING);
-       */
+        thread.transitionTo(TERMINATED);
+        thread.checkThreadState(TERMINATED);
 
-
-        myThread.goSleeping();
-        checkThreadState(myThread, Thread.State.TIMED_WAITING);
-
-        myThread.terminate();
-        checkThreadState(myThread, Thread.State.TERMINATED);
-
         try {
-            myThread.join();
+            thread.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
             System.out.println("Unexpected exception.");
@@ -102,241 +89,4 @@
             throw new RuntimeException("TEST FAILED.");
         System.out.println("Test passed.");
     }
-
-    private static void checkThreadState(Thread t, Thread.State expected) {
-        // wait for the thread to transition to the expected state.
-        // There is a small window between the thread checking the state
-        // and the thread actual entering that state.
-        Thread.State state;
-        int retryCount=0;
-        while ((state = t.getState()) != expected && retryCount < MAX_RETRY) {
-            if (state != Thread.State.RUNNABLE) {
-                throw new RuntimeException("Thread not in expected state yet," +
-                        " but it should at least be RUNNABLE");
-            }
-            goSleep(10);
-            retryCount++;
-        }
-
-        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 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 {
-        // Phaser to sync between the main thread putting
-        // this thread into various states
-        private Phaser phaser =  new Phaser(2);
-
-        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 volatile int state = RUNNABLE;
-
-        private boolean done = false;
-        public void run() {
-            // Signal main thread to continue.
-            phaser.arriveAndAwaitAdvance();
-
-            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.
-                        phaser.arrive();
-                        System.out.println("  myThread is going to block.");
-                        synchronized (globalLock) {
-                            // finish blocking
-                            state = RUNNABLE;
-                        }
-                        break;
-                    }
-                    case WAITING: {
-                        synchronized (globalLock) {
-                            // signal main thread.
-                            phaser.arrive();
-                            System.out.println("  myThread is going to wait.");
-                            try {
-                                globalLock.wait();
-                            } catch (InterruptedException e) {
-                                // ignore
-                            }
-                        }
-                        break;
-                    }
-                    case TIMED_WAITING: {
-                        synchronized (globalLock) {
-                            // signal main thread.
-                            phaser.arrive();
-                            System.out.println("  myThread is going to timed wait.");
-                            try {
-                                globalLock.wait(10000);
-                            } catch (InterruptedException e) {
-                                // ignore
-                            }
-                        }
-                        break;
-                    }
-                    case PARKED: {
-                        // signal main thread.
-                        phaser.arrive();
-                        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.
-                        phaser.arrive();
-                        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.
-                        phaser.arrive();
-                        System.out.println("  myThread is going to sleep.");
-                        try {
-                            Thread.sleep(1000000);
-                        } catch (InterruptedException e) {
-                            // finish sleeping
-                        }
-                        break;
-                    }
-                    case TERMINATE: {
-                        done = true;
-                        // signal main thread.
-                        phaser.arrive();
-                        break;
-                    }
-                    default:
-                        break;
-                }
-            }
-        }
-
-        public void waitUntilStarted() {
-            // wait for MyThread.
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goBlocked() {
-            System.out.println("Waiting myThread to go blocked.");
-            setState(BLOCKED);
-            // wait for MyThread to get to a point just before being blocked
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goWaiting() {
-            System.out.println("Waiting myThread to go waiting.");
-            setState(WAITING);
-            // wait for MyThread to get to just before wait on object.
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goTimedWaiting() {
-            System.out.println("Waiting myThread to go timed waiting.");
-            setState(TIMED_WAITING);
-            // wait for MyThread to get to just before timed wait call.
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goParked() {
-            System.out.println("Waiting myThread to go parked.");
-            setState(PARKED);
-            // wait for MyThread to get to just before parked.
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goTimedParked() {
-            System.out.println("Waiting myThread to go timed parked.");
-            setState(TIMED_PARKED);
-            // wait for MyThread to get to just before timed park.
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void goSleeping() {
-            System.out.println("Waiting myThread to go sleeping.");
-            setState(SLEEPING);
-            // wait for MyThread to get to just before sleeping
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        public void terminate() {
-            System.out.println("Waiting myThread to terminate.");
-            setState(TERMINATE);
-            // wait for MyThread to get to just before terminate
-            phaser.arriveAndAwaitAdvance();
-        }
-
-        private void setState(int newState) {
-            switch (state) {
-                case BLOCKED:
-                    while (state == BLOCKED) {
-                        goSleep(10);
-                    }
-                    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;
-            }
-        }
-    }
 }