1 /*
2  * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 package nsk.jdi.VirtualMachine.resume;
24 
25 import nsk.share.*;
26 import nsk.share.jdi.*;
27 import com.sun.jdi.*;
28 import java.io.*;
29 import com.sun.jdi.event.*;
30 import com.sun.jdi.request.*;
31 
32 public class resume001 extends TestDebuggerType2 {
33 
main(String argv[])34     public static void main(String argv[]) {
35         System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
36     }
37 
run(String argv[], PrintStream out)38     public static int run(String argv[], PrintStream out) {
39         return new resume001().runIt(argv, out);
40     }
41 
debuggeeClassName()42     protected String debuggeeClassName() {
43         return resume001a.class.getName();
44     }
45 
46     class EventListener extends EventHandler.EventListener {
47         Object lock = new Object();
48 
49         volatile int breakpointCounter;
50 
51         volatile int expectedBreakpointNumber;
52 
EventListener(int expectedBreakpointNumber)53         EventListener(int expectedBreakpointNumber) {
54             this.expectedBreakpointNumber = expectedBreakpointNumber;
55         }
56 
waitForBreakpoints()57         void waitForBreakpoints() {
58             synchronized (lock) {
59                 while (breakpointCounter < expectedBreakpointNumber) {
60                     try {
61                         lock.wait();
62                     } catch (InterruptedException e) {
63                         unexpectedException(e);
64                     }
65                 }
66             }
67         }
68 
eventReceived(Event event)69         public boolean eventReceived(Event event) {
70             if (event instanceof BreakpointEvent) {
71                 log.display("BreakpointEvent was received: " + event);
72 
73                 breakpointCounter++;
74 
75                 if (breakpointCounter == expectedBreakpointNumber) {
76                     synchronized (lock) {
77                         lock.notify();
78                     }
79                 }
80 
81                 if (breakpointCounter > expectedBreakpointNumber) {
82                     setSuccess(false);
83                     System.out.println("Extra breakpoint event was received: " + event);
84                 }
85 
86                 return true;
87             }
88 
89             return false;
90         }
91     }
92 
doTest()93     protected void doTest() {
94         ReferenceType testThreadClass = debuggee.classByName(resume001a.class.getName());
95 
96         BreakpointRequest breakpointRequest = null;
97 
98         try {
99             for (Location location : testThreadClass.allLineLocations()) {
100                 if (location.lineNumber() == resume001a.BREAKPOINT_LINE_NUMBER) {
101                     breakpointRequest = debuggee.getEventRequestManager().createBreakpointRequest(location);
102                     break;
103                 }
104             }
105         } catch (AbsentInformationException e) {
106             unexpectedException(e);
107             return;
108         }
109 
110         if (breakpointRequest == null) {
111             setSuccess(false);
112             log.complain("Location for line " + resume001a.BREAKPOINT_LINE_NUMBER + " wasn't found in class " + testThreadClass.name());
113             return;
114         }
115 
116         breakpointRequest.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
117         breakpointRequest.enable();
118 
119         log.display("BreakpointRequest was created: " + breakpointRequest);
120 
121         EventHandler eventHandler = new EventHandler(debuggee, log);
122         eventHandler.startListening();
123 
124         try {
125             /*
126              * Wait for BreakpointEvents from debuggee main thread and from each
127              * additional test thread
128              */
129             final int suspendedThreadsNumber = resume001a.TEST_THREAD_NUMBER + 1;
130 
131             EventListener listener = new EventListener(suspendedThreadsNumber);
132             eventHandler.addListener(listener);
133 
134             pipe.println(resume001a.COMMAND_STOP_ALL_THREADS_AT_BREAKPOINT);
135 
136             listener.waitForBreakpoints();
137 
138             log.display("Resume debuggee VM");
139 
140             debuggee.VM().resume();
141 
142             /*
143              * Wait for replay for previous command (resume001a.COMMAND_STOP_ALL_THREADS_AT_BREAKPOINT)
144              */
145             if (!isDebuggeeReady())
146                 return;
147 
148             pipe.println(resume001a.COMMAND_JOIN_TEST_THREADS);
149 
150             if (!isDebuggeeReady())
151                 return;
152 
153             ReferenceType debuggeeClass = debuggee.classByName(debuggeeClassNameWithoutArgs());
154 
155             Field counterField = debuggeeClass.fieldByName(resume001a.COUNTER_FIELD_NAME);
156             if (counterField == null) {
157                 setSuccess(false);
158                 log.complain("Field " + resume001a.COUNTER_FIELD_NAME + " wasn't found in class " + debuggeeClassNameWithoutArgs());
159                 return;
160             }
161 
162             IntegerValue value = (IntegerValue) debuggeeClass.getValue(counterField);
163 
164             /*
165              * Each suspended thread should increment counter after resuming
166              */
167             if (value.value() != suspendedThreadsNumber) {
168                 setSuccess(false);
169                 log.complain("Unexpected value of field " + resume001a.COUNTER_FIELD_NAME +
170                         ": " + value.intValue() + ", expected value is " + suspendedThreadsNumber);
171             }
172         } finally {
173             eventHandler.stopEventHandler();
174         }
175     }
176 }
177