diff --git a/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java b/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java index dbe002e26b2304f92201f320f955001f030cf45f..1b53f12c52de803a28d2be25eb232a2723f5ffc9 100644 --- a/test/java/lang/management/ThreadMXBean/ThreadStackTrace.java +++ b/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() { diff --git a/test/java/lang/management/ThreadMXBean/Utils.java b/test/java/lang/management/ThreadMXBean/Utils.java new file mode 100644 index 0000000000000000000000000000000000000000..92baf607404eeadae3dbb3359e2e1b9b21d7f0a8 --- /dev/null +++ b/test/java/lang/management/ThreadMXBean/Utils.java @@ -0,0 +1,79 @@ +/* + * 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); + } + } + +}