test/com/sun/jdi/MultiBreakpointsTest.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * 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");
         }
     }
 }
	/*
	* 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");
	}
	}
	}