6798842: TEST_BUG: ThreadStackTrace.java fails intermittently with unexpected thread status.

Summary: remove @ignore
Reviewed-by: swamyv

test/java/lang/management/ThreadMXBean/ThreadStackTrace.java

@@ -28,7 +28,7 @@
  *          ThreadInfo.getThreadState()
  * @author  Mandy Chung
  *
- * @run build Semaphore
+ * @run build Semaphore Utils
  * @run main ThreadStackTrace
  */
 
@@ -48,16 +48,6 @@ public class ThreadStackTrace {
     private static int esDepth = 3;
     private static int methodExamine1= 2;
 
-    private static void goSleep(long ms) {
-        try {
-            Thread.sleep(ms);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-            System.out.println("Unexpected exception.");
-            testFailed = true;
-        }
-    }
-
     private static void checkNullThreadInfo(Thread t) throws Exception {
         ThreadInfo ti = mbean.getThreadInfo(t.getId());
         if (ti != null) {
@@ -96,7 +86,7 @@ public class ThreadStackTrace {
                            "is waiting to begin.");
 
         // The Examiner should be waiting to be notified by the BlockedThread
-        checkThreadState(examiner, Thread.State.WAITING);
+        Utils.checkThreadState(examiner, Thread.State.WAITING);
 
         // Check that the stack is returned correctly for a new thread
         checkStack(examiner, examinerStack, esDepth);
@@ -135,35 +125,6 @@ public class ThreadStackTrace {
         }
     }
 
-    private static void checkThreadState(Thread thread, Thread.State s)
-        throws Exception {
-
-        ThreadInfo ti = mbean.getThreadInfo(thread.getId());
-        if (ti.getThreadState() != s) {
-            ThreadInfo info =
-                mbean.getThreadInfo(thread.getId(), Integer.MAX_VALUE);
-            System.out.println(INDENT + "TEST FAILED:");
-            printStack(thread, info.getStackTrace());
-            System.out.println(INDENT + "Thread state: " + info.getThreadState());
-
-            throw new RuntimeException("TEST FAILED: " +
-                "Thread state for " + thread + " returns " + ti.getThreadState() +
-                ".  Expected to be " + s);
-        }
-    }
-
-    private static void checkThreadState(Thread thread,
-                                         Thread.State s1, Thread.State s2)
-        throws Exception {
-
-        ThreadInfo ti = mbean.getThreadInfo(thread.getId());
-        if (ti.getThreadState() != s1 && ti.getThreadState() != s2) {
-            throw new RuntimeException("TEST FAILED: " +
-                "Thread state for " + thread + " returns " + ti.getThreadState() +
-                ".  Expected to be " + s1 + " or " + s2);
-        }
-    }
-
     private static void checkStack(Thread t, String[] expectedStack,
                                    int depth) throws Exception {
         ThreadInfo ti = mbean.getThreadInfo(t.getId(), Integer.MAX_VALUE);
@@ -197,20 +158,20 @@ public class ThreadStackTrace {
             handshake.semaP();
 
             // give a chance for the examiner thread to really wait
-            goSleep(20);
+            Utils.goSleep(20);
         }
 
         void waitUntilLockAReleased() {
             handshake.semaP();
 
             // give a chance for the examiner thread to really wait
-            goSleep(50);
+            Utils.goSleep(50);
         }
 
         private void notifyWaiter() {
             // wait until the examiner waits on the semaphore
             while (handshake.getWaiterCount() == 0) {
-                goSleep(20);
+                Utils.goSleep(20);
             }
             handshake.semaV();
         }
@@ -278,10 +239,10 @@ public class ThreadStackTrace {
 
             // wait until the examiner is waiting for blockedThread's notification
             while (!blockedThread.hasWaitersForBlocked()) {
-                goSleep(50);
+                Utils.goSleep(50);
             }
             // give a chance for the examiner thread to really wait
-            goSleep(20);
+            Utils.goSleep(20);
         }
 
         private Thread itself;
@@ -290,7 +251,7 @@ public class ThreadStackTrace {
                 examine2();
                 try {
                     System.out.println("Checking examiner's its own stack trace");
-                    checkThreadState(itself, Thread.State.RUNNABLE);
+                    Utils.checkThreadState(itself, Thread.State.RUNNABLE);
                     checkStack(itself, examinerStack, methodExamine1);
 
                     // wait until blockedThread is blocked on lockB
@@ -298,7 +259,7 @@ public class ThreadStackTrace {
 
                     System.out.println("Checking stack trace for " +
                         "BlockedThread - should be blocked on lockB.");
-                    checkThreadState(blockedThread, Thread.State.BLOCKED);
+                    Utils.checkThreadState(blockedThread, Thread.State.BLOCKED);
                     checkStack(blockedThread, blockedStack, methodB);
                 } catch (Exception e) {
                     e.printStackTrace();
@@ -312,7 +273,7 @@ public class ThreadStackTrace {
             synchronized (lockA) {
                 // wait until main thread gets signalled of the semaphore
                 while (handshake.getWaiterCount() == 0) {
-                    goSleep(20);
+                    Utils.goSleep(20);
                 }
 
                 handshake.semaV();  // notify the main thread
@@ -321,12 +282,12 @@ public class ThreadStackTrace {
                     blockedThread.waitUntilBlocked();
 
                     System.out.println("Checking examiner's its own stack trace");
-                    checkThreadState(itself, Thread.State.RUNNABLE);
+                    Utils.checkThreadState(itself, Thread.State.RUNNABLE);
                     checkStack(itself, examinerStack, esDepth);
 
                     System.out.println("Checking stack trace for " +
                         "BlockedThread - should be blocked on lockA.");
-                    checkThreadState(blockedThread, Thread.State.BLOCKED);
+                    Utils.checkThreadState(blockedThread, Thread.State.BLOCKED);
                     checkStack(blockedThread, blockedStack, bsDepth);
 
                 } catch (Exception e) {
@@ -344,7 +305,7 @@ public class ThreadStackTrace {
                 try {
                     System.out.println("Checking stack trace for " +
                         "BlockedThread - should be waiting on lockA.");
-                    checkThreadState(blockedThread, Thread.State.WAITING);
+                    Utils.checkThreadState(blockedThread, Thread.State.WAITING);
                     checkStack(blockedThread, blockedStack, bsDepth);
 
                     // Let the blocked thread go
@@ -357,7 +318,7 @@ public class ThreadStackTrace {
                 }
             }
             // give some time for BlockedThread to proceed
-            goSleep(50);
+            Utils.goSleep(50);
         } // examine2()
 
         public void run() {

test/java/lang/management/ThreadMXBean/Utils.java

+/*
+ * Copyright 2003-2006 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.
+ */
+
+/*
+ * Utility class for ThreadMXBean tests
+ */
+import java.lang.management.ManagementFactory;
+import java.lang.management.ThreadMXBean;
+
+public class Utils {
+    private static final ThreadMXBean tm = ManagementFactory.getThreadMXBean();
+    private static final int MAX_RETRY = 200;
+
+    public static boolean waitForBlockWaitingState(Thread t) {
+        // wait for the thread to transition to the expected state
+        int retryCount=0;
+        while (t.getState() == Thread.State.RUNNABLE && retryCount < MAX_RETRY) {
+            goSleep(100);
+            retryCount++;
+        }
+        return (t.getState() != Thread.State.RUNNABLE);
+    }
+
+    public static boolean waitForThreadState(Thread t, Thread.State expected) {
+        // wait for the thread to transition to the expected state
+        int retryCount=0;
+        while (t.getState() != expected && retryCount < MAX_RETRY) {
+            goSleep(100);
+            retryCount++;
+        }
+        return (t.getState() == expected);
+    }
+
+    public static void checkThreadState(Thread t, Thread.State expected) {
+        waitForThreadState(t, expected);
+
+        Thread.State state = tm.getThreadInfo(t.getId()).getThreadState();
+        if (state == null) {
+            throw new RuntimeException(t.getName() + " expected to have " +
+                expected + " but got null.");
+        }
+        if (state != expected) {
+            t.dumpStack();
+            throw new RuntimeException(t.getName() +
+                 " expected to have " + expected + " but got " + state);
+        }
+    }
+
+    public static void goSleep(long ms) {
+        try {
+            Thread.sleep(ms);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            System.out.println("TEST FAILED: Unexpected exception.");
+            throw new RuntimeException(e);
+        }
+    }
+
+}