/*
* Copyright (c) 2001, 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 4359247
* @summary Breakpoints on multiple threads have problems.
*
* @author tbell, jjh
*
* @build TestScaffold VMConnection TargetListener TargetAdapter
* @run compile -g MultiBreakpointsTest.java
* @run main MultiBreakpointsTest
*/
/*
* This test runs a debuggee with n threads each of which just loops
* doing some printlns and calling a method. The debugger sets
* bkpts on these methods and verifies that they are all hit.
* The default number of threads is 4. To change it to say 10,
* pass this to the testcase on the cmd line:
* -Dnthreads=10
* The current max allowed value of nthreads is 30.
* You can also do this, for example,
* -Dnhits=30
* to change the number of times the bkpts are to be hit from
* the default of 100 to 30.
*/
import com.sun.jdi.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;
import java.util.*;
/********** target program **********/
import java.io.*;
import java.text.*;
class MultiBreakpointsTarg {
MultiBreakpointsTarg(int numThreads, int numHits) {
for (int ii = 0; ii < numThreads; ii++) {
console(ii, numHits);
}
}
public static void main(String args[]) {
int nthreads;
int nhits;
String nStr = System.getProperty("nthreads");
if (nStr == null) {
throw new RuntimeException("nthreads = null in debuggee");
}
nthreads = Integer.parseInt(nStr);
nStr = System.getProperty("nhits");
if (nStr == null) {
throw new RuntimeException("nhits = null in debuggee");
}
nhits = Integer.parseInt(nStr);
System.out.println("Debuggee: nthreads = " + nthreads + ", nhits = " + nhits);
MultiBreakpointsTarg ptr = new MultiBreakpointsTarg(nthreads, nhits);
// for (int i = 0; i < nthreads; i++) {
// ptr.console(i);
// }
}
// The brute force approach for simplicity - don't use reflection
// nor set thread specific bkpts. Use of those features would
// make for interesting tests too, and maybe would prove that
// we don't really have to bother doing it this dumb way.
void bkpt0() {}
void bkpt1() {}
void bkpt2() {}
void bkpt3() {}
void bkpt4() {}
void bkpt5() {}
void bkpt6() {}
void bkpt7() {}
void bkpt8() {}
void bkpt9() {}
void bkpt10() {}
void bkpt11() {}
void bkpt12() {}
void bkpt13() {}
void bkpt14() {}
void bkpt15() {}
void bkpt16() {}
void bkpt17() {}
void bkpt18() {}
void bkpt19() {}
void bkpt20() {}
void bkpt21() {}
void bkpt22() {}
void bkpt23() {}
void bkpt24() {}
void bkpt25() {}
void bkpt26() {}
void bkpt27() {}
void bkpt28() {}
void bkpt29() {}
void console(final int num, final int nhits) {
final InputStreamReader isr = new InputStreamReader(System.in);
final BufferedReader br = new BufferedReader(isr);
// Create the threads
//
//final String threadName = "DebuggeeThread: " + num;
final String threadName = "" + num;
Thread thrd = new Thread( threadName ) {
public void run() {
synchronized( isr ) {
boolean done = false;
try {
// For each thread, run until numHits bkpts have been hit
for( int i = 0; i < nhits; i++ ) {
// This is a tendril from the original jdb test.
// It could probably be deleted.
System.out.println("Thread " + threadName + " Enter a string: ");
String s = "test" + num;
switch (num) {
case 0: bkpt0(); break;
case 1: bkpt1(); break;
case 2: bkpt2(); break;
case 3: bkpt3(); break;
case 4: bkpt4(); break;
case 5: bkpt5(); break;
case 6: bkpt6(); break;
case 7: bkpt7(); break;
case 8: bkpt8(); break;
case 9: bkpt9(); break;
case 10: bkpt10(); break;
case 11: bkpt11(); break;
case 12: bkpt12(); break;
case 13: bkpt13(); break;
case 14: bkpt14(); break;
case 15: bkpt15(); break;
case 16: bkpt16(); break;
case 17: bkpt17(); break;
case 18: bkpt18(); break;
case 19: bkpt19(); break;
case 20: bkpt20(); break;
case 21: bkpt21(); break;
case 22: bkpt22(); break;
case 23: bkpt23(); break;
case 24: bkpt24(); break;
case 25: bkpt25(); break;
case 26: bkpt26(); break;
case 27: bkpt27(); break;
case 28: bkpt28(); break;
case 29: bkpt29(); break;
}
System.out.println("Thread " + threadName + " You entered : " + s);
if( s.compareTo( "quit" ) == 0 )
done = true;
}
} catch(Exception e) {
System.out.println("WOOPS");
}
}
}
};
thrd.setPriority(Thread.MAX_PRIORITY-1);
thrd.start();
}
}
/********** test program **********/
public class MultiBreakpointsTest extends TestScaffold {
ReferenceType targetClass;
ThreadReference mainThread;
EventRequestManager erm;
static int nthreads;
static int nhits;
BreakpointRequest bkpts[];
int hits[];
MultiBreakpointsTest (String args[]) {
super(args);
bkpts = new BreakpointRequest[nthreads];
hits = new int[nthreads];
}
public static void main(String[] args) throws Exception {
String countStr = System.getProperty("nthreads");
if (countStr == null) {
nthreads = 4;
} else {
nthreads = Integer.parseInt(countStr);
}
if ( nthreads > 30) {
throw new RuntimeException("nthreads is greater than 30: " + nthreads);
}
countStr = System.getProperty("nhits");
if (countStr == null) {
nhits = 100;
} else {
nhits = Integer.parseInt(countStr);
}
args = new String[] { "-J-Dnthreads=" + nthreads, "-J-Dnhits=" + nhits} ;
new MultiBreakpointsTest(args).startTests();
}
/********** event handlers **********/
public void breakpointReached(BreakpointEvent event) {
BreakpointRequest req = (BreakpointRequest)event.request();
for ( int ii = 0; ii < nthreads; ii++) {
if (req == bkpts[ii]) {
println("Hit bkpt on thread: " +ii+ ": " + ++hits[ii]);
break;
}
}
}
public BreakpointRequest setBreakpoint(String clsName,
String methodName,
String methodSignature) {
ReferenceType rt = findReferenceType(clsName);
if (rt == null) {
rt = resumeToPrepareOf(clsName).referenceType();
}
Method method = findMethod(rt, methodName, methodSignature);
if (method == null) {
throw new IllegalArgumentException("Bad method name/signature");
}
BreakpointRequest bpr = erm.createBreakpointRequest(method.location());
bpr.setSuspendPolicy(EventRequest.SUSPEND_ALL);
//bpr.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
bpr.enable();
return bpr;
}
/********** test core **********/
protected void runTests() throws Exception {
/*
* Get to the top of main()
* to determine targetClass and mainThread
*/
BreakpointEvent bpe = startToMain("MultiBreakpointsTarg");
targetClass = bpe.location().declaringType();
mainThread = bpe.thread();
erm = vm().eventRequestManager();
for (int ii = 0 ; ii < nthreads; ii++) {
bkpts[ii] = setBreakpoint("MultiBreakpointsTarg",
"bkpt" + ii,
"()V");
}
/*
* resume the target listening for events
*/
listenUntilVMDisconnect();
for ( int ii = 0; ii < nthreads; ii++) {
if (hits[ii] != nhits) {
failure("FAILED: Expected " + nhits + " breakpoints for thread " + ii + " but only got " + hits[ii]);
}
}
/*
* deal with results of test
* if anything has called failure("foo") testFailed will be true
*/
if (!testFailed) {
println("MultiBreakpointsTest: passed");
} else {
throw new Exception("MultiBreakpointsTest: failed");
}
}
}