OpenJDK / portola / portola
changeset 50230:31361382634b
8199379: [TESTBUG] Open source vm testbase JDB tests
Reviewed-by: mseledtsov, sspitsyn
line wrap: on
line diff
--- a/test/hotspot/jtreg/ProblemList-graal.txt Tue May 22 13:10:56 2018 -0400 +++ b/test/hotspot/jtreg/ProblemList-graal.txt Tue May 22 10:08:04 2018 -0700 @@ -134,6 +134,7 @@ vmTestbase/nsk/jdi/VirtualMachine/redefineClasses/redefineclasses026/TestDescription.java 8195627 generic-all vmTestbase/nsk/jdi/VirtualMachine/redefineClasses/redefineclasses028/TestDescription.java 8195627 generic-all vmTestbase/nsk/jdi/VirtualMachine/redefineClasses/redefineclasses030/TestDescription.java 8195627 generic-all +vmTestbase/nsk/jdb/wherei/wherei001/wherei001.java 8195627 generic-all vmTestbase/vm/mlvm/anonloader/stress/oome/heap/Test.java 8186299 generic-all vmTestbase/vm/mlvm/anonloader/stress/oome/metaspace/Test.java 8186299 generic-all
--- a/test/hotspot/jtreg/ProblemList.txt Tue May 22 13:10:56 2018 -0400 +++ b/test/hotspot/jtreg/ProblemList.txt Tue May 22 10:08:04 2018 -0700 @@ -144,6 +144,8 @@ vmTestbase/vm/mlvm/indy/func/jvmti/mergeCP_indy2manyDiff_b/TestDescription.java 8013267 generic-all vmTestbase/vm/mlvm/indy/func/jvmti/mergeCP_indy2manySame_b/TestDescription.java 8013267 generic-all +vmTestbase/nsk/jdb/exclude/exclude001/exclude001.java 8197938 windows-all + vmTestbase/heapdump/JMapHeapCore/TestDescription.java 8023376,8001227,8051445 generic-all vmTestbase/heapdump/JMapMetaspaceCore/TestDescription.java 8023376,8001227,8051445 generic-all
--- a/test/hotspot/jtreg/TEST.groups Tue May 22 13:10:56 2018 -0400 +++ b/test/hotspot/jtreg/TEST.groups Tue May 22 10:08:04 2018 -0700 @@ -1257,9 +1257,10 @@ # JSR292 tests (invokedynamic AKA Multi-Language VM AKA Da Vinci Machine) vmTestbase_vm_mlvm = \ vmTestbase/vm/mlvm + # Heap dump tests vmTestbase_vm_heapdump = \ - vmTestbase/heapdump/ + vmTestbase/heapdump vmTestbase_vm_heapdump_quick = \ vmTestbase/heapdump/OnOOMToFile/TestDescription.java \ @@ -1267,3 +1268,8 @@ vmTestbase/heapdump/OnOOMToPath/TestDescription.java \ vmTestbase/heapdump/JMapHeapCore/TestDescription.java \ vmTestbase/heapdump/JMapMetaspace/TestDescription.java + +# JDB tests +vmTestbase_nsk_jdb = \ + vmTestbase/nsk/jdb +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/caught_exception/caught_exception002/caught_exception002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/caught_exception/caught_exception002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'catch caught <exception>' command. + * When the debugee throws an exception that is caught somewhere + * up in the program stack, jdb does not halt execution at the point + * the exception was thrown but continues to execute the code in the catch + * clause and proceed on with the rest of the program. + * To halt execution at the throw point for exceptions + * that are being caught - the 'catch' command has to be used. + * The test throws ten exceptions that are on jdb's catch list + * and verifies that jdb halts execution at the throw point each + * time an exception is thrown. + * COMMENTS + * This test functionally equals to + * nsk/jdb/caught_exception/caught_exception001 test and replaces it. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.caught_exception.caught_exception002.caught_exception002 + * nsk.jdb.caught_exception.caught_exception002.caught_exception002a + * @run main/othervm PropertyResolvingWrapper + * nsk.jdb.caught_exception.caught_exception002.caught_exception002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.caught_exception.caught_exception002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class caught_exception002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new caught_exception002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.caught_exception.caught_exception002"; + static final String TEST_CLASS = PACKAGE_NAME + ".caught_exception002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final int MAX = 10; + + /* ------------------------------------- */ + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + for (int i = 0; i < MAX; i++) { + reply = jdb.receiveReplyFor(JdbCommand._catch + " caught " + PACKAGE_NAME + ".MyException" + i); + } + + for (int i = 0; i < MAX; i++) { + reply = jdb.receiveReplyFor(JdbCommand.cont); + checkCatch(reply, i); + } + + jdb.contToExit(1); + } + + private void checkCatch (String[] reply, int i) { + Paragrep grep; + int count; + String found; + Vector v = new Vector(); + + grep = new Paragrep(reply); + v.add("Exception occurred"); + v.add(PACKAGE_NAME + ".MyException" + i); + count = grep.find(v); + if (count != 1) { + log.complain("Failed to report catch of MyException" + i + " : " + count); + success = false; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/caught_exception/caught_exception002/caught_exception002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.caught_exception.caught_exception002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class caught_exception002a { + + /* TEST DEPENDANT VARIABLES AND CONSTANTS */ + static final String PACKAGE_NAME = "nsk.jdb.caught_exception.caught_exception002"; + + public static void main(String args[]) { + caught_exception002a _caught_exception002a = new caught_exception002a(); + System.exit(caught_exception002.JCK_STATUS_BASE + _caught_exception002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + lastBreak(); + + int result = -1; + for (int i = 0; i <= 10; i++) { + result = a(i); + } + + log.display("Debuggee PASSED"); + return caught_exception002.PASSED; + } + + public static int a(int i) { + int result = -1; + try { + result = b(i); + } catch (MyException0 e) { + System.out.println("debugee's main(): caught MyException0"); + } catch (MyException1 e) { + System.out.println("debugee's main(): caught MyException1"); + } catch (MyException2 e) { + System.out.println("debugee's main(): caught MyException2"); + } catch (MyException3 e) { + System.out.println("debugee's main(): caught MyException3"); + } catch (MyException4 e) { + System.out.println("debugee's main(): caught MyException4"); + } catch (MyException5 e) { + System.out.println("debugee's main(): caught MyException5"); + } catch (MyException6 e) { + System.out.println("debugee's main(): caught MyException6"); + } catch (MyException7 e) { + System.out.println("debugee's main(): caught MyException7"); + } catch (MyException8 e) { + System.out.println("debugee's main(): caught MyException8"); + } catch (MyException9 e) { + System.out.println("debugee's main(): caught MyException9"); + } + return result; + } + + public static int b(int i) throws MyException0, MyException1, + MyException2, MyException3, MyException4, MyException5, MyException6, + MyException7, MyException8, MyException9 { + + switch(i) { + case 0: + throw new MyException0("MyException0"); + case 1: + throw new MyException1("MyException1"); + case 2: + throw new MyException2("MyException2"); + case 3: + throw new MyException3("MyException3"); + case 4: + throw new MyException4("MyException4"); + case 5: + throw new MyException5("MyException5"); + case 6: + throw new MyException6("MyException6"); + case 7: + throw new MyException7("MyException7"); + case 8: + throw new MyException8("MyException8"); + case 9: + throw new MyException9("MyException9"); + default: + return i*i; + } + } +} + +class MyException0 extends Exception { + public MyException0 (String s) {super(s);} +} +class MyException1 extends Exception { + public MyException1 (String s) {super(s);} +} +class MyException2 extends Exception { + public MyException2 (String s) {super(s);} +} +class MyException3 extends Exception { + public MyException3 (String s) {super(s);} +} +class MyException4 extends Exception { + public MyException4 (String s) {super(s);} +} +class MyException5 extends Exception { + public MyException5 (String s) {super(s);} +} +class MyException6 extends Exception { + public MyException6 (String s) {super(s);} +} +class MyException7 extends Exception { + public MyException7 (String s) {super(s);} +} +class MyException8 extends Exception { + public MyException8 (String s) {super(s);} +} +class MyException9 extends Exception { + public MyException9 (String s) {super(s);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/classes/classes001/classes001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/classes/classes001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'classes' command. + * The test checks if jdb correctly replies on 'classes' command. + * The test passes when reply contains full names of all checked classes. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.classes.classes001.classes001 + * nsk.jdb.classes.classes001.classes001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.classes.classes001.classes001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.classes.classes001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class classes001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new classes001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.classes.classes001"; + static final String TEST_CLASS = PACKAGE_NAME + ".classes001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String NOT_VALID_SAMPLE = "is not a valid"; + + static String[] checkedClasses = { + DEBUGGEE_CLASS, + DEBUGGEE_CLASS + "$Inner1", + DEBUGGEE_CLASS + "$Inner2", + DEBUGGEE_CLASS + "$Inner3", + DEBUGGEE_CLASS + "$Inner4", + DEBUGGEE_CLASS + "$Inner5", + DEBUGGEE_CLASS + "$Inner6", + DEBUGGEE_CLASS + "$Inner7", + DEBUGGEE_CLASS + "$Inner8", + DEBUGGEE_CLASS + "$InnerInt1", + DEBUGGEE_CLASS + "$InnerInt2", + DEBUGGEE_CLASS + "$InnerInt3", + DEBUGGEE_CLASS + "$InnerInt4", + DEBUGGEE_CLASS + "$InnerInt5", + PACKAGE_NAME + ".Outer1", + PACKAGE_NAME + ".Outer2", + PACKAGE_NAME + ".Outer3", + PACKAGE_NAME + ".OuterInt1", + PACKAGE_NAME + ".OuterInt2" + }; + + /* ------------------------------------- */ + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.classes); + + for (int i = 0; i < checkedClasses.length; i++) { + if (!checkClass(checkedClasses[i], reply)) { + success = false; + } + } + + jdb.contToExit(1); + } + + private boolean checkClass (String className, String[] reply) { + Paragrep grep; + String found; + boolean result = true; + + grep = new Paragrep(reply); + found = grep.findFirst(className); + if (found.length() == 0) { + log.complain("Failed to report class " + className); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/classes/classes001/classes001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.classes.classes001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class classes001a { + + /* TEST DEPENDANT VARIABLES AND CONSTANTS */ + static final String PACKAGE_NAME = "nsk.jdb.classes.classes001"; + + public static void main(String args[]) { + classes001a _classes001a = new classes001a(); + System.exit(classes001.JCK_STATUS_BASE + _classes001a.runIt(args, System.out)); + } + + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + init(); + + log.display("Debuggee PASSED"); + return classes001.PASSED; + } + + class Inner1 {} + interface InnerInt1 {} + + public class Inner2 {} + public interface InnerInt2 {} + + private class Inner3 {} + private interface InnerInt3 {} + + protected class Inner4 {} + protected interface InnerInt4 {} + + abstract class Inner5 {} + abstract interface InnerInt5 {} + + final class Inner6 extends Inner5{} + + class Inner7 extends Outer2{} + class Inner8 implements OuterInt1, OuterInt2, InnerInt1, InnerInt2, InnerInt3, InnerInt4, InnerInt5 {} + + private void init () { + Outer1 o1 = new Outer1(); + Outer3 o3 = new Outer3(); + Inner1 i1 = new Inner1(); + Inner2 i2 = new Inner2(); + Inner3 i3 = new Inner3(); + Inner4 i4 = new Inner4(); + Inner6 i6 = new Inner6(); + Inner7 i7 = new Inner7(); + Inner8 i8 = new Inner8(); + + lastBreak(); + } +} + +class Outer1 {} +interface OuterInt1 {} + +abstract class Outer2 {} +abstract interface OuterInt2 {} + +final class Outer3 {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/classpath/classpath001/classpath001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/classpath/classpath001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * An "is it alive & breathing" test for the 'classpath' command. + * The test passes if reply on 'classpath' command is not empty. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.classpath.classpath001.classpath001 + * nsk.jdb.classpath.classpath001.classpath001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.classpath.classpath001.classpath001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.classpath.classpath001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class classpath001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new classpath001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.classpath.classpath001"; + static final String TEST_CLASS = PACKAGE_NAME + ".classpath001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + reply = jdb.receiveReplyFor(JdbCommand.classpath); + + grep = new Paragrep(reply); + found = grep.findFirst("lasspath"); + if (found.length() == 0) { + log.complain("Failed to report classpath"); + success = false; + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/classpath/classpath001/classpath001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.classpath.classpath001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class classpath001a { + public static void main(String args[]) { + classpath001a _classpath001a = new classpath001a(); + lastBreak(); + System.exit(classpath001.JCK_STATUS_BASE + _classpath001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + lastBreak(); + + log.display("Debuggee PASSED"); + return classpath001.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear002/clear002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/clear/clear002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'clear <class_id>.<method>' command. + * The test sets 3 breakpoints and then clears two of them after the + * first breakpoint is reached. The tests verifies that jdb does not + * halt execution at the cleared breakpoint. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.clear.clear002.clear002 + * nsk.jdb.clear.clear002.clear002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.clear.clear002.clear002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.clear.clear002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class clear002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new clear002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.clear.clear002"; + static final String TEST_CLASS = PACKAGE_NAME + ".clear002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String METHOD_TO_STOP = DEBUGGEE_CLASS + ".func5"; + static final String METHOD1_TO_CLEAR = DEBUGGEE_CLASS + ".func4"; + static final String METHOD2_TO_CLEAR = DEBUGGEE_CLASS + "$A.func7"; + static final String REMOVED_SAMPLE = "Removed:"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + log.display("Setting breakpoint in method: " + METHOD1_TO_CLEAR); + jdb.setBreakpointInMethod(METHOD1_TO_CLEAR); + + log.display("Setting breakpoint in method: " + METHOD2_TO_CLEAR); + jdb.setBreakpointInMethod(METHOD2_TO_CLEAR); + + log.display("Setting breakpoint in method: " + METHOD_TO_STOP); + jdb.setBreakpointInMethod(METHOD_TO_STOP); + + if (!checkClear (METHOD1_TO_CLEAR)) { + success = false; + } + + if (!checkClear (METHOD2_TO_CLEAR)) { + success = false; + } + + jdb.contToExit(2); + + grep = new Paragrep(jdb.getTotalReply()); + count = grep.find(Jdb.BREAKPOINT_HIT); + if (count != 2) { + log.complain("Should hit 2 breakpoints."); + log.complain("Breakpoint hit count reported: " + count); + success = false; + } + + if (!checkBreakpoint (METHOD1_TO_CLEAR, grep)) { + success = false; + } + + if (!checkBreakpoint (METHOD2_TO_CLEAR, grep)) { + success = false; + } + } + + private boolean checkBreakpoint (String methodName, Paragrep grep) { + String found; + boolean result = true; + int count; + Vector v; + + v = new Vector(); + v.add(Jdb.BREAKPOINT_HIT); + v.add(methodName); + + found = grep.findFirst(v); + if (found.length() > 0) { + log.complain("Wrong hit at removed breakpoint in method:" + methodName); + result = false; + } + return result; + } + + private boolean checkClear (String methodName) { + Paragrep grep; + String found; + String[] reply; + boolean result = true; + int count; + Vector v; + + v = new Vector(); + v.add(REMOVED_SAMPLE); + v.add(methodName); + + log.display("Clearing breakpoint in method:" + methodName); + reply = jdb.receiveReplyFor(JdbCommand.clear + methodName); + grep = new Paragrep(reply); + + found = grep.findFirst(v); + if (found.length() == 0) { + log.complain("Failed to clear breakpoint in method: " + methodName); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear002/clear002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.clear.clear002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class clear002a { + public static void main(String args[]) { + clear002a _clear002a = new clear002a(); + lastBreak(); + System.exit(clear002.JCK_STATUS_BASE + _clear002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int i = func1(0) + A.func7(0); + + log.display("Debuggee PASSED"); + return clear002.PASSED; + } + + public int func1(int i) { + return func2(i) + 1; + } + + public int func2(int i) { + return func3(i) + 1; + } + + public int func3(int i) { + return func4(i) + 1; + } + + public int func4(int i) { + return func5(i) + 1; + } + + public int func5(int i) { + return func6(i) + 1; + } + + public int func6(int i) { + return i-5; + } + + static class A { + public static int func7 (int i) { + return i++; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear003/clear003.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/clear/clear003. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A negative test case for the 'clear <class_id>.<method>' command. + * The test sets 2 breakpoints and then tries to clear non-existent + * breakpoint after the first breakpoint is reached. The tests verifies + * that jdb correctly reports about attempt to clear non-existent + * breakpoint. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.clear.clear003.clear003 + * nsk.jdb.clear.clear003.clear003a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.clear.clear003.clear003 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.clear.clear003; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class clear003 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new clear003().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.clear.clear003"; + static final String TEST_CLASS = PACKAGE_NAME + ".clear003"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String METHOD4 = "func4"; + static final String METHOD5 = "func5"; + static final String METHOD_TO_CLEAR = DEBUGGEE_CLASS + "." + METHOD4; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + log.display("Setting breakpoint in method: " + METHOD5); + jdb.setBreakpointInMethod(DEBUGGEE_CLASS + "." + METHOD5); + + log.display("Clearing breakpoint."); + reply = jdb.receiveReplyFor(JdbCommand.clear + METHOD_TO_CLEAR); + grep = new Paragrep(reply); + count = grep.find("Removed:"); + if (count > 0) { + log.complain("Cleared non-existent breakpoint in method: " + METHOD_TO_CLEAR); + success = false; + } + + jdb.contToExit(2); + + grep = new Paragrep(jdb.getTotalReply()); + count = grep.find(Jdb.BREAKPOINT_HIT); + if (count != 2) { + log.complain("Should hit 2 breakpoints."); + log.complain("Breakpoint hit count reported: " + count); + success = false; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear003/clear003a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.clear.clear003; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class clear003a { + public static void main(String args[]) { + clear003a _clear003a = new clear003a(); + lastBreak(); + System.exit(clear003.JCK_STATUS_BASE + _clear003a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int i = func1(0); + + log.display("Debuggee PASSED"); + return clear003.PASSED; + } + + public int func1(int i) { + return func2(i) + 1; + } + + public int func2(int i) { + return func3(i) + 1; + } + + public int func3(int i) { + int value; + value = func4(i) + 1; + return value; + } + + public int func4(int i) { + int value; + value = func5(i) + 1; + return value; + } + + public int func5(int i) { + int value; + value = func6(i) + 1; + return value; + } + + public int func6(int i) { + return i-5; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear004/clear004.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/clear/clear004. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'clear <class_id:line>' command. + * The test sets 3 breakpoints and then clears one after the first + * breakpoint is reached. The tests verifies that jdb does not + * halt execution at the cleared breakpoint. + * COMMENTS + * This test functionally equals to nsk/jdb/clear/clear004 test and + * replaces it. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.clear.clear004.clear004 + * nsk.jdb.clear.clear004.clear004a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.clear.clear004.clear004 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.clear.clear004; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class clear004 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new clear004().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.clear.clear004"; + static final String TEST_CLASS = PACKAGE_NAME + ".clear004"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String[] BREAKPOINTS = new String[] + { DEBUGGEE_CLASS + ":63", + DEBUGGEE_CLASS + ":67", + DEBUGGEE_CLASS + ":71" }; + static final String REMOVED_SAMPLE = "Removed:"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + for (int i = 0; i < BREAKPOINTS.length; i++) { + log.display("Setting breakpoint at " + BREAKPOINTS[i]); + reply = jdb.receiveReplyFor(JdbCommand.stop_at + BREAKPOINTS[i]); + } + + if (!checkClear (BREAKPOINTS[1])) { + success = false; + } + + jdb.contToExit(3); + + grep = new Paragrep(jdb.getTotalReply()); + count = grep.find(Jdb.BREAKPOINT_HIT); + if (count != 3) { + log.complain("Should hit 3 breakpoints."); + log.complain("Breakpoint hit count reported: " + count); + success = false; + } + + if (!checkBreakpoint (BREAKPOINTS[1], grep)) { + success = false; + } + + } + + private boolean checkBreakpoint (String breakpoint, Paragrep grep) { + String found; + boolean result = true; + int count; + Vector v; + + v = new Vector(); + v.add(Jdb.BREAKPOINT_HIT); + v.add(breakpoint); + + found = grep.findFirst(v); + if (found.length() > 0) { + log.complain("Wrong hit at removed breakpoint at:" + breakpoint); + result = false; + } + return result; + } + + private boolean checkClear (String breakpoint) { + Paragrep grep; + String found; + String[] reply; + boolean result = true; + int count; + Vector v; + + v = new Vector(); + v.add(REMOVED_SAMPLE); + v.add(breakpoint); + + log.display("Clearing breakpoint at: " + breakpoint); + reply = jdb.receiveReplyFor(JdbCommand.clear + breakpoint); + grep = new Paragrep(reply); + + found = grep.findFirst(v); + if (found.length() == 0) { + log.complain("Failed to clear breakpoint at: " + breakpoint); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/clear/clear004/clear004a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +// THIS TEST IS LINE NUMBER SENSITIVE + +package nsk.jdb.clear.clear004; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class clear004a { + public static void main(String args[]) { + clear004a _clear004a = new clear004a(); + lastBreak(); + System.exit(clear004.JCK_STATUS_BASE + _clear004a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int i = func1(0) + A.func7(0); + + log.display("Debuggee PASSED"); + return clear004.PASSED; + } + + public int func1(int i) { + return func2(i) + 1; + } + + public int func2(int i) { + return func3(i) + 1; + } + + public int func3(int i) { + return func4(i) + 1; // this is line for breakpoint // clear004.BREAKPOINTS[0] + } + + public int func4(int i) { + return func5(i) + 1; // this is line for cleared breakpoint // clear004.BREAKPOINTS[1] + } + + public int func5(int i) { + return func6(i) + 1; // this is line for breakpoint // clear004.BREAKPOINTS[2] + } + + public int func6(int i) { + return i-5; + } + + static class A { + public static int func7 (int i) { + return i++; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/down/down002/down002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/down/down002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * This tests the jdb 'down' command. The test sets a breakpoint + * at 'func5' method in debugged 'nsk.jdb.down.down002a' class and then + * runs the debugee. Once, an execution suspends at 'func5' method, + * the 'down' command is issued to the debugger several times. + * The output is processed by counting the number of times + * each method name appears in the stack trace. The test passes + * if the obtained count matches the expected one. + * COMMENTS + * This test functionally equals to nsk/jdb/down/down001 test and + * replaces it. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.down.down002.down002 + * nsk.jdb.down.down002.down002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.down.down002.down002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.down.down002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class down002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new down002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.down.down002"; + static final String TEST_CLASS = PACKAGE_NAME + ".down002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String[][] FRAMES = new String[][] { + {"[1]", DEBUGGEE_CLASS + ".func5"}, + {"[2]", DEBUGGEE_CLASS + ".func4"}, + {"[3]", DEBUGGEE_CLASS + ".func3"}, + {"[4]", DEBUGGEE_CLASS + ".func2"}, + {"[5]", DEBUGGEE_CLASS + ".func1"}, + {"[6]", DEBUGGEE_CLASS + ".runIt"}, + {"[7]", DEBUGGEE_CLASS + ".main"} + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.receiveReplyFor(JdbCommand.stop_in + DEBUGGEE_CLASS + ".func5"); + jdb.receiveReplyFor(JdbCommand.cont); + + for (int i = 0; i < (FRAMES.length-1); i++) { + jdb.receiveReplyFor(JdbCommand.up); + } + + for (int i = 0; i < (FRAMES.length-1); i++) { + jdb.receiveReplyFor(JdbCommand.down); + jdb.receiveReplyFor(JdbCommand.where); + } + + jdb.contToExit(1); + + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + + for (int i = 1; i < (FRAMES.length-1); i++) { + v = new Vector(); + v.add(FRAMES[i][0]); + v.add(FRAMES[i][1]); + count = grep.find(v); + if (count != (i+1)) { + failure("Unexpected number of the stack frame: " + FRAMES[i][1] + + "\n\texpected value : " + (i+1) + ", got : " + count); + } + } + + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/down/down002/down002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.down.down002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class down002a { + public static void main(String args[]) { + down002a _down002a = new down002a(); + lastBreak(); + System.exit(down002.JCK_STATUS_BASE + _down002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int i = func1(0); + + log.display("Debuggee PASSED"); + return down002.PASSED; + } + + public int func1(int i) { + return func2(i) + 1; + } + + public int func2(int i) { + return func3(i) + 1; + } + + public int func3(int i) { + return func4(i) + 1; + } + + public int func4(int i) { + return func5(i) + 1; + } + + public int func5(int i) { + return func6(i) + 1; + } + + public int func6(int i) { + return i-5; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/dump/dump002/dump002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2003, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/dump/dump002. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for the 'dump' command. + * The test works as follows. Upon the debuggee is suspended + * on breakpoint, jdb issues 'dump' command for an object + * of debugged class and for element in array fields. + * The test passes if all checked fields with their values + * are listed. + * The test consists of two parts: + * dump002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * dump002a.java - the debugged application. + * COMMENTS + * The test replaces the nsk/jdb/dump/dump001 one. + * Test fixed according to test bug: + * 5045859 TEST_BUG: some JDB tests do not recognize JDB prompt + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.dump.dump002.dump002 + * nsk.jdb.dump.dump002.dump002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.dump.dump002.dump002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.dump.dump002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class dump002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + compoundPromptIdent = COMPOUND_PROMPT_IDENT; + return new dump002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.dump.dump002"; + static final String TEST_CLASS = PACKAGE_NAME + ".dump002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String COMPOUND_PROMPT_IDENT = "main"; + + static final String[] CHECKED_FIELDS = { + "_dump002a", + "iStatic", + "iPrivate", + "iProtect", + "iPublic", + "iFinal", + "iTransient", + "iVolatile", + "iArray", + "sStatic", + "sPrivate", + "sProtected", + "sPublic", + "sFinal", + "sTransient", + "sVolatile", + "sArray", + "fBoolean", + "fByte", + "fChar", + "fDouble", + "fFloat", + "fInt", + "fLong", + "fShort" + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v = new Vector(); + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.dump + DEBUGGEE_CLASS + "._dump002a"); + grep = new Paragrep(reply); + for (int i = 0; i < CHECKED_FIELDS.length; i++) { + v.setSize(0); + v.add(CHECKED_FIELDS[i]); + v.add("null"); + if (grep.find(v) > 0) { + failure("The field is not dumped : " + CHECKED_FIELDS[i]); + } + } + + String checkedField = DEBUGGEE_CLASS + ".iArray[0]"; + reply = jdb.receiveReplyFor(JdbCommand.dump + checkedField); + checkField(reply, checkedField); + + checkedField = DEBUGGEE_CLASS + ".sArray[0]"; + reply = jdb.receiveReplyFor(JdbCommand.dump + checkedField); + checkField(reply, checkedField); + + jdb.contToExit(1); + } + + void checkField (String[] reply, String fieldName) { + Paragrep grep; + Vector v = new Vector(); + + grep = new Paragrep(reply); + v.setSize(0); + v.add(fieldName); + v.add("null"); + if (grep.find(v) > 0) { + failure("The field is not dumped : " + fieldName); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/dump/dump002/dump002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2003, 2018, 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. + */ + +package nsk.jdb.dump.dump002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class dump002a { + static dump002a _dump002a = new dump002a(); + + public static void main(String args[]) { + System.exit(dump002.JCK_STATUS_BASE + _dump002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + lastBreak(); + + log.display("Debuggee PASSED"); + return dump002.PASSED; + } + + static int iStatic = 0; + private int iPrivate = 1; + protected int iProtect = 2; + public int iPublic = 3; + final int iFinal = 4; + transient int iTransient = 5; + volatile int iVolatile = 6; + + static int [] iArray = { 7 }; + + static String sStatic = "zero"; + private String sPrivate = "one"; + protected String sProtected = "two"; + public String sPublic = "three"; + final String sFinal = "four"; + transient String sTransient = "five"; + volatile String sVolatile = "six"; + + static String [] sArray = { "seven" }; + + boolean fBoolean = true; + byte fByte = Byte.MAX_VALUE; + char fChar = Character.MAX_VALUE; + double fDouble = Double.MAX_VALUE; + float fFloat = Float.MAX_VALUE; + int fInt = Integer.MAX_VALUE; + long fLong = Long.MAX_VALUE; + short fShort = Short.MAX_VALUE; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/eval/eval001/eval001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/eval/eval001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'eval <expr>' command. + * The test checks if jdb correctly prints values for the following + * expressions: + * - static field, + * - instance field, + * - element of array field, + * - return value of a method, + * - arithmetic expression of local variables, + * - return value of public method of the java.lang.String class. + * The test passes when all printed values are equal to expected ones. + * The test consists of two program: + * eval001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * eval001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.eval.eval001.eval001 + * + * @comment make sure eval001a is compiled w/ full debug info + * @clean nsk.jdb.eval.eval001.eval001a + * @compile -g:lines,source,vars eval001a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.eval.eval001.eval001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.eval.eval001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class eval001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new eval001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.eval.eval001"; + static final String TEST_CLASS = PACKAGE_NAME + ".eval001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String[][] checkedExpr = { + { DEBUGGEE_CLASS + ".myStaticField", "-2147483648" }, + { DEBUGGEE_CLASS + "._eval001a.myInstanceField", "9223372036854775807" }, + { DEBUGGEE_CLASS + "._eval001a.myArrayField[0][0].toString()", "ABCDE" }, + { DEBUGGEE_CLASS + "._eval001a.myMethod()", "2147483647" }, + { "myClass.toString().equals(\"abcde\")", "true"}, + { "i + j + k", "777"}, + { "new java.lang.String(\"Hello, World\").length()", "12"} + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // to get out of lastBreak() + reply = jdb.receiveReplyFor(JdbCommand.step); + + for (int i = 0; i < checkedExpr.length; i++) { + if (!checkValue(checkedExpr[i][0], checkedExpr[i][1])) { + success = false; + } + } + + jdb.contToExit(1); + } + + private boolean checkValue (String expr, String value) { + Paragrep grep; + String[] reply; + String found; + Vector v; + boolean result = true; + + reply = jdb.receiveReplyFor(JdbCommand.eval + expr); + grep = new Paragrep(reply); + found = grep.findFirst(value); + if (found.length() <= 0) { + log.complain("jdb failed to report value of expression: " + expr); + log.complain("expected : " + value + " ;\nreported: " + (reply.length > 0? reply[0]: "")); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/eval/eval001/eval001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.eval.eval001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class eval001a { + + static eval001a _eval001a = new eval001a(); + + public static void main(String args[]) { + System.exit(eval001.JCK_STATUS_BASE + _eval001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + MyClass myClass = new MyClass("abcde"); + int i = 111; + int j = 222; + int k = 444; + + synchronized (this) { + lastBreak(); + } + + log.display("Debuggee PASSED"); + return eval001.PASSED; + } + + static private int myStaticField = Integer.MIN_VALUE; + protected long myInstanceField; + public MyClass[][] myArrayField; + + private eval001a () { + myArrayField = new MyClass[][] {new MyClass[] {new MyClass("ABCDE")}}; + myInstanceField = Long.MAX_VALUE; + } + + synchronized private int myMethod() { + return Integer.MAX_VALUE; + } + + static class MyClass { + String line; + + public MyClass (String s) { + line = s; + } + + public String toString() { + return line; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/exclude/exclude001/exclude001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/exclude/exclude001. + * VM Testbase keywords: [jpda, jdb, quarantine] + * VM Testbase comments: JDK-8191037 + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'exclude' command. + * The debuggee program (exclude001a.java) starts three + * addional threads of MyThread class. The 'run' method of these + * threads invokes java.lang.System.currentTimeMillis() and + * com.sun.jdi.Bootstrap.virtualMachineManager() methods. + * There are three test cases: + * - block all exclude filter; + * - modified exclude filter allowing tracing events for java.* methods, + * which is set with 'exclude javax.*,sun.*,com.sun.*,jdk.*' command; + * - modified exclude filter allowing tracing events for com.sun.* methods, + * which is set with 'exclude java.*,javax.*,sun.*,jdk.*' command. + * - non-modified, predefined exclude filter; + * - modified exclude filter allowing tracing events for java.* methods, + * which is set with 'exclude javax.*,sun.*,com.sun.*' command; + * - modified exclude filter allowing tracing events for all system methods, + * which is set with 'exclude none' command. + * For each test case the correspondent MyThread thread is started and + * suspended at a breakpoint. Then method tracing is turned on with + * 'trace methods <thread id>' command with correspondent exclude filtering. + * The test passes if debuggee suspends on method enter/exit of only + * filtered classes, i.e. in comply with exclude filter previously set. + * The test consists of two program: + * exclude001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * exclude001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.exclude.exclude001.exclude001 + * nsk.jdb.exclude.exclude001.exclude001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.exclude.exclude001.exclude001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.exclude.exclude001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class exclude001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new exclude001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.exclude.exclude001"; + static final String TEST_CLASS = PACKAGE_NAME + ".exclude001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + + static final String JAVA_CORE_METHOD = "java.lang.System.currentTimeMillis"; + static final String COM_SUN_METHOD = "com.sun.jdi.Bootstrap.virtualMachineManager"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + String[] threads; + + String oldExclude = ""; + boolean javaTraced = false; + boolean comTraced = false; + boolean nskTraced = false; + + jdb.setBreakpointInMethod(LAST_BREAK); + + // getting predefined 'exclude' value + reply = jdb.receiveReplyFor(JdbCommand.exclude); + if (reply.length == 0) { + log.complain("Predefined excluded lists of classes is empty"); + success = false; + } else { + + oldExclude = reply[0]; + + for (int testCase = 0; testCase < exclude001a.numThreads; testCase++) { + + reply = jdb.receiveReplyFor(JdbCommand.cont); + + if (jdb.isAtBreakpoint(reply, LAST_BREAK)) { + + threads = jdb.getThreadIds(DEBUGGEE_THREAD); + + if (threads.length != 1) { + log.complain("jdb should report 1 instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + } else { + + reply = jdb.receiveReplyFor(JdbCommand.step); // to get out of lastBreak; + + switch (testCase) { + case 0: // block all + reply = jdb.receiveReplyFor(JdbCommand.exclude + "java.*,javax.*,sun.*,com.sun.*,jdk.*"); + + break; + case 1: // allow java.* + reply = jdb.receiveReplyFor(JdbCommand.exclude + "javax.*,sun.*,com.sun.*,jdk.*"); + break; + case 2: // allow com.sun.* + reply = jdb.receiveReplyFor(JdbCommand.exclude + "java.*,javax.*,sun.*,jdk."); + break; + } + + reply = jdb.receiveReplyFor(JdbCommand.trace + "methods " + threads[0]); + + while (true) { + reply = jdb.receiveReplyFor(JdbCommand.cont); + + grep = new Paragrep(reply); + count = grep.find(JAVA_CORE_METHOD); + if (count > 0) { + if (testCase != 0) { + javaTraced = true; + } else { + log.complain("Trace message for excluded method: " + JAVA_CORE_METHOD); + } + } + + count = grep.find(COM_SUN_METHOD); + if (count > 0) { + if (testCase == 2) { + comTraced = true; + } else { + log.complain("Trace message for excluded method: " + COM_SUN_METHOD); + } + } + + count = grep.find(DEBUGGEE_THREAD + ".run"); + if (count > 0) { + nskTraced = true; + + reply = jdb.receiveReplyFor(JdbCommand.exclude + oldExclude); + reply = jdb.receiveReplyFor(JdbCommand.untrace + "methods "+ threads[0]); + break; + } + } + } + } + } + } + + jdb.contToExit(2); + + if (!javaTraced) { + log.complain("There were no tracing events for " + JAVA_CORE_METHOD + "() method while turned off filter"); + success = false; + } + if (!comTraced) { + log.complain("There were no tracing events for " + COM_SUN_METHOD + "() method while turned off filter"); + success = false; + } + if (!nskTraced) { + log.complain("There were no tracing events for " + DEBUGGEE_THREAD + ".run() method "); + success = false; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/exclude/exclude001/exclude001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.exclude.exclude001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +import com.sun.jdi.*; + + +/* This is debuggee aplication */ +public class exclude001a { + public static void main(String args[]) { + exclude001a _exclude001a = new exclude001a(); + System.exit(exclude001.JCK_STATUS_BASE + _exclude001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + static final String MYTHREAD = "MyThread"; + static final int numThreads = 3; // number of threads. + + static JdbArgumentHandler argumentHandler; + static Log log; + + static Object waitnotify = new Object(); + + public int runIt(String args[], PrintStream out) { + + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + Thread holder [] = new Thread[numThreads]; + + for (int i = 0; i < numThreads ; i++) { + holder[i] = new MyThread(MYTHREAD + "-" + i); + holder[i].start(); + try { + holder[i].join(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for finish of " + MYTHREAD + "-" + i); + return exclude001.FAILED; + } + } + + lastBreak(); + + log.display("Debuggee PASSED"); + return exclude001.PASSED; + } +} + + +class MyThread extends Thread { + String name; + + public MyThread (String s) { + super(s); + name = s; + } + + public void run() { + + exclude001a.lastBreak(); + + long time = java.lang.System.currentTimeMillis(); + + VirtualMachineManager vmm = com.sun.jdi.Bootstrap.virtualMachineManager(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/fields/fields001/fields001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/fields/fields001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'fields <class id>' command. + * There are three test cases: + * - request for the fields defined in class, + * - request for the fields defined in inner class, + * - request for the fields inherited from super class. + * The test passes when reply contains names of all checked fields + * for a given debuggee's class. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.fields.fields001.fields001 + * nsk.jdb.fields.fields001.fields001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.fields.fields001.fields001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.fields.fields001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class fields001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new fields001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.fields.fields001"; + static final String TEST_CLASS = PACKAGE_NAME + ".fields001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String DEBUGGEE_CLASS1 = DEBUGGEE_CLASS + "$Inner"; + static final String DEBUGGEE_CLASS2 = DEBUGGEE_CLASS + "$Extender"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String NOT_VALID_SAMPLE = "is not a valid"; + + static String[] checkedFields1 = { + "i_st", "o_st", + "i_pv", "o_pv", + "i_pt", "o_pt", + "i_pb", "o_pb", + "i_fn", "o_fn", + "i_tr", "o_tr", + "i_vl", "o_vl", + "i_a", "o_a", + "i_aa", "o_aa", + "i_aaa", "o_aaa" + }; + + static String[] checkedFields2 = { + "ii_pv", "oi_pv", + "ii_pt", "oi_pt", + "ii_pb", "oi_pb", + "ii_fn", "oi_fn", + "ii_tr", "oi_tr", + "ii_vl", "oi_vl", + "ii_a", "oi_a", + "ii_aa", "oi_aa", + "ii_aaa", "oi_aaa" + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.fields + DEBUGGEE_CLASS); + if (!checkFields(DEBUGGEE_CLASS, reply, checkedFields1)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.fields + DEBUGGEE_CLASS1); + if (!checkFields(DEBUGGEE_CLASS1, reply, checkedFields2)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.fields + DEBUGGEE_CLASS2); + if (!checkFields(DEBUGGEE_CLASS2, reply, checkedFields2)) { + success = false; + } + + jdb.contToExit(1); + } + + private boolean checkFields (String className, String[] reply, String[] checkedFields) { + Paragrep grep; + String found; + boolean result = true; + int count; + + grep = new Paragrep(reply); + for (int i = 0; i < checkedFields.length; i++) { + count = grep.find(checkedFields[i]); + if (count == 0) { + log.complain("Failed to report field " + checkedFields[i] + " for class " + className); + result = false; + } + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/fields/fields001/fields001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.fields.fields001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class fields001a { + + /* TEST DEPENDANT VARIABLES AND CONSTANTS */ + static final String PACKAGE_NAME = "nsk.jdb.fields.fields001"; + + public static void main(String args[]) { + fields001a _fields001a = new fields001a(); + System.exit(fields001.JCK_STATUS_BASE + _fields001a.runIt(args, System.out)); + } + + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + lastBreak(); + + log.display("Debuggee PASSED"); + return fields001.PASSED; + } + + static int i_st; + private int i_pv; + protected int i_pt; + public int i_pb; + final int i_fn = 0;; + transient int i_tr; + volatile int i_vl; + int [] i_a; + int [][] i_aa; + int [][][] i_aaa; + + static Object o_st; + private Object o_pv; + protected Object o_pt; + public Object o_pb; + final Object o_fn = new Object(); + transient Object o_tr; + volatile Object o_vl; + Object [] o_a; + Object [][] o_aa; + Object [][][] o_aaa; + + class Inner { + private int ii_pv; + protected int ii_pt; + public int ii_pb; + final int ii_fn = 0;; + transient int ii_tr; + volatile int ii_vl; + int [] ii_a; + int [][] ii_aa; + int [][][] ii_aaa; + + private Object oi_pv; + protected Object oi_pt; + public Object oi_pb; + final Object oi_fn = new Object(); + transient Object oi_tr; + volatile Object oi_vl; + Object [] oi_a; + Object [][] oi_aa; + Object [][][] oi_aaa; + } + + class Extender extends Inner {}; + + Inner inner; + Extender extender; + + public fields001a() { + inner = new Inner(); + extender = new Extender(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/ignore/ignore001/ignore001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/ignore/ignore001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'ignore <class_id>' command. + * The tests sets catch hooks for two different exception + * which are thrown in the debuggee. Then these hooks are + * removed by 'ignore' command. The test checks the jdb does + * not halt execution on removed catch hooks. + * COMMENTS + * The test was updated due fix of the bug 4683795. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.ignore.ignore001.ignore001 + * nsk.jdb.ignore.ignore001.ignore001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.ignore.ignore001.ignore001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.ignore.ignore001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class ignore001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new ignore001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.ignore.ignore001"; + static final String TEST_CLASS = PACKAGE_NAME + ".ignore001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String EXCEPTION_SAMPLE = "Exception occurred:"; + static final String REMOVED_SAMPLE = "Removed:"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + +// jdb.setBreakpointInMethod(LAST_BREAK); + + log.display("Setting catch for: " + nsk.jdb.ignore.ignore001.ignore001a.JAVA_EXCEPTION); + reply = jdb.receiveReplyFor(JdbCommand._catch + " caught " + nsk.jdb.ignore.ignore001.ignore001a.JAVA_EXCEPTION); + + log.display("Setting catch for: " + nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION1); + reply = jdb.receiveReplyFor(JdbCommand._catch + " caught " + nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION1); + + log.display("Setting catch for: " + nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION2); + reply = jdb.receiveReplyFor(JdbCommand._catch + " caught " + nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION2); + + for (;;) { + if (!checkCatch(nsk.jdb.ignore.ignore001.ignore001a.JAVA_EXCEPTION)) { + success = false; + } + if (!checkCatch(nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION1)) { + success = false; + } + if (!checkCatch(nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION2)) { + success = false; + } + + if (!checkIgnore(nsk.jdb.ignore.ignore001.ignore001a.JAVA_EXCEPTION)) { + success = false; + } + if (!checkIgnore(nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION1)) { + success = false; + } + if (!checkIgnore(nsk.jdb.ignore.ignore001.ignore001a.USER_EXCEPTION2)) { + success = false; + } + + jdb.contToExit(6); + + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + count = grep.find(EXCEPTION_SAMPLE); + if (count != 3) { + success = false; + log.complain("Should report 3 catched exceptions."); + log.complain("Reported catched exception count is " + count); + } + break; + } + } + + private boolean checkCatch (String exceptionName) { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + boolean result = true; + +// log.display("Resuming debuggee."); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + v = new Vector(); + v.add(EXCEPTION_SAMPLE); + v.add(exceptionName); + + grep = new Paragrep(reply); + found = grep.findFirst(v); + if (found.length() == 0) { + log.complain("Failed to catch " + exceptionName); + result = false; + } + return result; + } + + private boolean checkIgnore (String exceptionName) { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + boolean result = true; + + log.display("Unsetting catch for: " + exceptionName); + reply = jdb.receiveReplyFor(JdbCommand.ignore + " caught " + exceptionName); + + v = new Vector(); + v.add(REMOVED_SAMPLE); + v.add(exceptionName); + + grep = new Paragrep(reply); + found = grep.findFirst(v); + if (found.length() == 0) { + log.complain("Failed to remove catch for " + exceptionName); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/ignore/ignore001/ignore001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.ignore.ignore001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class ignore001a { + + /* TEST DEPENDANT VARIABLES AND CONSTANTS */ + static final String PACKAGE_NAME = "nsk.jdb.ignore.ignore001"; + static final String JAVA_EXCEPTION = "java.lang.NumberFormatException"; + static final String USER_EXCEPTION1 = PACKAGE_NAME + ".ignore001a$Exception1"; + static final String USER_EXCEPTION2 = PACKAGE_NAME + ".Exception2"; + + static JdbArgumentHandler argumentHandler; + static Log log; + + public static void main(String args[]) { + ignore001a _ignore001a = new ignore001a(); + System.exit(ignore001.JCK_STATUS_BASE + _ignore001a.runIt(args, System.out)); + } + +// static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + for (int i = 0; i < 6; i++) { + a(i); + } + + log.display("Debuggee PASSED"); + return ignore001.PASSED; + } + + private void a (int i) { + try { + switch (i) { + case 0: case 3: + log.display("Throwing NumberFormatException, i = " + i); + throw new java.lang.NumberFormatException(); + case 1: case 4: + log.display("Throwing Exception1, i = " + i); + throw new Exception1(); + case 2: case 5: + log.display("Throwing Exception2, i = " + i); + throw new Exception2(); + } + } catch (java.lang.NumberFormatException e0) { + } catch (Exception1 e1) { + } catch (Exception2 e2) { + } +// lastBreak(); + } + + class Exception1 extends Exception {} +} + +class Exception2 extends Exception {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/interrupt/interrupt001/interrupt001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/interrupt/interrupt001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'interrupt <thread id>' command. + * The debuggee program (interrupt001a.java) creates a number of additional + * threads with name like "MyThread-<number>" and starts them. The jdb + * suspends the debuggee at a moment when the additional threads are + * waiting for notification for lock objects and then tries to interrupt them. + * If these threads are interrupted then a value of the special + * "notInterrupted" variable should not be modified. + * Value of "notInterrupted" variable is checked by "eval <expr>" command. + * The test passes if the value is equal to 0 and fails otherwise.. + * COMMENTS + * Modified due to fix of the bug: + * 4760826 TTY: 'interrupt <threadID>' command sometimes does not work in Mantis + * Modified due to fix of the bug: + * 4974992 Missed prompt with jdb testcase nsk/jdb/interrupt/interrupt001 + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.interrupt.interrupt001.interrupt001 + * nsk.jdb.interrupt.interrupt001.interrupt001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.interrupt.interrupt001.interrupt001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.interrupt.interrupt001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +public class interrupt001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + return new interrupt001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.interrupt.interrupt001"; + static final String TEST_CLASS = PACKAGE_NAME + ".interrupt001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".breakHere"; + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = DEBUGGEE_CLASS + "$" + MYTHREAD; + static final String DEBUGGEE_RESULT = DEBUGGEE_CLASS + ".notInterrupted.get()"; + + static int numThreads = nsk.jdb.interrupt.interrupt001.interrupt001a.numThreads; + + private static Pattern tidPattern = Pattern.compile("(0x[0-9a-f]+)"); + + protected void runCases() { + String[] reply; + Paragrep grep; + String found; + String[] threads; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + threads = jdb.getThreadIds(DEBUGGEE_THREAD); + + if (threads.length != numThreads) { + log.complain("jdb should report " + numThreads + " instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + } + + pauseTillAllThreadsWaiting(threads); + + for (int i = 0; i < threads.length; i++) { + reply = jdb.receiveReplyFor(JdbCommand.interrupt + threads[i]); + } + + reply = jdb.receiveReplyFor(JdbCommand.threads); + reply = jdb.receiveReplyFor(JdbCommand.cont, true); + + reply = jdb.receiveReplyFor(JdbCommand.eval + DEBUGGEE_RESULT); + grep = new Paragrep(reply); + found = grep.findFirst(DEBUGGEE_RESULT + " =" ); + if (found.length() > 0) { + if (found.indexOf(DEBUGGEE_RESULT + " = 0") < 0) { + log.complain("Not all " + MYTHREAD + "s were interrupted."); + log.complain(found); + success = false; + } + } else { + log.complain("TEST BUG: not found value for " + DEBUGGEE_RESULT); + } + + jdb.contToExit(1); + } + + private void pauseTillAllThreadsWaiting(String[] threads) { + String[] reply; + boolean tidswaiting = false; + + Set<String> tids = new HashSet<>(Arrays.asList(threads)); + Set<String> waitingTids = null; + + do { + String[] thrdsRply = (String[])jdb.receiveReplyFor(JdbCommand.threads); + waitingTids = Arrays.asList(thrdsRply).stream() + .filter((r)-> r.endsWith("waiting")) + .map((r)->{ + Matcher m = tidPattern.matcher(r); + if (m.find()) { + return m.group(1); + } + return null; + }) + .filter((r)-> r != null) + .collect(Collectors.toSet()); + + // If all Tids are waiting set allWorkersAreWaiting to true so + // the main test thread will get out of its breakpoint loop + // and continue with the test. + if (waitingTids.containsAll(tids)) { + reply = jdb.receiveReplyFor(JdbCommand.set + DEBUGGEE_CLASS + ".allWorkersAreWaiting=true"); + tidswaiting = true; + } else { + reply = jdb.receiveReplyFor(JdbCommand.cont); + } + } while (!tidswaiting); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/interrupt/interrupt001/interrupt001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.interrupt.interrupt001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicInteger; + +/* This is debuggee aplication */ +public class interrupt001a { + private class MyThread extends Thread { + final Object lock; + int ind; + String name; + + public MyThread (Object l, int i, String n) { + lock = l; + ind = i; + name = n; + } + + public void run() { + synchronized (lock) { + synchronized (waitnotify) { + threadRunning = true; + waitnotify.notify(); + } + + try { + flags[ind] = false; + while (!flags[ind]) { + lock.wait(); + } + } catch (InterruptedException e) { + notInterrupted.decrementAndGet(); + synchronized (waitnotify) { + waitnotify.notify(); + } + } + } + } + } + + public static void main(String args[]) { + interrupt001a _interrupt001a = new interrupt001a(); + System.exit(interrupt001.JCK_STATUS_BASE + _interrupt001a.runIt(args, System.out)); + } + + static void breakHere () {} + + static final String MYTHREAD = "MyThread"; + static final int numThreads = 5; // number of threads + static volatile boolean allWorkersAreWaiting = false; + + private final Object waitnotify = new Object(); + private volatile boolean threadRunning; + private volatile boolean[] flags = new boolean[numThreads]; + + private JdbArgumentHandler argumentHandler; + private Log log; + + public static final AtomicInteger notInterrupted = new AtomicInteger(numThreads); + + public int runIt(String args[], PrintStream out) { + + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + int i; + Thread[] holder = new Thread[numThreads]; + Object[] locks = new Object[numThreads]; + + for (i = 0; i < numThreads ; i++) { + locks[i] = new Object(); + holder[i] = new MyThread(locks[i], i, MYTHREAD + "-" + i); + } + + synchronized (waitnotify) { + for (i = 0; i < numThreads ; i++) { + holder[i].start(); + try { + threadRunning = false; + while (!threadRunning) { + waitnotify.wait(); + } + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for start of " + MYTHREAD + "-" + i); + return interrupt001.FAILED; + } + } + } + + // allWorkersAreWaiting will be set to true by the debugger thread + // when it sees all of the worker treads are waiting. + do { + breakHere(); // a break to get thread ids and then to interrupt MyThreads. + } while (!allWorkersAreWaiting); + + long waitTime = argumentHandler.getWaitTime() * 60 * 1000; + long startTime = System.currentTimeMillis(); + while (notInterrupted.get() > 0 && System.currentTimeMillis() - startTime <= waitTime) { + synchronized (waitnotify) { + try { + waitnotify.wait(waitTime); + } catch (InterruptedException e) { + log.display("Main thread was interrupted while waiting"); + } + } + } + for (i = 0; i < numThreads ; i++) { + if (holder[i].isAlive()) { + synchronized (locks[i]) { + flags[i] = true; + locks[i].notifyAll(); + } + } + } + breakHere(); // a break to check if MyThreads were interrupted + + log.display("Debuggee PASSED"); + return interrupt001.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/kill/kill001/kill001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/kill/kill001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'kill <thread id> <expr>' command. + * The debuggee program (kill001a.java) creates a number of additional + * threads with name like "MyThread-<number>" and starts them. The jdb + * suspends debuggee at moment when additional threads try to obtain + * lock on synchronized object (previously locked in main thread) + * and then tries to kill them. If these threads are killed then + * a value of the special "notKilled" variable should not be modified. + * Value of "notKilled" variable is checked by "eval <expr>" command. + * The test passes if the value is equal to 0 and fails otherwise.. + * COMMENTS + * Modified due to fix of the test bug: + * 4940902 TEST_BUG: race in nsk/jdb/kill/kill001 + * Modified due to fix of the bug: + * 5024081 TEST_BUG: nsk/jdb/kill/kill001 is slow + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.kill.kill001.kill001 + * nsk.jdb.kill.kill001.kill001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.kill.kill001.kill001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.kill.kill001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class kill001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + return new kill001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.kill.kill001"; + static final String TEST_CLASS = PACKAGE_NAME + ".kill001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".breakHere"; + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + static final String DEBUGGEE_RESULT = DEBUGGEE_CLASS + ".notKilled"; + static final String DEBUGGEE_EXCEPTIONS = DEBUGGEE_CLASS + ".exceptions"; + + static int numThreads = nsk.jdb.kill.kill001.kill001a.numThreads; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + String[] threads; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + threads = jdb.getThreadIds(DEBUGGEE_THREAD); + + if (threads.length != numThreads) { + log.complain("jdb should report " + numThreads + " instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + } + + for (int i = 0; i < threads.length; i++) { + reply = jdb.receiveReplyForWithMessageWait(JdbCommand.kill + threads[i] + " " + + DEBUGGEE_EXCEPTIONS + "[" + i + "]", + "killed"); + } + + for (int i = 0; i <= numThreads; i++) { + reply = jdb.receiveReplyFor(JdbCommand.cont); + } + + // make sure the debugger is at a breakpoint + if (!jdb.isAtBreakpoint(reply, LAST_BREAK)) { + log.display("Expected breakpoint has not been hit yet"); + jdb.waitForMessage(0, LAST_BREAK); + } + log.display("Breakpoint has been hit"); + + reply = jdb.receiveReplyForWithMessageWait(JdbCommand.eval + DEBUGGEE_RESULT, + DEBUGGEE_RESULT + " ="); + grep = new Paragrep(reply); + found = grep.findFirst(DEBUGGEE_RESULT + " =" ); + if (found.length() > 0) { + if (found.indexOf(DEBUGGEE_RESULT + " = 0") < 0) { + log.complain("Not all " + MYTHREAD + "s were killed. " + found + " remaining"); + success = false; + } + } else { + log.complain("Value for " + DEBUGGEE_RESULT + " is not found."); + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.threads); + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/kill/kill001/kill001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.kill.kill001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +/* This is debuggee aplication */ +public class kill001a { + public static void main(String args[]) { + kill001a _kill001a = new kill001a(); + System.exit(kill001.JCK_STATUS_BASE + _kill001a.runIt(args, System.out)); + } + + static void breakHere () {} + + static final String MYTHREAD = "MyThread"; + static final int numThreads = 5; // number of threads. one lock per thread. + static Object lock = new Object(); + static Object waitnotify = new Object(); + public static volatile int notKilled = 0; + static final String message = "kill001a's Exception"; + static int waitTime; + + static JdbArgumentHandler argumentHandler; + static Log log; + + static final Throwable[] exceptions = { + new ThreadDeath(), + new NullPointerException(message), + new SecurityException(message), + new com.sun.jdi.IncompatibleThreadStateException(message), + new MyException(message) + }; + + + public int runIt(String args[], PrintStream out) { + + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + waitTime = argumentHandler.getWaitTime() * 60 * 1000; + + int i; + Thread holder [] = new Thread[numThreads]; + + for (i = 0; i < numThreads ; i++) { + holder[i] = new MyThread(MYTHREAD + "-" + i); + } + + // lock monitor to prevent threads from finishing after they started + synchronized (lock) { + synchronized (waitnotify) { + for (i = 0; i < numThreads ; i++) { + holder[i].start(); + try { + waitnotify.wait(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for start of " + MYTHREAD + "-" + i); + return kill001.FAILED; + } + } + } + breakHere(); // a break to get thread ids and then to kill MyThreads. + } + + // wait during watTime until all MyThreads will be killed + long oldTime = System.currentTimeMillis(); + while ((System.currentTimeMillis() - oldTime) <= kill001a.waitTime) { + boolean waited = false; + for (i = 0; i < numThreads ; i++) { + if (holder[i].isAlive()) { + waited = true; + try { + synchronized(waitnotify) { + waitnotify.wait(1000); + } + } catch (InterruptedException e) { + log.display("Main thread was interrupted while waiting for killing of " + MYTHREAD + "-" + i); + } + } + } + if (!waited) { + break; + } + } + breakHere(); // a break to check if MyThreads were killed + log.display("notKilled == " + notKilled); + + for (i = 0; i < numThreads ; i++) { + if (holder[i].isAlive()) { + log.display("Debuggee FAILED"); + return kill001.FAILED; + } + } + + log.display("Debuggee PASSED"); + return kill001.PASSED; + } + + static class MyException extends Exception { + MyException (String message) { + super(message); + } + } +} + + +class MyThread extends Thread { + String name; + + public MyThread (String n) { + name = n; + } + + public void run() { + // Concatenate strings in advance to avoid lambda calculations later + String ThreadFinished = "WARNING: Thread finished: " + this.name; + String ThreadInterrupted = "WARNING: Thread was interrupted while waiting for killing: " + this.name; + kill001a.log.display("Thread started: " + this.name); + + synchronized (kill001a.waitnotify) { + kill001a.waitnotify.notify(); + } + // prevent thread from early finish + synchronized (kill001a.lock) {} + + // sleep during waitTime to give debugger a chance to kill debugee's thread + try { + Thread.currentThread().sleep(kill001a.waitTime); + } catch (InterruptedException e) { + kill001a.log.display(ThreadInterrupted); + e.printStackTrace(kill001a.log.getOutStream()); + } + + kill001a.notKilled++; + kill001a.log.display(ThreadFinished); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/kill/kill002/kill002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/kill/kill002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'kill <thread id> <expr>' command. + * The debuggee program (kill002a.java) creates a number of additional + * threads with name like "MyThread-<number>" and starts them. The jdb + * suspends debuggee at moment when additional threads are + * waiting for notification for lock objects and then tries to kill them. + * If these threads are killed then a value of the special + * "notKilled" variable should not be modified. + * Value of "notKilled" variable is checked by "eval <expr>" command. + * The test passes if the value is equal to 0 and fails otherwise.. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.kill.kill002.kill002 + * nsk.jdb.kill.kill002.kill002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.kill.kill002.kill002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.kill.kill002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class kill002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + return new kill002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.kill.kill002"; + static final String TEST_CLASS = PACKAGE_NAME + ".kill002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".breakHere"; + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + static final String DEBUGGEE_RESULT = DEBUGGEE_CLASS + ".notKilled"; + static final String DEBUGGEE_EXCEPTIONS = DEBUGGEE_CLASS + ".exceptions"; + + static int numThreads = nsk.jdb.kill.kill002.kill002a.numThreads; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + String[] threads; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + threads = jdb.getThreadIds(DEBUGGEE_THREAD); + + if (threads.length != numThreads) { + log.complain("jdb should report " + numThreads + " instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + } + + for (int i = 0; i < threads.length; i++) { + reply = jdb.receiveReplyForWithMessageWait(JdbCommand.kill + threads[i] + " " + + DEBUGGEE_EXCEPTIONS + "[" + i + "]", + "killed"); + } + reply = jdb.receiveReplyFor(JdbCommand.threads); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // make sure the debugger is at a breakpoint + if (!jdb.isAtBreakpoint(reply, LAST_BREAK)) { + log.display("Expected breakpoint has not been hit yet"); + jdb.waitForMessage(0, LAST_BREAK); + } + log.display("Breakpoint has been hit"); + + reply = jdb.receiveReplyForWithMessageWait(JdbCommand.eval + DEBUGGEE_RESULT, + DEBUGGEE_RESULT + " ="); + grep = new Paragrep(reply); + found = grep.findFirst(DEBUGGEE_RESULT + " =" ); + if (found.length() > 0) { + if (found.indexOf(DEBUGGEE_RESULT + " = 0") < 0) { + log.complain("Not all " + MYTHREAD + "s were killed. " + found + " remaining"); + success = false; + } + } else { + log.complain("Value for " + DEBUGGEE_RESULT + " is not found."); + success = false; + } + + jdb.contToExit(numThreads + 1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/kill/kill002/kill002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ +package nsk.jdb.kill.kill002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class kill002a { + public static void main(String args[]) { + kill002a _kill002a = new kill002a(); + System.exit(kill002.JCK_STATUS_BASE + _kill002a.runIt(args, System.out)); + } + + static void breakHere () {} + + static final String MYTHREAD = "MyThread"; + static final int numThreads = 5; // number of threads + static Object waitnotify = new Object(); + public static volatile int notKilled = 0; + static final String message = "kill002a's Exception"; + + static JdbArgumentHandler argumentHandler; + static Log log; + + static final Exception[] exceptions = { + new InterruptedException(message), + new NullPointerException(message), + new SecurityException(message), + new com.sun.jdi.IncompatibleThreadStateException(message), + new MyException(message) + }; + + public int runIt(String args[], PrintStream out) { + + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + int i; + Thread[] holder = new Thread[numThreads]; + Object[] locks = new Object[numThreads]; + + for (i = 0; i < numThreads ; i++) { + locks[i] = new Object(); + holder[i] = new MyThread(locks[i], MYTHREAD + "-" + i); + } + + synchronized (waitnotify) { + for (i = 0; i < numThreads ; i++) { + holder[i].start(); + try { + waitnotify.wait(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for start of " + MYTHREAD + "-" + i); + return kill002.FAILED; + } + + synchronized (locks[i]) { // holder[i] must wait on its lock[i] at this moment. + log.display("Thread " + MYTHREAD + "-" + i + " is waiting"); + } + } + } + breakHere(); // a break to get thread ids and then to kill MyThreads. + + // waits on all MyThreads completion in case they were not killed + for (i = 0; i < numThreads ; i++) { + synchronized (locks[i]) { + locks[i].notifyAll(); + } + if (holder[i].isAlive() && !holder[i].interrupted()) { + try { + holder[i].join(); + } catch (InterruptedException e) { + log.display("Main thread was interrupted while waiting for finish of " + MYTHREAD + "-" + i); + } + } + } + breakHere(); // a break to check if MyThreads were killed + + log.display("notKilled == " + notKilled); + log.display("Debuggee PASSED"); + return kill002.PASSED; + } + + static class MyException extends Exception { + MyException (String message) { + super(message); + } + } +} + + +class MyThread extends Thread { + Object lock; + String name; + + public MyThread (Object l, String n) { + lock = l; + name = n; + } + + public void run() { + // Concatenate strings in advance to avoid lambda calculations later + final String ThreadFinished = "WARNING: Thread finished: " + this.name; + String ThreadInterrupted = "WARNING: Thread was interrupted while waiting for killing: " + this.name; + kill002a.log.display("Thread started: " + this.name); + + synchronized (lock) { + synchronized (kill002a.waitnotify) { + kill002a.waitnotify.notify(); + } + + try { + lock.wait(); + kill002a.notKilled++; + kill002a.log.display(ThreadFinished); + } catch (Exception e) { + kill002a.log.display(ThreadInterrupted); + e.printStackTrace(kill002a.log.getOutStream()); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/klass/class001/class001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/class/class001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test case for the 'class <class_id>' command. + * The test checks if jdb correctly replies on request for + * given debuggee class via 'class' command. + * The test fails if : + * - string "is not a valid" found in reply, + * - reply does not contain full name of a checked class. + * Otherwise the test passes. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.klass.class001.class001 + * nsk.jdb.klass.class001.class001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.klass.class001.class001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.klass.class001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class class001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new class001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.klass.class001"; + static final String TEST_CLASS = PACKAGE_NAME + ".class001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String NOT_VALID_SAMPLE = "is not a valid"; + + static String[] checkedClasses = { + DEBUGGEE_CLASS, + DEBUGGEE_CLASS + "$InnerInt1", + DEBUGGEE_CLASS + "$Inner2", + DEBUGGEE_CLASS + "$Inner3", + DEBUGGEE_CLASS + "$Inner4", + DEBUGGEE_CLASS + "$Inner5", + DEBUGGEE_CLASS + "$Inner6", + PACKAGE_NAME + ".Outer1" + }; + + /* ------------------------------------- */ + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + for (int i = 0; i < checkedClasses.length; i++) { + if (!checkClass(checkedClasses[i])) { + success = false; + } + } + + jdb.contToExit(1); + } + + private boolean checkClass (String className) { + String[] reply; + Paragrep grep; + int count; + String found; + boolean result = true; + + reply = jdb.receiveReplyFor(JdbCommand._class + className); + + grep = new Paragrep(reply); + found = grep.findFirst(NOT_VALID_SAMPLE); + if (found.length() > 0) { + log.complain("Failed to report class " + className); + result = false; + } + found = grep.findFirst(className); + if (found.length() == 0) { + log.complain("Failed to report class " + className); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/klass/class001/class001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.klass.class001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class class001a { + + /* TEST DEPENDANT VARIABLES AND CONSTANTS */ + static final String PACKAGE_NAME = "nsk.jdb.klass.class001"; + + public static void main(String args[]) { + class001a _class001a = new class001a(); + System.exit(class001.JCK_STATUS_BASE + _class001a.runIt(args, System.out)); + } + + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + init(); + + log.display("Debuggee PASSED"); + return class001.PASSED; + } + + interface InnerInt1 {} + public class Inner2 implements InnerInt1 {} + private class Inner3 {} + protected class Inner4 {} + abstract class Inner5 {} + final class Inner6 extends Inner5{} + + private void init () { + Outer1 o1 = new Outer1(); + Inner2 i2 = new Inner2(); + Inner3 i3 = new Inner3(); + Inner4 i4 = new Inner4(); + Inner6 i6 = new Inner6(); + + lastBreak(); + } +} + +class Outer1 {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/list/list002/list002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/list/list002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for the 'list' command. + * It lists the source of given method and the source on a given line. + * The test passes if it find expected strings in jdb's output. + * The test consists of two parts: + * list002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * list002a.java - the debugged application. + * COMMENTS + * The test functionally equals to nsk/jdb/list/list001 test + * and replaces it. + * + * @library /vmTestbase + * /test/lib + * @build nsk.jdb.list.list002.list002 + * nsk.jdb.list.list002.list002a + * @run driver jdk.test.lib.FileInstaller list002a.java src/nsk/jdb/list/list002/list002a.java + * @run main/othervm PropertyResolvingWrapper nsk.jdb.list.list002.list002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * "-jdb.option=-sourcepath src/" + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.list.list002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class list002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new list002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.list.list002"; + static final String TEST_CLASS = PACKAGE_NAME + ".list002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".runIt"; + static final int LINE_NUMBER = 38; + + final static String METHOD_SOURCE[] = new String[] { + "public int runIt(String args[], PrintStream out) {", + "JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args);", + "Log log = new Log(out, argumentHandler);", + "log.display(\"Debuggee PASSED\");", + "return list002.PASSED;" + }; + + final static String LINE_SOURCE = + "System.exit(list002.JCK_STATUS_BASE + _list002a.runIt(args, System.out));"; + + final static String SOURCE_NOT_FOUND = "Source file not found"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.list + "runIt"); + grep = new Paragrep(reply); + if (grep.find(SOURCE_NOT_FOUND) > 0) { + failure(reply[0]); + } else { + for (int i = 0; i < METHOD_SOURCE.length; i++) { + if (grep.find(METHOD_SOURCE[i]) == 0) { + failure("Line is not found in method sources:\n\t"+ + METHOD_SOURCE[i]); + } + } + } + + reply = jdb.receiveReplyFor(JdbCommand.list + LINE_NUMBER); + grep = new Paragrep(reply); + if (grep.find(SOURCE_NOT_FOUND) > 0) { + failure(reply[0]); + } else { + if (grep.find(LINE_SOURCE) == 0) { + failure("Line " + LINE_NUMBER + " is not found:\n\t"+ + LINE_SOURCE); + } + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/list/list002/list002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.list.list002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +// THIS TEST IS LINE NUMBER SENSITIVE + +/* This is debuggee aplication */ +public class list002a { + static list002a _list002a = new list002a(); + + public static void main(String args[]) { // list002.LINE_NUMBER + System.exit(list002.JCK_STATUS_BASE + _list002a.runIt(args, System.out)); + } + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return list002.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/locals/locals002/locals002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/locals/locals002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for the 'locals' command. + * The test sets breakpoints in 'allKindsOfLocals' and 'allKindsOfArgs' + * methods of debugged 'locals002a' class. Once the debuggee is + * suspended in method, the test via 'locals' command compares + * the values of all visible variables with expected ones. + * The test consists of two parts: + * locals002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * locals002a.java - the debugged application. + * COMMENTS + * The test functionally equals to nsk/jdb/locals/locals001 test + * and replaces it. + * Test fixed according to test bug: + * 5045859 TEST_BUG: some JDB tests do not recognize JDB prompt + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.locals.locals002.locals002 + * + * @comment make sure locals002a is compiled w/ full debug info + * @clean nsk.jdb.locals.locals002.locals002a + * @compile -g:lines,source,vars locals002a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.locals.locals002.locals002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.locals.locals002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class locals002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + compoundPromptIdent = COMPOUND_PROMPT_IDENT; + return new locals002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.locals.locals002"; + static final String TEST_CLASS = PACKAGE_NAME + ".locals002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String COMPOUND_PROMPT_IDENT = "main"; + static final int BREAKPOINT_LINE1 = 84; + static final int BREAKPOINT_LINE2 = 100; + + static final String LOCALS[][] = new String[][] { + { "boolVar" , "true" , "false" }, + { "byteVar" , "27" , "12" }, + { "charVar" , "V" , "A" }, + { "shortVar" , "767" , "327" }, + { "intVar" , "1474" , "3647" }, + { "longVar" , "21345" , "65789" }, + { "floatVar" , "3.141" , "4.852" }, + { "doubleVar", "2.578" , "3.8976" }, + { "objVar" , "objVarString" , "objArgString" }, + { "arrVar" , "int[5]" , "int[3]" } + + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.receiveReplyFor(JdbCommand.stop_at + DEBUGGEE_CLASS + ":" + BREAKPOINT_LINE1); + jdb.receiveReplyFor(JdbCommand.stop_at + DEBUGGEE_CLASS + ":" + BREAKPOINT_LINE2); + + jdb.receiveReplyFor(JdbCommand.cont); + reply = jdb.receiveReplyFor(JdbCommand.locals); + grep = new Paragrep(reply); + for (int i = 0; i < LOCALS.length; i++) { + v = new Vector(); + v.add(LOCALS[i][0]); + v.add(LOCALS[i][2]); + if (grep.find(v) == 0) { + failure("Cannot find " + LOCALS[0][0] + + " with expected value: " + LOCALS[i][2]); + } + } + + jdb.receiveReplyFor(JdbCommand.cont); + reply = jdb.receiveReplyFor(JdbCommand.locals); + grep = new Paragrep(reply); + for (int i = 0; i < LOCALS.length; i++) { + v = new Vector(); + v.add(LOCALS[i][0]); + v.add(LOCALS[i][1]); + if (grep.find(v) == 0) { + failure("Cannot find " + LOCALS[0][0] + + " with expected value: " + LOCALS[i][1]); + } + } + + jdb.contToExit(1); + } + + private boolean checkStop () { + Paragrep grep; + String[] reply; + String found; + Vector v; + boolean result = true; + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/locals/locals002/locals002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +// THIS TEST IS LINE NUMBER SENSITIVE + +package nsk.jdb.locals.locals002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class locals002a { + static locals002a _locals002a = new locals002a(); + + public static void main(String args[]) { + System.exit(locals002.JCK_STATUS_BASE + _locals002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int arr[] = new int[3]; + + for (int i = 0 ; i < 3 ; i++) arr[i] = i*i; + + allKindsOfVars ( + false, + (byte)12, + 'A', + (short)327, + 3647, + (long)65789, + (float)4.852, + (double)3.8976, + "objArgString", + arr + ); + + allKindsOfLocals(); + + log.display("Debuggee PASSED"); + return locals002.PASSED; + } + + public void allKindsOfVars ( + boolean boolVar, + byte byteVar, + char charVar, + short shortVar, + int intVar, + long longVar, + float floatVar, + double doubleVar, + Object objVar, + int[] arrVar + ) + { + System.out.println("Arguments but no locals"); // locals002.BREAKPOINT_LINE1 + } + + static void allKindsOfLocals() { + boolean boolVar = true; + byte byteVar = 27; + char charVar = 'V'; + short shortVar = (short)767; + int intVar = 1474; + long longVar = (long)21345; + float floatVar = (float)3.141; + double doubleVar = (double)2.578; + Object objVar = "objVarString"; + int[] arrVar = new int[5]; + + for (int j = 0; j < 5 ; j++) arrVar[j] = j; + System.out.println("Locals but no arguments"); // locals002.BREAKPOINT_LINE2 + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/methods/methods002/methods002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2003, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/methods/methods002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for the 'methods' command. + * The test checks the following cases + * - class with various method modifiers, + * - class with various constructors, + * - class with various overloaded methods, + * - abstract class and interface, + * - implementing class, + * - class with inherited methods, + * - class with inherited and overrided methods. + * The test passes if signatures for all expected methods are listed + * in reply on command for every case. + * The test consists of two parts: + * methods002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * methods002a.java - the debugged application. + * COMMENTS + * This test replaces the nsk/jdb/methods/methods001 one. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.methods.methods002.methods002 + * nsk.jdb.methods.methods002.methods002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.methods.methods002.methods002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.methods.methods002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class methods002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new methods002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.methods.methods002"; + static final String TEST_CLASS = PACKAGE_NAME + ".methods002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // Case for class with method modifiers + String testedClass1 = TEST_CLASS + "a"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass1); + for (int i = 1; i <= 33; i++) { + checkMethod( reply, "m" + intToString(i), 1, testedClass1, testedClass1 ); + } + for (int i = 1; i <= 3; i++) { + checkMethod( reply, "f" + intToString(i), 1, testedClass1, testedClass1 ); + } + + // Case for class with many constructors + String testedClass2 = TEST_CLASS + "b"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass2); + String[] reply1 = toStringArray(reply); // on Windows reply is single string with embedded \r\n symbols + checkMethod( reply1, "<init>", 4, testedClass2, testedClass2 ); + + // Case for class with overloaded methods + String testedClass3 = TEST_CLASS + "c"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass3); + reply1 = toStringArray(reply); // // on Windows reply is single string with embedded \r\n symbols + checkMethod( reply1, "m01", 3, testedClass3, testedClass3 ); + + // Case for abstract class + String testedClass4 = TEST_CLASS + "d"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass4); + checkMethod( reply, "m01", 1, testedClass4, testedClass4 ); + + // Case for interface + String testedClass5 = TEST_CLASS + "i"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass5); + checkMethod( reply, "i01", 1, testedClass5, testedClass5 ); + + // Case for class with implemented method + String testedClass6 = TEST_CLASS + "e"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass6); + checkMethod( reply, "m01", 1, testedClass4, testedClass6 ); + checkMethod( reply, "i01", 1, testedClass5, testedClass6 ); + checkMethod( reply, "m01", 1, testedClass6, testedClass6 ); + + // Case for class with inherited methods + String testedClass7 = TEST_CLASS + "f"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass7); + for (int i = 1; i <= 33; i++) { + checkMethod( reply, "m" + intToString(i), 1, testedClass1, testedClass7 ); + } + for (int i = 1; i <= 3; i++) { + checkMethod( reply, "f" + intToString(i), 1, testedClass1, testedClass7 ); + } + + // Case for class with inherited and overrided methods + String testedClass8 = TEST_CLASS + "g"; + reply = jdb.receiveReplyFor(JdbCommand.methods + testedClass8); + for (int i = 1; i <= 33; i++) { + checkMethod( reply, "m" + intToString(i), 1, testedClass8, testedClass8 ); + } + for (int i = 1; i <= 33; i++) { + checkMethod( reply, "m" + intToString(i), 1, testedClass1, testedClass8 ); + } + for (int i = 1; i <= 3; i++) { + checkMethod( reply, "f" + intToString(i), 1, testedClass1, testedClass8 ); + } + + jdb.contToExit(1); + } + + private void checkMethod ( + String[] reply, /* reply on 'methods' command */ + String methodName, /* method name */ + int expOccur, /* expected number of occurences of the method */ + String ownerClass, /* name of class defining method */ + String testedClass /* name of tested class */ + ) { + + Paragrep grep = new Paragrep(reply); + Vector v = new Vector(); + + v.add(ownerClass); + v.add(methodName); + int j = grep.find(v); + if (j != expOccur) { + failure("Wrong number of occurences of method " + methodName + + "\n\t of class " + ownerClass + + "\n\t in class " + testedClass + + "\n\t expected number: " + expOccur + " got: " + j); + } + } + + private String[] toStringArray (String[] arr) { + Vector v = new Vector(); + for (int i = 0; i < arr.length; i++) { + StringTokenizer st = new StringTokenizer(arr[i], "\r\n"); + while (st.hasMoreTokens()) { + v.add(st.nextToken()); + } + } + Object[] objects = v.toArray(); + String[] results = new String[objects.length]; + for (int i = 0; i < objects.length; i++) { + results[i] = (String)objects[i]; + } + return results; + } + + private String intToString (int i) { + String s = String.valueOf(i); + if (s.length()==1) + s = "0" + s; + return s; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/methods/methods002/methods002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2003, 2018, 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. + */ + +package nsk.jdb.methods.methods002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class methods002a { + static methods002a _methods002a = new methods002a(); + + public static void main(String args[]) { + System.exit(methods002.JCK_STATUS_BASE + _methods002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + methods002b b = new methods002b(1); + methods002c c = new methods002c(); + methods002e e = new methods002e(); + methods002f f = new methods002f(); + methods002g g = new methods002g(); + lastBreak(); + + log.display("Debuggee PASSED"); + return methods002.PASSED; + } + + static long lo; + + // various method modifiers + void m01 (long l) { lo = l; }; + private void m02 (long l) { lo = l; }; + protected void m03 (long l) { lo = l; }; + public void m04 (long l) { lo = l; }; + static void m05 (long l) { lo = l; }; + synchronized void m06 (long l) { lo = l; }; + strictfp void m07 (long l) { lo = l; }; + native void m08 (long l); + public static synchronized strictfp void m09 (long l) { lo = l; }; + + long m10 (long l) { return lo + l; }; + private long m11 (long l) { return lo + l; }; + protected long m12 (long l) { return lo + l; }; + public long m13 (long l) { return lo + l; }; + static long m14 (long l) { return lo + l; }; + synchronized long m15 (long l) { return lo + l; }; + strictfp long m16 (long l) { return lo + l; }; + native long m17 (long l); + public static synchronized strictfp long m18 (long l) { return lo + l; }; + + Object m19 () { return new Object(); }; + private Object m20 () { return new Object(); }; + protected Object m21 () { return new Object(); }; + public Object m22 () { return new Object(); }; + static Object m23 () { return new Object(); }; + synchronized Object m24 () { return new Object(); }; + strictfp Object m25 () { return new Object(); }; + native Object m26 (); + public static synchronized strictfp Object m27 () { return new Object(); }; + + + // array methods + double[] m28 () { return new double[1]; }; + double m29 (double[] arr) {return arr[0];}; + double[][] m30 (double[][] arr) {return arr;}; + + String[] m31 () { return new String[1];}; + String m32 (String[] arr) { return arr[0];}; + String[][] m33 (String[][] arr) {return arr;}; + + // final methods + final void f01 (long l) { lo = l; }; + final long f02 (long l) { return lo + l; }; + final Object f03 () { return new Object(); }; +} + +// Class with many constructors +class methods002b { + int ind; + methods002b (int i) { ind = i; }; + + private methods002b (int i, int j) { ind = i+j; }; + protected methods002b (int i, int j, int k) { ind = i+j+k; }; + public methods002b (int i, int j, int k, int l) { ind = i+j+k+l; }; +} + +// Class with overloaded methods +class methods002c { + int m01 (int i) { return i; }; + int m01 (int i, int j) { return i+j; }; + int m01 (int i, short j) { return i+j; }; +} + +// Class with abstract methods +abstract class methods002d { + abstract void m01 (); +} + +interface methods002i { + void i01 (); +} + +class methods002e extends methods002d implements methods002i { + void m01 () {}; + public void i01 () {}; +} + +// Class with inherited methods +class methods002f extends methods002a {} + +// Class with inherited and overrided method +class methods002g extends methods002f { + static long lo; + + void m01 (long l) { lo = l; }; + private void m02 (long l) { lo = l; }; + protected void m03 (long l) { lo = l; }; + public void m04 (long l) { lo = l; }; + static void m05 (long l) { lo = l; }; + synchronized void m06 (long l) { lo = l; }; + strictfp void m07 (long l) { lo = l; }; + native void m08 (long l); + public static synchronized strictfp void m09 (long l) { lo = l; }; + + long m10 (long l) { return lo + l; }; + private long m11 (long l) { return lo + l; }; + protected long m12 (long l) { return lo + l; }; + public long m13 (long l) { return lo + l; }; + static long m14 (long l) { return lo + l; }; + synchronized long m15 (long l) { return lo + l; }; + strictfp long m16 (long l) { return lo + l; }; + native long m17 (long l); + public static synchronized strictfp long m18 (long l) { return lo + l; }; + + Object m19 () { return new Object(); }; + private Object m20 () { return new Object(); }; + protected Object m21 () { return new Object(); }; + public Object m22 () { return new Object(); }; + static Object m23 () { return new Object(); }; + synchronized Object m24 () { return new Object(); }; + strictfp Object m25 () { return new Object(); }; + native Object m26 (); + public static synchronized strictfp Object m27 () { return new Object(); }; + + double[] m28 () { return new double[1]; }; + double m29 (double[] arr) {return arr[0];}; + double[][] m30 (double[][] arr) {return arr;}; + + String[] m31 () { return new String[1];}; + String m32 (String[] arr) { return arr[0];}; + String[][] m33 (String[][] arr) {return arr;}; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/monitor/monitor001/monitor001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/monitor/monitor001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * A positive test for the 'monitor <command>' command. + * The jdb sets up line breakpoint at the debugged application. Then four different + * commands are set as a "monitor" by 'monitor <command>' command. After resuming the + * debuggee stops at the breakpoint. All "monitored" commands should be executed. + * The test passes if correct replies for all "monitored" commands are found in jdb stdout + * stream. + * The test consists of two program: + * monitor001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * monitor001a.java - the debugged application. + * COMMENTS + * The test was updated due fix of the bug 4686159. + * Test fixed according to test bug: + * 5041797 TEST_BUG: race condition in JDB output readirectors + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.monitor.monitor001.monitor001 + * nsk.jdb.monitor.monitor001.monitor001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.monitor.monitor001.monitor001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.monitor.monitor001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class monitor001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new monitor001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.monitor.monitor001"; + static final String TEST_CLASS = PACKAGE_NAME + ".monitor001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final int LINE_NUMBER = 47; + + static final String[] CHECKED_COMMANDS = { + JdbCommand.threads, + JdbCommand.methods + DEBUGGEE_CLASS, + JdbCommand.fields + DEBUGGEE_CLASS, + JdbCommand.eval + "(new java.lang.String(\"Hello, World\")).length()" + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + reply = jdb.receiveReplyFor(JdbCommand.stop_at + DEBUGGEE_CLASS + ":" + LINE_NUMBER); + + for (int i = 0; i < CHECKED_COMMANDS.length; i++) { + reply = jdb.receiveReplyFor(JdbCommand.monitor + CHECKED_COMMANDS[i]); + } + + int repliesCount = CHECKED_COMMANDS.length + 1; + reply = jdb.receiveReplyFor(JdbCommand.cont, true, repliesCount); + + reply = jdb.receiveReplyFor(JdbCommand.monitor); + if (!checkMonitors(reply)) { + success = false; + } + + jdb.contToExit(1); + + reply = jdb.getTotalReply(); + if (!checkCommands(reply)) { + success = false; + } + } + + private boolean checkMonitors(String[] reply) { + Paragrep grep; + String found; + Vector v; + boolean result = true; + int count; + + grep = new Paragrep(reply); + for (int i = 0; i < CHECKED_COMMANDS.length; i++) { + if ((count = grep.find(CHECKED_COMMANDS[i])) != 1) { + log.complain("Wrong number of monitor command: " + CHECKED_COMMANDS[i]); + log.complain(" Expected: 1; found: " + count); + result = false; + } + } + + return result; + } + + private boolean checkCommands(String[] reply) { + Paragrep grep; + String found; + Vector v = new Vector(); + boolean result = true; + int count; + + grep = new Paragrep(reply); + + // check 'threads' + v.add("java.lang.Thread"); + v.add("main"); + if ((count = grep.find(v)) != 1) { + log.complain("Wrong number of execution of monitored command: " + CHECKED_COMMANDS[0]); + log.complain(" Expected: 1; found: " + count); + result = false; + } + // check 'methods' + if ((count = grep.find("runIt(java.lang.String[], java.io.PrintStream)")) != 1) { + log.complain("Wrong number of execution of monitored command: " + CHECKED_COMMANDS[1]); + log.complain(" Expected: 1; found: " + count); + result = false; + } + // check 'fields' + if ((count = grep.find(DEBUGGEE_CLASS + " _monitor001a")) != 1) { + log.complain("Wrong number of execution of monitored command: " + CHECKED_COMMANDS[2]); + log.complain(" Expected: 1; found: " + count); + result = false; + } + // check 'eval' + if ((count = grep.find("length() = 12")) != 1) { + log.complain("Wrong number of execution of monitored command: " + CHECKED_COMMANDS[3]); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/monitor/monitor001/monitor001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.monitor.monitor001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +// THIS TEST IS LINE NUMBER SENSITIVE + +/* This is debuggee aplication */ +public class monitor001a { + static monitor001a _monitor001a = new monitor001a(); + + public static void main(String args[]) { + System.exit(monitor001.JCK_STATUS_BASE + _monitor001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + int localInt = 0; // monitor001.LINE_NUMBER + localInt++; // dummy breakpoint + log.display("Debuggee PASSED"); + return monitor001.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/next/next001/next001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/next/next001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'next' command. + * The debuggee program (next001a.java) creates two additional + * threads of MyThread type and starts them. The jdb sets up breakpoint + * inside the method 'func2' which is invoked in these addional threads. + * When breakpoint is hitted the checked command is called at the line + * in which debuggee's method ('func3') is invoked. After this, + * the stack trace of the current method is checked by 'where' command. + * The test passes if only calling method ('func2') presents in stack + * trace, but not the called method ('func3'). + * The test consists of two program: + * next001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * next001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.next.next001.next001 + * nsk.jdb.next.next001.next001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.next.next001.next001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.next.next001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class next001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new next001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.next.next001"; + static final String TEST_CLASS = PACKAGE_NAME + ".next001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + + static final String[] checkedMethods = {"func1", "func2", "func3"}; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + String[] threads; + + jdb.setBreakpointInMethod(LAST_BREAK); + + int breakCount = 0; + int nextCount = 0; + for (int i = 0; i < next001a.numThreads; i++) { + reply = jdb.receiveReplyFor(JdbCommand.cont); + if (jdb.isAtBreakpoint(reply, LAST_BREAK)) { + breakCount++; + reply = jdb.receiveReplyFor(JdbCommand.step); // to get out of lastBreak; + + reply = jdb.receiveReplyFor(JdbCommand.next); + if (!checkNext()) { + success = false; + } else { + nextCount++; + } + } + } + + jdb.contToExit(1); + + if (nextCount != next001a.numThreads) { + log.complain("Wrong number of 'next' events: " + nextCount); + log.complain("Must be equal to : " + next001a.numThreads); + success = false; + } + } + + + private boolean checkNext () { + Paragrep grep; + String found; + int count; + boolean result = true; + String[] reply; + + reply = jdb.receiveReplyFor(JdbCommand.where); + + grep = new Paragrep(reply); + count = grep.find(DEBUGGEE_THREAD + "." + checkedMethods[2]); + if (count > 0) { + log.complain("Debuggee is suspended in wrong method after 'next' command: " + DEBUGGEE_THREAD + "." + checkedMethods[2]); + result= false; + } + + count = grep.find(DEBUGGEE_THREAD + "." + checkedMethods[1]); + if (count != 1) { + log.complain("Checked method does not exist in thread stack trace: " + DEBUGGEE_THREAD + "." + checkedMethods[1]); + result= false; + } + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/next/next001/next001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.next.next001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class next001a { + public static void main(String args[]) { + next001a _next001a = new next001a(); + System.exit(next001.JCK_STATUS_BASE + _next001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + static final String MYTHREAD = "MyThread"; + static final int numThreads = 2; // number of threads. + + static JdbArgumentHandler argumentHandler; + static Log log; + + static Object waitnotify = new Object(); + + public int runIt(String args[], PrintStream out) { + + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + Thread holder [] = new Thread[numThreads]; + + for (int i = 0; i < numThreads ; i++) { + holder[i] = new MyThread(); + holder[i].start(); + try { + holder[i].join(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for finish of " + MYTHREAD + "-" + i); + return next001.FAILED; + } + } + + log.display("Debuggee PASSED"); + return next001.PASSED; + } +} + + +class MyThread extends Thread { + public void run() { + int runLocal = func1(100); + } + + public int func1(int i) { + return func2(i); + } + + public int func2(int i) { + next001a.lastBreak(); + int int2 = func3(i); // this is the line before 'next' command + return int2; // this is the line after 'next' command + } + + public int func3(int i) { + return i*i; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect001/connect001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/connect/connect001. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-connect' option with 'com.sun.jdi.CommandLineLaunch" + * connector. + * Jdb is started with particular connector argument. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.options.connect.connect001a" string + * is found in jdb's output stream: + * The test consists of two parts: + * connect001.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * connect001a.java - the debugged application. + * COMMENTS + * The test is similar to nsk/jdb/run/run002, but uses particular connector + * overriding settings in ini-file. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.connect.connect001.connect001 + * nsk.jdb.options.connect.connect001.connect001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.options.connect.connect001.connect001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -connector=launching + * -transport=default + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.connect.connect001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class connect001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new connect001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect.connect001"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected boolean shouldPass() { + String feature = "com.sun.jdi.CommandLineLaunch"; + if (argumentHandler.shouldPass(feature)) { + log.println("Test passes because of not implemented feature: " + feature); + return true; + } + return super.shouldPass(); + } + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect001/connect001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2004, 2018, 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. + */ + +package nsk.jdb.options.connect.connect001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class connect001a { + static connect001a _connect001a = new connect001a(); + + public static void main(String args[]) { + System.exit(connect001.JCK_STATUS_BASE + _connect001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return connect001.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect002/connect002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/connect/connect002. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-connect' option with 'com.sun.jdi.SocketAttach" + * connector. + * Jdb is started with particular connector argument. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.options.connect.connect002a" string + * is found in jdb's output stream: + * The test consists of two parts: + * connect002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * connect002a.java - the debugged application. + * COMMENTS + * The test is similar to nsk/jdb/run/run002, but uses particular connector + * overriding settings in ini-file. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.connect.connect002.connect002 + * nsk.jdb.options.connect.connect002.connect002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.options.connect.connect002.connect002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -connector=attaching + * -transport=socket + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.connect.connect002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class connect002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new connect002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect.connect002"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected boolean shouldPass() { + String feature = "com.sun.jdi.SocketAttach"; + if (argumentHandler.shouldPass(feature)) { + log.println("Test passes because of not implemented feature: " + feature); + return true; + } + return super.shouldPass(); + } + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect002/connect002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2004, 2018, 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. + */ + +package nsk.jdb.options.connect.connect002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class connect002a { + static connect002a _connect002a = new connect002a(); + + public static void main(String args[]) { + System.exit(connect002.JCK_STATUS_BASE + _connect002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return connect002.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect003/connect003.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/connect/connect003. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-connect' option with 'com.sun.jdi.SharedMemoryAttach" + * connector. + * Jdb is started with particular connector argument. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.options.connect.connect003a" string + * is found in jdb's output stream: + * The test consists of two parts: + * connect003.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * connect003a.java - the debugged application. + * COMMENTS + * The test is similar to nsk/jdb/run/run002, but uses particular connector + * overriding settings in ini-file. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.connect.connect003.connect003 + * nsk.jdb.options.connect.connect003.connect003a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.options.connect.connect003.connect003 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -connector=attaching + * -transport=shmem + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.connect.connect003; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class connect003 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new connect003().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect.connect003"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect003"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected boolean shouldPass() { + String feature = "com.sun.jdi.SharedMemoryAttach"; + if (argumentHandler.shouldPass(feature)) { + log.println("Test passes because of not implemented feature: " + feature); + return true; + } + return super.shouldPass(); + } + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect003/connect003a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2004, 2018, 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. + */ + +package nsk.jdb.options.connect.connect003; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class connect003a { + static connect003a _connect003a = new connect003a(); + + public static void main(String args[]) { + System.exit(connect003.JCK_STATUS_BASE + _connect003a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return connect003.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect004/connect004.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/connect/connect004. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-connect' option with 'com.sun.jdi.SocketListen" + * connector. + * Jdb is started with particular connector argument. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.options.connect.connect004a" string + * is found in jdb's output stream: + * The test consists of two parts: + * connect004.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * connect004a.java - the debugged application. + * COMMENTS + * The test is similar to nsk/jdb/run/run002, but uses particular connector + * overriding settings in ini-file. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.connect.connect004.connect004 + * nsk.jdb.options.connect.connect004.connect004a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.options.connect.connect004.connect004 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -connector=listening + * -transport=socket + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.connect.connect004; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class connect004 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new connect004().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect.connect004"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect004"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected boolean shouldPass() { + String feature = "com.sun.jdi.SocketListen"; + if (argumentHandler.shouldPass(feature)) { + log.println("Test passes because of not implemented feature: " + feature); + return true; + } + return super.shouldPass(); + } + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect004/connect004a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2004, 2018, 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. + */ + +package nsk.jdb.options.connect.connect004; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class connect004a { + static connect004a _connect004a = new connect004a(); + + public static void main(String args[]) { + System.exit(connect004.JCK_STATUS_BASE + _connect004a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return connect004.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect005/connect005.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/connect/connect005. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-connect' option with 'com.sun.jdi.SharedMemoryListen" + * connector. + * Jdb is started with particular connector argument. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.options.connect.connect005a" string + * is found in jdb's output stream: + * The test consists of two parts: + * connect005.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * connect005a.java - the debugged application. + * COMMENTS + * The test is similar to nsk/jdb/run/run002, but uses particular connector + * overriding settings in ini-file. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.connect.connect005.connect005 + * nsk.jdb.options.connect.connect005.connect005a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.options.connect.connect005.connect005 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -connector=listening + * -transport=shmem + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.connect.connect005; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class connect005 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new connect005().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect.connect005"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect005"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected boolean shouldPass() { + String feature = "com.sun.jdi.SharedMemoryListen"; + if (argumentHandler.shouldPass(feature)) { + log.println("Test passes because of not implemented feature: " + feature); + return true; + } + return super.shouldPass(); + } + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/connect/connect005/connect005a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2004, 2018, 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. + */ + +package nsk.jdb.options.connect.connect005; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class connect005a { + static connect005a _connect005a = new connect005a(); + + public static void main(String args[]) { + System.exit(connect005.JCK_STATUS_BASE + _connect005a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return connect005.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/options/listconnectors/listconnectors001/listconnectors001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2004, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/options/listconnectors/listconnectors001. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for '-listconnectors' option of jdb. + * This test checks that jdb started with tested option prints to stdout + * list of connectors and transports, that includes all supported + * connectors and transport configurations: + * com.sun.jdi.CommandLineLaunch (dt_socket, dt_shmem) + * com.sun.jdi.RawLineLaunch (dt_socket, dt_shmem) + * com.sun.jdi.SocketAttach (dt_socket) + * com.sun.jdi.SocketListen (dt_socket) + * com.sun.jdi.SharedMemoryAttach (dt_shmem) + * com.sun.jdi.SharedMemoryListen (dt_shmem) + * Those configurations, which are not supported on tested platform, + * are just ignored. + * This test does not actually use debuggee class and any connectors + * regardless of settings in ini-file, and the main test class + * specifically overrides default behaviour of framework classes. + * The test consists of one part: + * listconnectors001.java - test driver, i.e. launches jdb + * and checks its output. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.options.listconnectors.listconnectors001.listconnectors001 + * @run main/othervm PropertyResolvingWrapper + * nsk.jdb.options.listconnectors.listconnectors001.listconnectors001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -jdb.option=-listconnectors + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.options.listconnectors.listconnectors001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class listconnectors001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new listconnectors001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.options.connect"; + static final String TEST_CLASS = PACKAGE_NAME + ".connect001"; + static final String DEBUGGEE_CLASS = null; + static final String FIRST_BREAK = null; + static final String LAST_BREAK = null; + + static final String TESTED_OPTION = "-listconnectors"; + static final String TESTED_CONNECTORS_LIST[] = { + "com.sun.jdi.CommandLineLaunch", "dt_socket", + "com.sun.jdi.CommandLineLaunch", "dt_shmem", + "com.sun.jdi.RawCommandLineLaunch", "dt_socket", + "com.sun.jdi.RawCommandLineLaunch", "dt_shmem", + "com.sun.jdi.SocketAttach", "dt_socket", + "com.sun.jdi.SocketListen", "dt_socket", + "com.sun.jdi.SharedMemoryAttach", "dt_shmem", + "com.sun.jdi.SharedMemoryListen", "dt_shmem", + }; + static final int TESTED_CONNECTORS_COUNT = TESTED_CONNECTORS_LIST.length / 2; +/* + protected void launchJdbAndDebuggee(String debuggeeClass) throws Exception { + String jdbExecPath = argumentHandler.getJdbExecPath(); + String args[] = {jdbExecPath, TESTED_OPTION}; + + launcher = new Launcher(argumentHandler, log); + jdb = new Jdb(launcher); + jdb.launch(args); + } + */ + + protected void initJdb() { + // do nothing + } + + protected void runCases() { + // do noting + } + + protected void afterJdbExit() { + String[] reply = jdb.getTotalReply(); + + for (int i = 0; i < TESTED_CONNECTORS_COUNT; i++) { + String connector = TESTED_CONNECTORS_LIST[i*2 + 0]; + String transport = TESTED_CONNECTORS_LIST[i*2 + 1]; + Paragrep grep = new Paragrep(reply); + + Vector<String> v = new Vector<String>(); + v.add(Jdb.SUPPORTED_CONNECTOR_NAME); + v.add(connector); + v.add(Jdb.SUPPORTED_TRANSPORT_NAME); + if (!transport.equals("*")) { + v.add(transport); + } + + int found = grep.find(v); + if (found == 1) { + display("expected connector found:\n" + + " connector: " + connector + + " transport: " + transport + + " found: " + found); + } else if (found > 1) { + failure("duplicated connector found (see jdb.stdout):\n" + + " connector: " + connector + + " transport: " + transport + + " found: " + found); + } else if (argumentHandler.shouldPass(connector) + || argumentHandler.shouldPass(connector, transport)) { + display("unsupported connector not found:\n" + + " connector: " + connector + + " transport: " + transport + + " found: " + found); + } else { + failure("no expected connector found (see jdb.stdout):\n" + + " connector: " + connector + + " transport: " + transport + + " found: " + found); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/pop/pop001/pop001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/pop/pop001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * A positive test case for the 'pop' command. + * The debugged application (pop001a.java) starts additional thread of MyThread + * class. The 'run()' method of the this class invokes recursively a number of + * int methods. The jdb sets breakpoint in the last called 'func5()' method + * to suspend the debugged VM when all the methods, i.e. from 'func1()' to + * 'func5()', are in MyThread's stack. Then jdb steps up three frame on stack + * by 'up 3' command. At this moment frame with 'func2()' is current. + * Then the 'pop' command is called. The test passes if after execution of + * tested command the 'func1()' frame becomes current and jdb correctly reports + * the thread stack and local variable(s) of the current frame. + * The test consists of two program: + * pop001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * pop001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.pop.pop001.pop001 + * nsk.jdb.pop.pop001.pop001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.pop.pop001.pop001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.pop.pop001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class pop001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new pop001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.pop.pop001"; + static final String TEST_CLASS = PACKAGE_NAME + ".pop001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + static final String[] CHECKED_METHODS = {"func1", "func2", "func3", "func4", "func5"}; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + while (true) { + String[] threads = jdb.getThreadIds(DEBUGGEE_THREAD); + if (threads.length != 1) { + log.complain("jdb should report 1 instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + break; + } + + reply = jdb.receiveReplyFor(JdbCommand.thread + threads[0]); + + reply = jdb.receiveReplyFor(JdbCommand.step); // to get out of lastBreak() + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func5", "[1]", "lastBreak", false)) { + success = false; + } + reply = jdb.receiveReplyFor(JdbCommand.up + " 3"); + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func2", "[4]", "func3", false)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.pop); + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func1", "[1]", "func2", true)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.locals); + grep = new Paragrep(reply); + if (grep.find("Internal exception") > 0) { + log.complain("Internal exception was thrown while 'locals' command"); + for (int i = 0; i < reply.length; i++) { + log.complain(reply[i]); + } + success = false; + } + + break; + } + + jdb.contToExit(2); + } + + private boolean checkStack (String[] reply, String shouldBe, String frameNum, String shouldNotBe, boolean pop ) { + Paragrep grep; + String found; + Vector v = new Vector(); + boolean result = true; + int count; + + grep = new Paragrep(reply); + v.add(frameNum); + v.add(DEBUGGEE_THREAD + "." + shouldBe); + if ((count = grep.find(v)) != 1) { + log.complain("Contents of stack trace is incorrect " + ( pop? "after 'pop' command": "")); + log.complain("Searched for: " + DEBUGGEE_THREAD + "." + shouldBe); + log.complain("Count : " + count); + result = false; + } + + if (grep.find(DEBUGGEE_THREAD + "." + shouldNotBe) > 0) { + log.complain("Contents of stack trace is incorrect " + ( pop? "after 'pop' command": "")); + log.complain("Found wrong frame: " + DEBUGGEE_THREAD + "." + shouldNotBe); + result = false; + } + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/pop/pop001/pop001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.pop.pop001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class pop001a { + + static final String MYTHREAD = "MyThread"; + + static JdbArgumentHandler argumentHandler; + static Log log; + + static pop001a _pop001a = new pop001a(); + + public static void main(String args[]) { + System.exit(pop001.JCK_STATUS_BASE + _pop001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + MyThread myThread = new MyThread(MYTHREAD); + myThread.start(); + + if (myThread.isAlive()) { + try { + myThread.join(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for finish of " + MYTHREAD); + return pop001.FAILED; + } + } + + log.display("Debuggee PASSED"); + return pop001.PASSED; + } +} + +class MyThread extends Thread { + + public MyThread (String name) { + super(name); + } + + public void run() { + pop001a.log.display("run() started"); + int runLocal; + int j = func1(0); + pop001a.log.display("run() finished"); + } + + public int func1(int intParam) { + pop001a.log.display("func1() started"); + int func1Local; + intParam++; + return func2(intParam); + } + + public int func2(int intParam) { + pop001a.log.display("func2() started"); + int func2Local; + intParam++; + return func3(intParam); + } + + public int func3(int intParam) { + pop001a.log.display("func3() started"); + int func3Local; + intParam++; + return func4(intParam); + } + + public int func4(int intParam) { + pop001a.log.display("func4() started"); + int func4Local; + intParam++; + return func5(intParam); + } + + public int func5(int intParam) { + pop001a.log.display("func5() started"); + int func5Local; + intParam++; + pop001a.lastBreak(); + return intParam; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/pop_exception/pop_exception001/pop_exception001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2012, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/pop_exception/pop_exception001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * Test for cr 6972759 "Step over not working after thrown exception and Pop" + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.pop_exception.pop_exception001.pop_exception001 + * nsk.jdb.pop_exception.pop_exception001.pop_exception001a + * @run main/othervm PropertyResolvingWrapper + * nsk.jdb.pop_exception.pop_exception001.pop_exception001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.pop_exception.pop_exception001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class pop_exception001 extends JdbTest { + + static final String PACKAGE_NAME = "nsk.jdb.pop_exception.pop_exception001"; + static final String TEST_CLASS = PACKAGE_NAME + ".pop_exception001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new pop_exception001().runTest(argv, out); + } + + + + protected void runCases() { + + jdb.receiveReplyFor(JdbCommand._catch + "java.lang.NullPointerException"); + jdb.receiveReplyFor(JdbCommand.cont); + //exception + jdb.receiveReplyFor(JdbCommand.pop); + jdb.receiveReplyFor(JdbCommand.pop); + jdb.receiveReplyFor(JdbCommand.ignore + "java.lang.NullPointerException"); + jdb.receiveReplyFor(JdbCommand.step); + jdb.receiveReplyFor(JdbCommand.next); + jdb.receiveReplyFor(JdbCommand.next); + String[] reply = jdb.receiveReplyFor(JdbCommand.next); + + jdb.quit(); + checkJdbReply(reply); + } + + private void checkJdbReply(String[] jdbReply) { + String replyString = ""; + for(String s: jdbReply) { + replyString += s; + if(s.contains("line=")){ + if(!s.contains("line=" + pop_exception001a.expectedFinish)) { + throw new Failure("FAILED: Expected location: line=" + pop_exception001a.expectedFinish + "\n found: " + s); + } else { + return; + } + } + } + throw new Failure("FAILED: Couldn't determinate finish position: " + replyString); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/pop_exception/pop_exception001/pop_exception001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012, 2018, 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. + */ + +package nsk.jdb.pop_exception.pop_exception001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +// THIS TEST IS LINE NUMBER SENSITIVE + +/** + * debugee application + */ +public class pop_exception001a { + public static void main(String args[]) { + pop_exception001a _pop_exception001a = new pop_exception001a(); + System.exit(Consts.JCK_STATUS_BASE + _pop_exception001a.runIt(args, System.out)); + } + + static JdbArgumentHandler argumentHandler; + static Log log; + + public int runIt(String args[], PrintStream out) { + int i = 0; + Object item = null; + try { + item = new Object(); + i = 5; // expectedFinish + item = getItem(i); + } finally { + System.out.println("item = "+item); + } + return Consts.TEST_PASSED; + } + + private Object getItem(int i) { + if (i == 5) { + throw new NullPointerException("Something went wrong"); + } else { + return new Integer(i); + } + } + + public final static String expectedFinish = "51"; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/print/print002/print002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2003, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/print/print002. + * VM Testbase keywords: [quick, jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * This is a test for the 'print <expr>' command. + * The test checks if jdb correctly prints values for the following + * expressions: + * - arithmetic expression of local variables, + * - boolean expression of local variables, + * - string field deeply nested in class hierarchy. + * The test passes when all printed values are equal to expected ones. + * The test consists of two program: + * print002.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * print002a.java - the debugged application. + * COMMENTS + * The test replaces the nsk/jdb/print/print001 one. + * Test was fixed according to test bug: + * 4862693 NSK testcase nsk/jdb/print/print002 fails with operation not yet supported + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.print.print002.print002 + * + * @comment make sure print002a is compiled w/ full debug info + * @clean nsk.jdb.print.print002.print002a + * @compile -g:lines,source,vars print002a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.print.print002.print002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.print.print002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class print002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new print002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.print.print002"; + static final String TEST_CLASS = PACKAGE_NAME + ".print002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String[][] checkedExpr = { + { "i + j", "8"}, + { "j - i", "4"}, + { "j * i", "12"}, + { "j / i", "3"}, +// { "j % i", "0"}, +// { "i++", "2"}, +// { "++i", "3"}, +// { "j--", "6"}, +// { "--j", "5"}, +// { "!b1 ", "false"}, +// { "b2 && b1", "false"}, +// { "b2 || b1", "true"}, + { "a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.s", "foo" } + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // to get out of lastBreak() + reply = jdb.receiveReplyFor(JdbCommand.step); + + for (int i = 0; i < checkedExpr.length; i++) { + if (!checkValue(checkedExpr[i][0], checkedExpr[i][1])) { + success = false; + } + } + + jdb.contToExit(1); + } + + private boolean checkValue (String expr, String value) { + Paragrep grep; + String[] reply; + String found; + Vector v; + boolean result = true; + + reply = jdb.receiveReplyFor(JdbCommand.print + expr); + grep = new Paragrep(reply); + found = grep.findFirst(value); + if (found.length() <= 0) { + log.complain("jdb failed to report value of expression: " + expr); + log.complain("\t expected : " + value + " ;\n\t reported: " + (reply.length > 0? reply[0]: "")); + result = false; + } + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/print/print002/print002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2003, 2018, 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. + */ + +package nsk.jdb.print.print002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class print002a { + + static print002a _print002a = new print002a(); + + public static void main(String args[]) { + System.exit(print002.JCK_STATUS_BASE + _print002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + int i = 2; + int j = 6; + boolean b1 = true; + boolean b2 = false; + + A a = new A(); + + synchronized (this) { + lastBreak(); + } + + log.display("Debuggee PASSED"); + return print002.PASSED; + } +} + +class A { +B b; +A() { b = new B(); } +} + +class B { +C c; +B() { c = new C(); } +} + +class C { +D d; +C() { d = new D(); } +} + +class D { +E e; +D() { e = new E(); } +} + +class E { +F f; +E() { f = new F(); } +} + +class F { +G g; +F() { g = new G(); } +} + +class G { +H h; +G() { h = new H(); } +} + +class H { +I i; +H() { i = new I(); } +} + +class I { +J j; +I() { j = new J(); } +} + +class J { +K k; +J() { k = new K(); } +} + +class K { +L l; +K() { l = new L(); } +} + +class L { +M m; +L() { m = new M(); } +} + +class M { +N n; +M() { n = new N(); } +} + +class N { +O o; +N() { o = new O(); } +} + +class O { +P p; +O() { p = new P(); } +} + +class P { +Q q; +P() { q = new Q(); } +} + +class Q { +R r; +Q() { r = new R(); } +} + +class R { +S s; +R() { s = new S(); } +} + +class S { +T t; +S() { t = new T(); } +} + +class T { +U u; +T() { u = new U(); } +} + +class U { +V v; +U() { v = new V(); } +} + +class V { +W w; +V() { w = new W(); } +} + +class W { +X x; +W() { x = new X(); } +} + +class X { +Y y; +X() { y = new Y(); } +} + +class Y { +Z z; +Y() { z = new Z(); } +} + +class Z { + String s; + Z() { s = "foo";} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/read/read001/jdb.scenario Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,5 @@ +classes +threads +methods nsk.jdb.read.read001.read001a +fields nsk.jdb.read.read001.read001a +locals
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/read/read001/read001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/read/read001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * A positive test for the 'read <filename>' command. + * The jdb stops the debugged application on enter in read001a.lastBreak() + * method. Then the tested command is called for the 'jdb.scenario' file. + * The test passes if correct replies for all commands containing in + * 'jdb.scenario' are found in jdb stdout stream. + * The test consists of two program: + * read001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * read001a.java - the debugged application. + * COMMENTS + * Only limited number of commands is used in 'jdb.scenario' file because + * the jdb does not wait until end of reply for current command and + * immediatly executes the next command from 'jdb.scenario'. + * Fixed test according to test bug: + * 4665075 TTY: error messages for commands from scenario file of 'read' command + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.read.read001.read001 + * + * @comment make sure read001a is compiled w/ full debug info + * @clean nsk.jdb.read.read001.read001a + * @compile -g:lines,source,vars read001a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.read.read001.read001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.read.read001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class read001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new read001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.read.read001"; + static final String TEST_CLASS = PACKAGE_NAME + ".read001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String SCENARIO_FILE = "jdb.scenario"; + static final int SCENARIO_COMMANDS_COUNT = 5; + + protected void runCases() { + String[] reply; + String workdir = argumentHandler.getWorkDir(); + + // stop in lastBreak() method + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // return to testedInstanceMethod() + reply = jdb.receiveReplyFor(JdbCommand.step); + + String command = JdbCommand.read + workdir + File.separator + SCENARIO_FILE; + int count = SCENARIO_COMMANDS_COUNT + 1; + reply = jdb.receiveReplyFor(command, true, count); + + if (!checkCommands(reply)) { + success = false; + } + + jdb.contToExit(1); + } + + private boolean checkCommands(String[] reply) { + Paragrep grep; + String found; + Vector v = new Vector(); + boolean result = true; + int count; + + grep = new Paragrep(reply); + + // check 'threads' + log.display("Check reply for command: classes"); + if ((count = grep.find("nsk.jdb.read.read001.read001aTestedClass")) != 1) { + log.complain("Wrong number of execution of command: classes"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'threads' + log.display("Check reply for command: threads"); + if ((count = grep.find("TestedThreadInstance")) != 1) { + log.complain("Wrong number of execution of command: threads"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'methods' + log.display("Check reply for command: methods"); + if ((count = grep.find("testedInstanceMethod()")) != 1) { + log.complain("Wrong number of execution of command: methods nsk.jdb.read.read001a"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'fields' + log.display("Check reply for command: fields"); + if ((count = grep.find("testedStaticFieldBoolean")) != 1) { + log.complain("Wrong number of execution of command: fields nsk.jdb.read.read001.presentedInstance"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'locals' + log.display("Check reply for command: locals"); + if ((count = grep.find("testedLocalVarInt")) != 1) { + log.complain("Wrong number of execution of command: locals"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + +/* + // check 'eval' + log.display("Check reply for command: eval"); + if ((count = grep.find("556600")) != 1) { + log.complain("Wrong number of execution of command: " + + "eval nsk.jdb.read.read001a.staticInt+instanceInt*3"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'print' + log.display("Check reply for command: print"); + if ((count = grep.find("staticString = \"static string of read001a class\"")) != 1) { + log.complain("Wrong number of execution of command: " + + "print nsk.jdb.read.read001.read001a.staticString" + ); + log.complain(" Expected: 1; found: " + count); + result = false; + } + + // check 'dump' + log.display("Check reply for command: dump"); + if ((count = grep.find("instance of nsk.jdb.read.read001.read001a")) != 1) { + log.complain("Wrong number of execution of command: " + + "dump nsk.jdb.read.read001.read001a._read001a"); + log.complain(" Expected: 1; found: " + count); + result = false; + } + */ + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/read/read001/read001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.read.read001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class read001a { + + static boolean testedStaticFieldBoolean = true; + double testedInstanceFieldDouble = (double)3.1414926; + + public static void main(String args[]) { + read001a _read001a = new read001a(); + System.exit(read001.JCK_STATUS_BASE + _read001a.runIt(args, System.out)); + } + + void lastBreak () {} + + void testedInstanceMethod() { + int testedLocalVarInt = 0; + String testedLocalVarString = "foo"; + + lastBreak(); + + testedLocalVarString = "bar"; + } + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + int localInt = 0; + + read001aTestedClass obj = new read001aTestedClass(); + read001aTestedThread thread = new read001aTestedThread("TestedThreadInstance"); + + synchronized (thread.finishingMonitor) { + synchronized (thread.startingMonitor) { + try { + thread.start(); + thread.startingMonitor.wait(); + } catch (InterruptedException e) { + throw new Failure("Interrupted while starting tested thread: " + e); + } + } + + testedInstanceMethod(); + } + + try { + thread.join(); + } catch (InterruptedException e) { + throw new Failure("Interrupted while finishing tested thread: " + e); + } + + log.display("Debuggee PASSED"); + return read001.PASSED; + } +} + +class read001aTestedClass { + char instanceFiledChar = 'x'; +} + +class read001aTestedThread extends Thread { + + Object startingMonitor = new Object(); + Object finishingMonitor = new Object(); + + public read001aTestedThread(String name) { + super(name); + } + + public void run() { + synchronized (startingMonitor) { + startingMonitor.notifyAll(); + } + + synchronized (finishingMonitor) { + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/redefine/redefine001/RedefinedClass.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.redefine.redefine001; + +public class RedefinedClass { + public static String foo() { + return "BEFORE_REDEFINITION"; // This string is substituted with + // 'return "AFTER_REDEFINITION";' in + // the newclass/RedefinedClass.java. + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/redefine/redefine001/newclass_g/RedefinedClass.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.redefine.redefine001; + +public class RedefinedClass { + public static String foo() { + return "AFTER_REDEFINITION"; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/redefine/redefine001/redefine001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/redefine/redefine001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'redefine <class id> <class file name>' command. + * The debuggee program invokes three times method 'foo()' of RedefinedClass + * class. This class in redefined with checked command each time before last + * two invocations. If redefinitions occurs then the value returned by 'foo()' + * method must be different from one returned previous invocation. + * The test passes if method 'foo()' of the RedefinedClass returns expected + * values. + * The test consists of three program: + * redefine001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * redefine001a.java - the debugged application. + * RedefinedClass.java - the class to be redefined. + * newclass_g/RedefinedClass.java - the redefining class. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.redefine.redefine001.redefine001 + * nsk.jdb.redefine.redefine001.redefine001a + * + * @comment compile newclass_g/RedefinedClass.java to newclass_g + * @build ExecDriver + * @run driver PropertyResolvingWrapper ExecDriver --cmd + * ${compile.jdk}/bin/javac + * -d ${test.classes}/newclass_g + * -g:lines,source,vars + * -cp ${test.class.path} + * ${test.src}/newclass_g/RedefinedClass.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.redefine.redefine001.redefine001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.redefine.redefine001; + +import nsk.share.*; +import nsk.share.jdb.*; +import nsk.share.classload.ClassLoadUtils; + +import java.io.*; +import java.util.*; + +public class redefine001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new redefine001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.redefine.redefine001"; + static final String TEST_CLASS = PACKAGE_NAME + ".redefine001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String REDEFINED_CLASS = PACKAGE_NAME + ".RedefinedClass"; + static final String BEFORE_REDEFINITION = "BEFORE_REDEFINITION"; + static final String FIRST_REDEFINITION = "AFTER_REDEFINITION"; + static final String SECOND_REDEFINITION = BEFORE_REDEFINITION; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.step); // to get out of lastBreak() + + reply = jdb.receiveReplyFor(JdbCommand.eval + DEBUGGEE_CLASS + ".flag"); + grep = new Paragrep(reply); + if (grep.find(BEFORE_REDEFINITION) == 0) { + log.complain("Wrong value of redefine001a.flag before redefinition: " + (reply.length > 0? reply[0]: "")); + success = false; + } + + String className = RedefinedClass.class.getName(); + String pathToRedefFile1 = ClassLoadUtils.getRedefineClassFileName("newclass_g", className); + if (new File(pathToRedefFile1).exists()) { + reply = jdb.receiveReplyFor(JdbCommand.redefine + REDEFINED_CLASS + " " + pathToRedefFile1); + + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.eval + DEBUGGEE_CLASS + ".flag"); + grep = new Paragrep(reply); + if (grep.find(FIRST_REDEFINITION) == 0) { + log.complain("Wrong value of redefine001a.flag after first redefinition: " + (reply.length > 0? reply[0]: "")); + success = false; + } + } else { + log.complain("File does not exists: " + pathToRedefFile1); + success = false; + } + + String pathToRedefFile2 = ClassLoadUtils.getClassPathFileName(className); + if (new File(pathToRedefFile2).exists()) { + reply = jdb.receiveReplyFor(JdbCommand.redefine + REDEFINED_CLASS + " " + pathToRedefFile2); + + reply = jdb.receiveReplyFor(JdbCommand.cont); + + reply = jdb.receiveReplyFor(JdbCommand.eval + DEBUGGEE_CLASS + ".flag"); + grep = new Paragrep(reply); + if (grep.find(SECOND_REDEFINITION) == 0) { + log.complain("Wrong value of redefine001a.flag after second redefinition: " + (reply.length > 0? reply[0]: "")); + success = false; + } + } else { + log.complain("File does not exists: " + pathToRedefFile2); + success = false; + } + + jdb.contToExit(2); + } + + private boolean checkStop () { + Paragrep grep; + String[] reply; + String found; + Vector v; + boolean result = true; + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/redefine/redefine001/redefine001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.redefine.redefine001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class redefine001a { + static redefine001a _redefine001a = new redefine001a(); + + public static void main(String args[]) { + System.exit(redefine001.JCK_STATUS_BASE + _redefine001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + RedefinedClass c = new RedefinedClass(); + + flag = c.foo(); + + lastBreak(); // at this point RedefinedClass is redefined. + + flag = c.foo(); + + lastBreak(); + + flag = c.foo(); + + lastBreak(); + + log.display("Debuggee PASSED"); + return redefine001.PASSED; + } + + static String flag = ""; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/reenter/reenter001/reenter001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/reenter/reenter001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * A positive test case for the 'reenter' command. + * The debugged application (reenter001a.java) starts additional thread of MyThread + * class. The 'run()' method of the this class invokes recursively a number of + * int methods. The jdb sets breakpoint in the last called 'func5()' method + * to suspend the debugged VM when all the methods, i.e. from 'func1()' to + * 'func5()', are in MyThread's stack. Then jdb steps up three frame on stack + * by 'up 3' command. At this moment frame with 'func2()' is current. + * Then the 'reenter' command is called. The test passes if after execution of + * tested command the 'func2()' frame reentered, i.e. top frame of the stack. + * The test consists of two program: + * reenter001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * reenter001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.reenter.reenter001.reenter001 + * nsk.jdb.reenter.reenter001.reenter001a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.reenter.reenter001.reenter001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.reenter.reenter001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class reenter001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new reenter001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.reenter.reenter001"; + static final String TEST_CLASS = PACKAGE_NAME + ".reenter001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String MYTHREAD = "MyThread"; + static final String DEBUGGEE_THREAD = PACKAGE_NAME + "." + MYTHREAD; + static final String[] CHECKED_METHODS = {"func1", "func2", "func3", "func4", "func5"}; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + while (true) { + String[] threads = jdb.getThreadIds(DEBUGGEE_THREAD); + if (threads.length != 1) { + log.complain("jdb should report 1 instance of " + DEBUGGEE_THREAD); + log.complain("Found: " + threads.length); + success = false; + break; + } + + reply = jdb.receiveReplyFor(JdbCommand.thread + threads[0]); + + reply = jdb.receiveReplyFor(JdbCommand.step); // to get out of lastBreak() + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func5", "[1]", "lastBreak", false)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.up + " 3"); + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func2", "[4]", "func3", false)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.reenter); + + reply = jdb.receiveReplyFor(JdbCommand.where); + if (!checkStack(reply, "func2", "[1]", "func3", true)) { + success = false; + } + + reply = jdb.receiveReplyFor(JdbCommand.locals); + grep = new Paragrep(reply); + if (grep.find("Internal exception") > 0) { + log.complain("Internal exception was thrown while 'locals' command"); + for (int i = 0; i < reply.length; i++) { + log.complain(reply[i]); + } + success = false; + } + + break; + } + + jdb.contToExit(2); + } + + private boolean checkStack (String[] reply, String shouldBe, String frameNum, String shouldNotBe, boolean reenter ) { + Paragrep grep; + String found; + Vector v = new Vector(); + boolean result = true; + int count; + + grep = new Paragrep(reply); + v.add(frameNum); + v.add(DEBUGGEE_THREAD + "." + shouldBe); + if ((count = grep.find(v)) != 1) { + log.complain("Contents of stack trace is incorrect " + ( reenter? "after 'reenter' command": "")); + log.complain("Searched for: " + DEBUGGEE_THREAD + "." + shouldBe); + log.complain("Count : " + count); + result = false; + } + + if (grep.find(DEBUGGEE_THREAD + "." + shouldNotBe) > 0) { + log.complain("Contents of stack trace is incorrect " + ( reenter? "after 'reenter' command": "")); + log.complain("Found wrong frame: " + DEBUGGEE_THREAD + "." + shouldNotBe); + result = false; + } + + return result; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/reenter/reenter001/reenter001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.reenter.reenter001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class reenter001a { + + static final String MYTHREAD = "MyThread"; + + static JdbArgumentHandler argumentHandler; + static Log log; + + static reenter001a _reenter001a = new reenter001a(); + + public static void main(String args[]) { + System.exit(reenter001.JCK_STATUS_BASE + _reenter001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + argumentHandler = new JdbArgumentHandler(args); + log = new Log(out, argumentHandler); + + MyThread myThread = new MyThread(MYTHREAD); + myThread.start(); + + if (myThread.isAlive()) { + try { + myThread.join(); + } catch (InterruptedException e) { + log.complain("Main thread was interrupted while waiting for finish of " + MYTHREAD); + return reenter001.FAILED; + } + } + + log.display("Debuggee PASSED"); + return reenter001.PASSED; + } +} + +class MyThread extends Thread { + + public MyThread (String name) { + super(name); + } + + public void run() { + reenter001a.log.display("run() started"); + int runLocal; + int j = func1(0); + reenter001a.log.display("run() finished"); + } + + public int func1(int intParam) { + reenter001a.log.display("func1() started"); + int func1Local; + intParam++; + return func2(intParam); + } + + public int func2(int intParam) { + reenter001a.log.display("func2() started"); + int func2Local; + intParam++; + return func3(intParam); + } + + public int func3(int intParam) { + reenter001a.log.display("func3() started"); + int func3Local; + intParam++; + return func4(intParam); + } + + public int func4(int intParam) { + reenter001a.log.display("func4() started"); + int func4Local; + intParam++; + return func5(intParam); + } + + public int func5(int intParam) { + reenter001a.log.display("func5() started"); + int func5Local; + intParam++; + reenter001a.lastBreak(); + return intParam; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/regression/b4689395/b4689395.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2002, 2018, 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 4689395 + * @summary converted from VM Testbase nsk/jdb/regression/b4689395. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * Regression test for the bug + * 4689395 (P4/S3) "step over" after a class is redefined acts like "step out" + * Release summary: 1.4 + * Hardware version: generic + * O/S version (unbundled products): 5.8 + * The test consists of two java-files: + * b4689395.java - launches jdb and debuggee, writes commands to jdb, + * reads the jdb output; + * b4689395a.java - the debugged application. + * The debugged application (b4689395a.java) defines method minor() that + * prints four lines into System.out. b4689395 sets a breakpoint on the 54th + * line + * System.out.println("A breakpoint is here."); + * and then redefines b4689395a with newclass/b4689395a. Those classes differ + * just in the 30th line (period is omitted in newclass/b4689395a). After that + * the debuggee invokes 'next' command. The test fails if + * b4689395.ERROR_MESSAGE message appears in output, otherwise the test passes. + * COMMENTS + * The test reproduces the bug on Solsparc. + * java version "1.4.1-beta" + * Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.1-beta-b14) + * Java HotSpot(TM) Client VM (build 1.4.1-beta-b14, mixed mode) + * Command line + * ../jdk1.4.1-b14/solsparc/bin/java b4689395 -arch=sparc + * -waittime=2 -debugee.vmkind=java + * -jdb=../jdk1.4.1-b14/solsparc/bin/jdb + * -workdir=../b4689395 -jdb.option= -debugee.vmkeys= + * #launcher > Compound prompt found: main[1] + * #Test cases starts. + * #Sending command: stop at b4689395a:54 + * # + * #launcher > Compound prompt found: main[1] + * #Sending command: cont + * # + * #launcher > Compound prompt found: main[1] + * #Sending command: redefine b4689395a b4689395/newclass/b4689395a.class + * # + * #launcher > Compound prompt found: main[1] + * #Sending command: next + * # + * #launcher > Compound prompt found: main[1] + * ## ERROR: 'ERROR_M' is not expected to be printed after 'next' command. + * #Sending command: cont + * # + * #Test cases ends. + * #Waiting for jdb exits + * #jdb normally exited + * ## ERROR: TEST FAILED + * # + * # + * ##> + * ##> SUMMARY: Following errors occured + * ##> during test execution: + * ##> + * ## ERROR: 'ERROR_M' is not expected to be printed after 'next' command. + * ## ERROR: TEST FAILED + * + * @library /vmTestbase + * /test/lib + * + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.regression.b4689395.b4689395 + * nsk.jdb.regression.b4689395.b4689395a + * + * @comment compile newclass/b4689395a.java to newclass + * @build ExecDriver + * @run driver PropertyResolvingWrapper ExecDriver --cmd + * ${compile.jdk}/bin/javac + * -d ${test.classes}/newclass + * -cp ${test.class.path} + * ${test.src}/newclass/b4689395a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.regression.b4689395.b4689395 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.regression.b4689395; + +import nsk.share.*; +import nsk.share.jdb.*; +import nsk.share.classload.ClassLoadUtils; + +import java.io.*; +import java.util.*; + +public class b4689395 extends JdbTest { + final static String TEST_CLASS = b4689395.class.getName(); + final static String DEBUGGEE_CLASS = TEST_CLASS + "a"; + final static String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + final static String ERROR_MESSAGE = "ERROR_M"; + final static int LINE_NUMBER = 54; + private String classFile; + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + return new b4689395().runTest(argv, out); + } + + public b4689395() { + classFile = ClassLoadUtils.getRedefineClassFileName(DEBUGGEE_CLASS); + if (classFile == null) + throw new TestFailure("Unable to find redefine class file in classpath for: " + DEBUGGEE_CLASS); + } + + protected void runCases() { + String[] reply; + reply = jdb.receiveReplyFor(JdbCommand.stop_at + DEBUGGEE_CLASS + ":" + LINE_NUMBER); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + if (new File(classFile).exists()) { + reply = jdb.receiveReplyFor(JdbCommand.redefine + DEBUGGEE_CLASS + + " " + classFile); + reply = jdb.receiveReplyFor(JdbCommand.next); + + Paragrep grep = new Paragrep(reply); + if (grep.find(ERROR_MESSAGE) != 0) { + log.complain("'" + ERROR_MESSAGE + "' is not expected to be " + + "printed after 'next' command."); + success = false; + } + } else { + log.complain("File does not exist: " + classFile); + success = false; + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/regression/b4689395/b4689395a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.regression.b4689395; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +// THIS TEST IS LINE NUMBER SENSITIVE + +/* This is debuggee aplication */ +public class b4689395a { + static b4689395a _b4689395a = new b4689395a(); + final static String ERROR_MESSAGE = "ERROR_M"; + + public static void main(String args[]) { + System.exit(Consts.JCK_STATUS_BASE + _b4689395a.runIt(args, System.out)); + } + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + minor(); + + log.display("Debuggee PASSED"); + return Consts.TEST_PASSED; + } + + public static void minor() { + System.out.println("In the top of the method minor()."); // b4689395.LINE_NUMBER + System.out.println("A breakpoint is here."); + System.out.println("In the bottom of the method minor()."); + System.out.println(ERROR_MESSAGE); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/regression/b4689395/newclass/b4689395a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.regression.b4689395; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +// THIS TEST IS LINE NUMBER SENSITIVE + +/* This is debuggee aplication */ +public class b4689395a { + static b4689395a _b4689395a = new b4689395a(); + final static String ERROR_MESSAGE = "ERROR_M"; + + public static void main(String args[]) { + System.exit(Consts.JCK_STATUS_BASE + _b4689395a.runIt(args, System.out)); + } + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + minor(); + + log.display("Debuggee PASSED"); + return Consts.TEST_PASSED; + } + + public static void minor() { + System.out.println("In the top of the method minor()"); // b4689395.LINE_NUMBER + System.out.println("A breakpoint is here."); + System.out.println("In the bottom of the method minor()."); + System.out.println(ERROR_MESSAGE); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/resume/resume002/resume002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/resume/resume002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * This is a test for jdb 'resume all' and 'resume <thread id>' commands. + * The debuggee starts 5 'MyThreads' that are all suspended on the lock + * that the main thread holds. The the test driver issues the following + * commands for check: + * - 'suspend all' : "All threads suspended" message is expected in + * jdb output stream; + * - 'resume all' : "All threads resumed" message is expected in + * jdb output stream; + * - 'suspend <thread_id>' for each 'MyThread'; + * - 'resume <thread_id>' for each 'MyThread'. + * The test consists of two parts: + * resume002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * resume002a.java - the debugged application. + * COMMENTS + * This test functionally equals to nsk/jdb/resume/resume001 test + * and replaces it. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.resume.resume002.resume002 + * nsk.jdb.resume.resume002.resume002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.resume.resume002.resume002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.resume.resume002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class resume002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new resume002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.resume.resume002"; + static final String TEST_CLASS = PACKAGE_NAME + ".resume002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String THREAD_NAME = "MyThread"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + jdb.receiveReplyFor(JdbCommand.cont); + + String[] threadIds = jdb.getThreadIds(PACKAGE_NAME + "." + THREAD_NAME); + + reply = jdb.receiveReplyFor(JdbCommand.suspend); + grep = new Paragrep(reply); + if (grep.find("All threads suspended") == 0) { + failure("jdb cannot suspend all threads"); + } + reply = jdb.receiveReplyFor(JdbCommand.resume, false); + grep = new Paragrep(reply); + if (grep.find("All threads resumed") == 0) { + failure("jdb cannot resume all threads"); + } + + jdb.receiveReplyFor(JdbCommand.thread + threadIds[0]); + + for (int i = 0; i < resume002a.numThreads; i++) { + jdb.receiveReplyFor(JdbCommand.suspend + threadIds[i]); + jdb.receiveReplyFor(JdbCommand.resume + threadIds[i]); + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/resume/resume002/resume002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.resume.resume002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class resume002a { + public static void main(String args[]) { + resume002a _resume002a = new resume002a(); + System.exit(resume002.JCK_STATUS_BASE + _resume002a.runIt(args, System.out)); + } + + static void lastBreak () {} + static int numThreads = 5; // number of threads + static Thread holder [] = new Thread[numThreads]; + + static Object waitnotify = new Object(); + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + Lock lock = new Lock(); + + try { + lock.setLock(); + for (int i = 0; i < numThreads ; i++) { + holder[i] = new MyThread(lock, "MyThread#" + i); + synchronized (waitnotify) { + holder[i].start(); + waitnotify.wait(); + } + } + } catch (Exception e) { + System.err.println("TEST ERROR: Caught unexpected Exception while waiting in main thread: " + + e.getMessage()); + System.exit(resume002.FAILED); + } + + lastBreak(); // When jdb stops here, there should be 5 running MyThreads. + lock.releaseLock(); + + for (int i = 0; i < numThreads ; i++) { + if (holder[i].isAlive()) { + try { + holder[i].join(argumentHandler.getWaitTime() * 60000); + } catch (InterruptedException e) { + throw new Failure("Unexpected InterruptedException catched while waiting for join of: " + holder[i]); + } + } + } + + log.display("Debuggee PASSED"); + return resume002.PASSED; + } + +} + +class Lock { + boolean lockSet; + + synchronized void setLock() throws InterruptedException { + while (lockSet == true) + wait(); + lockSet = true; + } + + synchronized void releaseLock() { + if (lockSet == true) { + lockSet = false; + notify(); + } + } +} + +class MyThread extends Thread { + + Lock lock; + String name; + + MyThread (Lock l, String name) { + this.lock = l; + this.name = name; + } + + public void run() { + synchronized (resume002a.waitnotify) { + resume002a.waitnotify.notifyAll(); + } + try { + lock.setLock(); + } catch(Exception e) { + System.err.println("TEST ERROR: Caught unexpected Exception while waiting in MyThread: " + + e.getMessage()); + System.exit(resume002.FAILED); + } + lock.releaseLock(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/run/run002/run002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/run/run002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DESCRIPTION + * This is a test for the 'run' command. + * The 'run' command is issued in the superclass of test driver class. + * The test is passed if "run nsk.jdb.run.run002a" string is found + * in jdb's output stream: + * The test consists of two parts: + * run002.java - test driver, i.e. launches jdb and debuggee, + * writes commands to jdb, reads the jdb output, + * run002a.java - the debugged application. + * COMMENTS + * This test functionally equals to nsk/jdb/run/run001 test and + * replaces it. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.run.run002.run002 + * nsk.jdb.run.run002.run002a + * @run main/othervm PropertyResolvingWrapper nsk.jdb.run.run002.run002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.run.run002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class run002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new run002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.run.run002"; + static final String TEST_CLASS = PACKAGE_NAME + ".run002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.contToExit(1); + + if (argumentHandler.isLaunchingConnector()) { + reply = jdb.getTotalReply(); + grep = new Paragrep(reply); + v = new Vector(); + v.add(JdbCommand.run); + v.add(DEBUGGEE_CLASS); + if (grep.find(v) != 1) { + failure("jdb failed to run debugged application."); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/run/run002/run002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.run.run002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class run002a { + static run002a _run002a = new run002a(); + + public static void main(String args[]) { + System.exit(run002.JCK_STATUS_BASE + _run002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + + log.display("Debuggee PASSED"); + return run002.PASSED; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/set/set001/set001.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2002, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/set/set001. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'set <lvalue> = <expr>' command. + * The test checks if jdb correctly sets value for the following + * fields and variables: + * - static field, + * - instance field + * The jdb suspends the debuggee inside the method runIt and then tries + * to set new values for the fields and variables using checked command. + * Then the debuggee checks if modified fields/variables have expected + * values. If not, then special errorMessage variable is appended with + * the info of wrong values. The test passes when length of errorMessage + * is equal to 0, and fails otherwise. + * The test consists of two program: + * set001.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * set001a.java - the debugged application. + * COMMENTS + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.set.set001.set001 + * + * @comment make sure set001a is compiled w/ full debug info + * @clean nsk.jdb.set.set001.set001a + * @compile -g:lines,source,vars set001a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.set.set001.set001 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.set.set001; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class set001 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + return new set001().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.set.set001"; + static final String TEST_CLASS = PACKAGE_NAME + ".set001"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String ERROR_MESSAGE = DEBUGGEE_CLASS + ".errorMessage"; + + static final String[][] checkedExpr = { + { DEBUGGEE_CLASS + ".myStaticField", "-2147483648" }, + { DEBUGGEE_CLASS + "._set001a.myInstanceField", "9223372036854775807" }, + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // to get out of lastBreak() + reply = jdb.receiveReplyFor(JdbCommand.step); + + // set values + for (int i = 0; i < checkedExpr.length; i++) { + reply = jdb.receiveReplyFor(JdbCommand.set + checkedExpr[i][0] + " = " + checkedExpr[i][1]); + } + + reply = jdb.receiveReplyFor(JdbCommand.cont); + // check value of debuggeeResult + reply = jdb.receiveReplyFor(JdbCommand.eval + ERROR_MESSAGE); + //if everything is OK reply will look like this + // nsk.jdb.set.set001.set001a.errorMessage = "" + if (!reply[0].contains("\"\"")) { + log.complain("jdb failed to set value for expression(s): "); + for (int i = 0; i < reply.length; i++) { + log.complain(reply[i]); + } + success = false; + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/set/set001/set001a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2002, 2018, 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. + */ + +package nsk.jdb.set.set001; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class set001a { + + private static final String DEBUGGEE_PASSED = "Debuggee PASSED"; + private static final String DEBUGGEE_FAILED = "Debuggee FAILED"; + + static set001a _set001a = new set001a(); + + public static void main(String args[]) { + System.exit(set001.JCK_STATUS_BASE + _set001a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + String debuggeeResult = DEBUGGEE_PASSED; + + int localInt = 0; + lastBreak(); + /* jdb should change values of fileds and variables */ + + if (set001a.myStaticField != Integer.MIN_VALUE) { + errorMessage += "\nWrong value of set001a.myStaticField: " + set001a.myStaticField + ", expected: " + Integer.MIN_VALUE; + } + if (_set001a.myInstanceField != Long.MAX_VALUE) { + errorMessage += "\nWrong value of _set001a.myInstanceField: " + _set001a.myInstanceField + ", expected: " + Long.MAX_VALUE; + } + if (errorMessage.length() > 0) { + debuggeeResult = DEBUGGEE_FAILED; + } + + lastBreak(); // a breakpoint to check value of debuggeeResult + + log.display(debuggeeResult); + if (debuggeeResult.equals(DEBUGGEE_PASSED)) { + return set001.PASSED; + } else { + return set001.FAILED; + } + } + + static String errorMessage = ""; + static private int myStaticField; + protected long myInstanceField; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/set/set002/set002.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2007, 2018, 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 + * + * @summary converted from VM Testbase nsk/jdb/set/set002. + * VM Testbase keywords: [jpda, jdb] + * VM Testbase readme: + * DECSRIPTION + * A positive test for the 'set <lvalue> = <expr>' command. + * The test checks if jdb correctly sets value for the following + * fields and variables: + * - element of array field, + * - local variable + * Probably needs to be merged with set001 + * The jdb suspends the debuggee inside the method runIt and then tries + * to set new values for the fields and variables using checked command. + * Then the debuggee checks if modified fields/variables have expected + * values. If not, then special errorMessage variable is appended with + * the info of wrong values. The test passes when length of errorMessage + * is equal to 0, and fails otherwise. + * The test consists of two programs: + * set002.java - launches jdb and debuggee, writes commands to jdb, reads the jdb output, + * set002a.java - the debugged application. + * + * @library /vmTestbase + * /test/lib + * @run driver jdk.test.lib.FileInstaller . . + * @build nsk.jdb.set.set002.set002 + * + * @comment make sure set002a is compiled w/ full debug info + * @clean nsk.jdb.set.set002.set002a + * @compile -g:lines,source,vars set002a.java + * + * @run main/othervm PropertyResolvingWrapper nsk.jdb.set.set002.set002 + * -arch=${os.family}-${os.simpleArch} + * -waittime=5 + * -debugee.vmkind=java + * -transport.address=dynamic + * -jdb=${test.jdk}/bin/jdb + * -java.options="${test.vm.opts} ${test.java.opts}" + * -workdir=. + * -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" + */ + +package nsk.jdb.set.set002; + +import nsk.share.*; +import nsk.share.jdb.*; + +import java.io.*; +import java.util.*; + +public class set002 extends JdbTest { + + public static void main (String argv[]) { + System.exit(run(argv, System.out) + JCK_STATUS_BASE); + } + + public static int run(String argv[], PrintStream out) { + debuggeeClass = DEBUGGEE_CLASS; + firstBreak = FIRST_BREAK; + lastBreak = LAST_BREAK; + + return new set002().runTest(argv, out); + } + + static final String PACKAGE_NAME = "nsk.jdb.set.set002"; + static final String TEST_CLASS = PACKAGE_NAME + ".set002"; + static final String DEBUGGEE_CLASS = TEST_CLASS + "a"; + static final String FIRST_BREAK = DEBUGGEE_CLASS + ".main"; + static final String LAST_BREAK = DEBUGGEE_CLASS + ".lastBreak"; + + static final String ERROR_MESSAGE = DEBUGGEE_CLASS + ".errorMessage"; + + static final String[][] checkedExpr = { //not broken, can be run safely even if 4660158 is not fixed + { DEBUGGEE_CLASS + "._set002a.myArrayField[0][0].line", "\"ABCDE\"" }, + { "localInt", "java.lang.Integer.MIN_VALUE"} + }; + + protected void runCases() { + String[] reply; + Paragrep grep; + int count; + Vector v; + String found; + + jdb.setBreakpointInMethod(LAST_BREAK); + reply = jdb.receiveReplyFor(JdbCommand.cont); + + // to get out of lastBreak() + reply = jdb.receiveReplyFor(JdbCommand.step); + + // set values + for (int i = 0; i < checkedExpr.length; i++) { + reply = jdb.receiveReplyFor(JdbCommand.set + checkedExpr[i][0] + " = " + checkedExpr[i][1]); + } + + reply = jdb.receiveReplyFor(JdbCommand.cont); + // check value of debuggeeResult + reply = jdb.receiveReplyFor(JdbCommand.eval + ERROR_MESSAGE); + + //if everything is OK reply will look like this + // nsk.jdb.set.set002.set002a.errorMessage = "" + if (!reply[0].contains("\"\"")) { + log.complain("jdb failed to set value for expression(s): "); + for (int i = 0; i < reply.length; i++) { + log.complain(reply[i]); + } + success = false; + } + + jdb.contToExit(1); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/hotspot/jtreg/vmTestbase/nsk/jdb/set/set002/set002a.java Tue May 22 10:08:04 2018 -0700 @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2007, 2018, 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. + */ + +package nsk.jdb.set.set002; + +import nsk.share.*; +import nsk.share.jpda.*; +import nsk.share.jdb.*; + +import java.io.*; + +/* This is debuggee aplication */ +public class set002a { + + private static final String DEBUGGEE_PASSED = "Debuggee PASSED"; + private static final String DEBUGGEE_FAILED = "Debuggee FAILED"; + + static set002a _set002a = new set002a(); + + public static void main(String args[]) { + System.exit(set002.JCK_STATUS_BASE + _set002a.runIt(args, System.out)); + } + + static void lastBreak () {} + + public int runIt(String args[], PrintStream out) { + JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args); + Log log = new Log(out, argumentHandler); + String debuggeeResult = DEBUGGEE_PASSED; + + int localInt = 0; + lastBreak(); + /* jdb should change values of fileds and variables */ + + if (!_set002a.myArrayField[0][0].toString().equals("ABCDE")) { + errorMessage += "\nWrong value of _set002a.myArrayField[0][0]: " + _set002a.myArrayField[0][0] + ", expected: \"ABCDE\""; + } + if (localInt != Integer.MIN_VALUE) { + errorMessage += "\nWrong value of localInt: " + localInt + ", expected: " + Integer.MIN_VALUE; + } + if (errorMessage.length() > 0) { + debuggeeResult = DEBUGGEE_FAILED; + } + + lastBreak(); // a breakpoint to check value of debuggeeResult