infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-04-21 04:10:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

8004177: test/java/lang/Thread/GenerifyStackTraces.java doesn't clean-up

Browse Source 
Reviewed-by: alanb, dholmes, chegar
This commit is contained in:
Eric Wang 2013-05-16 10:59:06 +01:00
parent f06239abab
commit 9b4403735d
2 changed files with 16 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
jdk/test/java/lang/Thread/GenerifyStackTraces.java
View File

@ -23,7 +23,7 @@
/*
* @test
* @bug 4919105
* @bug 4919105 8004177
* @summary Generified basic unit test of Thread.getAllStackTraces()
* @author Mandy Chung
*/
@ -33,7 +33,6 @@ import java.util.*;
public class GenerifyStackTraces {
private static Object go = new Object();
private static Object dumpObj = new Object();
private static String[] methodNames = {"run", "A", "B", "C", "Done"};
private static int DONE_DEPTH = 5;
private static boolean testFailed = false;
@ -48,19 +47,26 @@ public class GenerifyStackTraces {
one = new ThreadOne();
one.start();
Thread dt = new DumpThread();
dt.setDaemon(true);
DumpThread dt = new DumpThread();
dt.start();
try {
one.join();
} finally {
dt.shutdown();
}
if (testFailed) {
throw new RuntimeException("Test Failed.");
}
}
static class DumpThread extends Thread {
private volatile boolean finished = false;
public void run() {
int depth = 2;
while (true) {
while (!finished) {
// At each iterator, wait until ThreadOne blocks
// to wait for thread dump.
// Then dump stack trace and notify ThreadOne to continue.
@ -75,6 +81,11 @@ public class GenerifyStackTraces {
}
}
}
public void shutdown() throws InterruptedException {
finished = true;
this.join();
}
}
static class ThreadOne extends Thread {

182
jdk/test/java/lang/Thread/StackTraces.java
View File

@ -1,182 +0,0 @@
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 4593133
* @summary Basic unit test of Thread.getStackTraces()
* @author Mandy Chung
*/
import java.util.*;
public class StackTraces {
private static Object go = new Object();
private static Object dumpObj = new Object();
private static String[] methodNames = {"run", "A", "B", "C", "Done"};
private static int DONE_DEPTH = 5;
private static boolean testFailed = false;
private static Thread one;
private static boolean trace = false;
public static void main(String[] args) throws Exception {
if (args.length > 0 && args[0].equals("trace")) {
trace = true;
}
one = new ThreadOne();
one.start();
Thread dt = new DumpThread();
dt.setDaemon(true);
dt.start();
if (testFailed) {
throw new RuntimeException("Test Failed.");
}
}
static class DumpThread extends Thread {
public void run() {
int depth = 2;
while (true) {
// At each iterator, wait until ThreadOne blocks
// to wait for thread dump.
// Then dump stack trace and notify ThreadOne to continue.
try {
sleep(2000);
dumpStacks(depth);
depth++;
finishDump();
} catch (Exception e) {
e.printStackTrace();
testFailed = true;
}
}
}
}
static class ThreadOne extends Thread {
public void run() {
A();
}
private void A() {
waitForDump();
B();
}
private void B() {
waitForDump();
C();
}
private void C() {
waitForDump();
Done();
}
private void Done() {
waitForDump();
// Get stack trace of current thread
StackTraceElement[] stack = getStackTrace();
try {
checkStack(this, stack, DONE_DEPTH);
} catch (Exception e) {
e.printStackTrace();
testFailed = true;
}
}
}
static private void waitForDump() {
synchronized(go) {
try {
go.wait();
} catch (Exception e) {
throw new RuntimeException("Unexpected exception" + e);
}
}
}
static private void finishDump() {
synchronized(go) {
try {
go.notifyAll();
} catch (Exception e) {
throw new RuntimeException("Unexpected exception" + e);
}
}
}
public static void dumpStacks(int depth) throws Exception {
// Get stack trace of another thread
StackTraceElement[] stack = one.getStackTrace();
checkStack(one, stack, depth);
// Get stack traces of all Threads
Map m = Thread.getAllStackTraces();
Set s = m.entrySet();
Iterator iter = s.iterator();
Map.Entry entry;
while (iter.hasNext()) {
entry = (Map.Entry) iter.next();
Thread t = (Thread) entry.getKey();
stack = (StackTraceElement[]) entry.getValue();
if (t == null || stack == null) {
throw new RuntimeException("Null thread or stacktrace returned");
}
if (t == one) {
checkStack(t, stack, depth);
}
}
}
private static void checkStack(Thread t, StackTraceElement[] stack,
int depth) throws Exception {
if (trace) {
printStack(t, stack);
}
int frame = stack.length - 1;
for (int i = 0; i < depth && frame >= 0; i++) {
if (! stack[frame].getMethodName().equals(methodNames[i])) {
throw new RuntimeException("Expected " + methodNames[i] +
" in frame " + frame + " but got " +
stack[frame].getMethodName());
}
frame--;
}
}
private static void printStack(Thread t, StackTraceElement[] stack) {
System.out.println(t +
" stack: (length = " + stack.length + ")");
if (t != null) {
for (int j = 0; j < stack.length; j++) {
System.out.println(stack[j]);
}
System.out.println();
}
}
}