| /* |
| * Copyright (c) 2006, 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.share.jdi; |
| |
| import java.io.PrintStream; |
| import java.lang.reflect.*; |
| import java.util.*; |
| |
| import com.sun.jdi.*; |
| import com.sun.jdi.event.*; |
| import com.sun.jdi.request.*; |
| import nsk.share.TestBug; |
| |
| /* |
| * Class is used as base debugger in tests for following events and event requests: |
| * - MonitorContendedEnterRequest / MonitorContendedEnterEvent |
| * - MonitorContendedEnteredRequest / MonitorContendedEnteredEvent |
| * - MonitorWaitRequest / MonitorWaitEvent |
| * - MonitorWaitedRequest / MonitorWaitedEvent |
| * |
| * In all these tests similar scenario is used: |
| * - debugger VM forces debuggee VM to create number of objects which should generate events during test |
| * - if any event filters are used each generating event object is checked is this object accepted by all filters, |
| * if object was accepted it should save information about all generated events and this information is available for debugger |
| * - debuggee performs event generation and stop at breakpoint |
| * - debugger reads data saved by event generators and checks is only expected events was generated |
| */ |
| public class JDIEventsDebugger extends TestDebuggerType2 { |
| // types of tested events |
| static public enum EventType { |
| MONITOR_CONTENTED_ENTER, |
| MONITOR_CONTENTED_ENTERED, |
| MONITOR_WAIT, |
| MONITOR_WAITED |
| } |
| |
| /* |
| * Class contains information required for event testing |
| */ |
| static class TestedEventData { |
| // event class |
| public Class<?> eventClass; |
| |
| // class representing event data on debuggee's side |
| public Class<?> eventDataMirrorClass; |
| |
| // class representing event data on debugger's side |
| public Class<?> eventDataClass; |
| |
| public TestedEventData(Class<?> eventClass, Class<?> eventDataMirrorClass, Class<?> eventDataClass) { |
| this.eventClass = eventClass; |
| this.eventDataMirrorClass = eventDataMirrorClass; |
| this.eventDataClass = eventDataClass; |
| } |
| } |
| |
| static public Map<EventType, TestedEventData> testedEventData = new HashMap<EventType, TestedEventData>(); |
| |
| static { |
| testedEventData.put(EventType.MONITOR_CONTENTED_ENTER, new TestedEventData(MonitorContendedEnterEvent.class, |
| DebuggeeEventData.DebugMonitorEnterEventData.class, DebuggerEventData.DebugMonitorEnterEventData.class)); |
| |
| testedEventData.put(EventType.MONITOR_CONTENTED_ENTERED, new TestedEventData(MonitorContendedEnteredEvent.class, |
| DebuggeeEventData.DebugMonitorEnteredEventData.class, DebuggerEventData.DebugMonitorEnteredEventData.class)); |
| |
| testedEventData.put(EventType.MONITOR_WAIT, new TestedEventData(MonitorWaitEvent.class, DebuggeeEventData.DebugMonitorWaitEventData.class, |
| DebuggerEventData.DebugMonitorWaitEventData.class)); |
| |
| testedEventData.put(EventType.MONITOR_WAITED, new TestedEventData(MonitorWaitedEvent.class, |
| DebuggeeEventData.DebugMonitorWaitedEventData.class, DebuggerEventData.DebugMonitorWaitedEventData.class)); |
| } |
| |
| static public TestedEventData[] eventDataByEventTypes(EventType[] eventTypes) { |
| TestedEventData[] result = new TestedEventData[eventTypes.length]; |
| |
| int i = 0; |
| for (EventType eventType : eventTypes) { |
| TestedEventData eventData = testedEventData.get(eventType); |
| |
| if (eventData == null) |
| throw new TestBug("Unsupported event type: " + eventType); |
| |
| result[i++] = eventData; |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Dummy event listener, just accepts all events |
| */ |
| public class DummyEventListener extends EventHandler.EventListener { |
| private volatile boolean breakpointEventReceived; |
| |
| public boolean eventReceived(Event event) { |
| if (event instanceof BreakpointEvent) { |
| breakpointEventReceived = true; |
| vm.resume(); |
| } |
| |
| return true; |
| } |
| |
| public void waitBreakpoint() { |
| while (!breakpointEventReceived) |
| Thread.yield(); |
| } |
| } |
| |
| /* |
| * Parse common for event tests parameters |
| */ |
| protected String[] doInit(String[] args, PrintStream out) { |
| args = super.doInit(args, out); |
| |
| ArrayList<String> standardArgs = new ArrayList<String>(); |
| |
| for (int i = 0; i < args.length; i++) { |
| if (args[i].equals("-allowExtraEvents")) { |
| extraEventClasses = createEventClassArray(args[i + 1]); |
| |
| i++; |
| } else if (args[i].equals("-allowMissedEvents")) { |
| missedEventClasses = createEventClassArray(args[i + 1]); |
| |
| i++; |
| } else |
| standardArgs.add(args[i]); |
| } |
| |
| return standardArgs.toArray(new String[standardArgs.size()]); |
| } |
| |
| // can't control some kinds of events (events from system libraries) and |
| // not all events should be saved for analysis |
| // (should be implemented in subclasses) |
| protected boolean shouldSaveEvent(Event event) { |
| return true; |
| } |
| |
| public Class<?> findEventDataClass(TestedEventData[] testedEventData, Event event) { |
| for (TestedEventData eventData : testedEventData) { |
| if (eventData.eventClass.isAssignableFrom(event.getClass())) |
| return eventData.eventClass; |
| } |
| |
| return null; |
| } |
| |
| /* |
| * This event listener stores received monitor events until BreakpointEvent |
| * is not received, after getting of BreakpointEvent checks only expected |
| * events were received |
| */ |
| public class EventListener extends EventHandler.EventListener { |
| |
| private TestedEventData[] testedEventData; |
| |
| public EventListener(TestedEventData[] testedEventData) { |
| this.testedEventData = testedEventData; |
| } |
| |
| private boolean shouldHandleEvent(Event event) { |
| return findEventDataClass(testedEventData, event) == null ? false : true; |
| } |
| |
| volatile boolean breakpointWasReceived; |
| |
| // execution was interrupted because of timeout |
| volatile boolean executionWasInterrupted; |
| |
| public boolean eventReceived(Event event) { |
| if (shouldHandleEvent(event)) { |
| if (shouldSaveEvent(event)) { |
| |
| Class<?> eventClass; |
| |
| eventClass = findEventDataClass(testedEventData, event); |
| List<Event> events = allReceivedEvents.get(eventClass); |
| |
| if (events == null) { |
| events = new LinkedList<Event>(); |
| allReceivedEvents.put(eventClass, events); |
| } |
| |
| events.add(event); |
| } |
| |
| return true; |
| } |
| // debuggee should stop at the end of test |
| else if (event instanceof BreakpointEvent) { |
| breakpointWasReceived = true; |
| |
| try { |
| // if execution was interrupted because of timeout don't check received |
| // events because it can consume too much time |
| if (!executionWasInterrupted) { |
| // get data from debuggee about all generated events |
| initExpectedEvents(testedEventData); |
| |
| checkEvents(); |
| } else |
| log.complain("WARNING: execution was interrupted because of timeout, test doesn't check received events"); |
| } catch (Throwable t) { |
| unexpectedException(t); |
| } |
| |
| vm.resume(); |
| |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| protected Class<?> extraEventClasses[]; |
| |
| protected Class<?> missedEventClasses[]; |
| |
| /* |
| * If test can't strictly control event generation it may allow generation |
| * of extra events and unexpected events aren't treated as error |
| * (subclasses should specify what kinds of extra events are allowed) |
| */ |
| private Class<?>[] allowedExtraEvents() { |
| return extraEventClasses; |
| } |
| |
| /* |
| * If test can't strictly control event generation case when debugger doesn't |
| * receive expected event may be not treated as failure |
| * (subclasses should specify what kinds of expected events can be not received) |
| */ |
| private Class<?>[] allowedMissedEvents() { |
| return missedEventClasses; |
| } |
| |
| private boolean isExtraEventAllowed(Class<?> eventClass) { |
| return checkEvent(eventClass, allowedExtraEvents()); |
| } |
| |
| private boolean isMissedEventAllowed(Class<?> eventClass) { |
| return checkEvent(eventClass, allowedMissedEvents()); |
| } |
| |
| private boolean checkEvent(Class<?> eventClass, Class<?> classes[]) { |
| if (classes == null) |
| return false; |
| |
| for (Class<?> klass : classes) { |
| if (klass.isAssignableFrom(eventClass)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| // flag is modified from the event listener thread |
| private volatile boolean eventsNotGenerated; |
| |
| /* |
| * Method returns true if test expects event generation, but events weren't |
| * generated. If test can't strictly control event generation such case isn't |
| * necessarily treated as test failure (sublasses of JDIEventsDebugger can |
| * for example try to rerun test several times). |
| */ |
| protected boolean eventsNotGenerated() { |
| return eventsNotGenerated; |
| } |
| |
| /* |
| * Print debug information about expected and received events(this data |
| * should be stored in lists 'allExpectedEvents' and 'allReceivedEvents') |
| * and check that only expected events were received |
| */ |
| private void checkEvents() { |
| if (getAllExpectedEvents().size() > 0 && getAllReceivedEvents().size() == 0 && allowedMissedEvents() != null) { |
| log.display("WARNING: didn't receive any event"); |
| eventsNotGenerated = true; |
| } |
| |
| log.display("ALL RECEIVED EVENTS: "); |
| for (Event event : getAllReceivedEvents()) |
| log.display("received event: " + eventToString(event)); |
| |
| log.display("ALL EXPECTED EVENTS: "); |
| for (DebuggerEventData.DebugEventData eventData : getAllExpectedEvents()) |
| log.display("expected event: " + eventData); |
| |
| // try to find received event in the list of expected events, if this event |
| // was found remove data about events from both lists |
| for (Class<?> eventClass : allReceivedEvents.keySet()) { |
| List<Event> receivedEvents = allReceivedEvents.get(eventClass); |
| List<DebuggerEventData.DebugEventData> expectedEvents = allExpectedEvents.get(eventClass); |
| |
| for (Iterator<Event> allReceivedEventsIterator = receivedEvents.iterator(); |
| allReceivedEventsIterator.hasNext();) { |
| |
| Event event = allReceivedEventsIterator.next(); |
| |
| for (Iterator<DebuggerEventData.DebugEventData> allExpectedEventsIterator = expectedEvents.iterator(); |
| allExpectedEventsIterator.hasNext();) { |
| |
| DebuggerEventData.DebugEventData debugEventData = allExpectedEventsIterator.next(); |
| |
| if (debugEventData.shouldCheckEvent(event)) { |
| if (debugEventData.checkEvent(event)) { |
| allExpectedEventsIterator.remove(); |
| allReceivedEventsIterator.remove(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| List<Event> receivedEventsLeft = getAllReceivedEvents(); |
| |
| // check is all received events were found in expected |
| if (receivedEventsLeft.size() > 0) { |
| // if allowExtraEvents = true extra events are not treated as error |
| for (Event event : receivedEventsLeft) { |
| if (!isExtraEventAllowed(event.getClass())) { |
| setSuccess(false); |
| log.complain("Unexpected event " + eventToString(event)); |
| } |
| } |
| } |
| |
| List<DebuggerEventData.DebugEventData> expectedEventsLeft = getAllExpectedEvents(); |
| |
| // check is all expected events were received |
| if (expectedEventsLeft.size() > 0) { |
| for (DebuggerEventData.DebugEventData eventData : expectedEventsLeft) { |
| if (!isMissedEventAllowed(eventData.eventClass)) { |
| setSuccess(false); |
| log.complain("Expected event was not generated: " + eventData); |
| } |
| } |
| } |
| } |
| |
| private String eventToString(Event event) { |
| try { |
| if (event instanceof MonitorContendedEnterEvent) |
| return event + ". Details(MonitorContendedEnterEvent):" + " Monitor: " + ((MonitorContendedEnterEvent) event).monitor() + " Thread: " |
| + ((MonitorContendedEnterEvent) event).thread(); |
| else if (event instanceof MonitorContendedEnteredEvent) |
| return event + ". Details(MonitorContendedEnteredEvent):" + " Monitor: " + ((MonitorContendedEnteredEvent) event).monitor() |
| + " Thread: " + ((MonitorContendedEnteredEvent) event).thread(); |
| else if (event instanceof MonitorWaitEvent) |
| return event + ". Details(MonitorWaitEvent):" + " Monitor: " + ((MonitorWaitEvent) event).monitor() + " Thread: " |
| + ((MonitorWaitEvent) event).thread() + " Timeout: " + ((MonitorWaitEvent) event).timeout(); |
| else if (event instanceof MonitorWaitedEvent) |
| return event + ". Details(MonitorWaitedEvent):" + " Monitor: " + ((MonitorWaitedEvent) event).monitor() + " Thread: " |
| + ((MonitorWaitedEvent) event).thread() + " Timedout: " + ((MonitorWaitedEvent) event).timedout(); |
| |
| return event.toString(); |
| } |
| // this exception can occur when unexpected event was received |
| catch (ObjectCollectedException e) { |
| // allowExtraEvents=true extra events are not treated as error |
| if (!isExtraEventAllowed(event.getClass())) { |
| setSuccess(false); |
| e.printStackTrace(log.getOutStream()); |
| log.complain("Unexpected ObjectCollectedException was caught, possible unexpected event was received"); |
| } |
| |
| return event.getClass().getName() + " [ Can't get full description, ObjectCollectedException was thrown ]"; |
| } |
| } |
| |
| // events received during test execution are stored here |
| private Map<Class<?>, List<Event>> allReceivedEvents = new HashMap<Class<?>, List<Event>>(); |
| |
| private List<Event> getAllReceivedEvents() { |
| List<Event> result = new LinkedList<Event>(); |
| |
| for (Class<?> eventClass : allReceivedEvents.keySet()) { |
| result.addAll(allReceivedEvents.get(eventClass)); |
| } |
| |
| return result; |
| } |
| |
| protected Map<Class<?>, List<DebuggerEventData.DebugEventData>> allExpectedEvents = new HashMap<Class<?>, List<DebuggerEventData.DebugEventData>>(); |
| |
| private List<DebuggerEventData.DebugEventData> getAllExpectedEvents() { |
| List<DebuggerEventData.DebugEventData> result = new LinkedList<DebuggerEventData.DebugEventData>(); |
| |
| for (Class<?> eventClass : allExpectedEvents.keySet()) { |
| result.addAll(allExpectedEvents.get(eventClass)); |
| } |
| |
| return result; |
| } |
| |
| // find in debuggee VM and add to the list 'allExpectedEvents' instances |
| // of classes representing generated events |
| protected void initExpectedEvents(TestedEventData testedEventData[]) { |
| List<DebuggerEventData.DebugEventData> events; |
| |
| ReferenceType referenceType = debuggee.classByName(debuggeeClassNameWithoutArgs()); |
| |
| ArrayReference generatedEvents = (ArrayReference) referenceType.getValue(referenceType.fieldByName("generatedEvents")); |
| |
| for (TestedEventData eventData : testedEventData) { |
| events = new LinkedList<DebuggerEventData.DebugEventData>(); |
| allExpectedEvents.put(eventData.eventClass, events); |
| } |
| |
| for (int i = 0; i < generatedEvents.length(); i++) { |
| ObjectReference debuggeeMirror = (ObjectReference) generatedEvents.getValue(i); |
| |
| for (TestedEventData eventData : testedEventData) { |
| |
| if (debuggeeMirror.referenceType().name().equals(eventData.eventDataMirrorClass.getName())) { |
| events = allExpectedEvents.get(eventData.eventClass); |
| |
| /* |
| * Use reflection to create object representing generated |
| * event Event data class should has constructor with single |
| * parameter of type com.sun.jdi.ObjectReference |
| */ |
| Constructor<?> constructor; |
| |
| try { |
| constructor = eventData.eventDataClass.getConstructor(new Class[] { ObjectReference.class }); |
| } catch (NoSuchMethodException e) { |
| TestBug testBug = new TestBug( |
| "Class representing debug event data should implement constructor with single parameter of type com.sun.jdi.ObjectReference"); |
| testBug.initCause(e); |
| throw testBug; |
| } |
| |
| DebuggerEventData.DebugEventData expectedEvent; |
| |
| try { |
| expectedEvent = (DebuggerEventData.DebugEventData) constructor.newInstance(new Object[] { debuggeeMirror }); |
| } catch (Exception e) { |
| TestBug testBug = new TestBug("Error when create debug event data: " + e); |
| testBug.initCause(e); |
| throw testBug; |
| } |
| events.add(expectedEvent); |
| } |
| } |
| } |
| } |
| |
| private void printFiltersInfo() { |
| if (eventFilters.size() > 0) { |
| log.display("Use following filters: "); |
| |
| for (EventFilters.DebugEventFilter filter : eventFilters) |
| log.display("" + filter); |
| } else { |
| log.display("Don't use event filters"); |
| } |
| } |
| |
| // filters used in test |
| protected List<EventFilters.DebugEventFilter> eventFilters = new LinkedList<EventFilters.DebugEventFilter>(); |
| |
| // Check is object generating events matches all filters, |
| // if object was accepted by all filters set this object's field |
| // 'saveEventData' to 'true', otherwise to 'false', |
| private void checkEventGenerator(ThreadReference eventThread, ObjectReference executor) { |
| boolean acceptedByFilters = true; |
| |
| for (EventFilters.DebugEventFilter eventFilter : eventFilters) { |
| if (!eventFilter.isObjectMatch(executor, eventThread)) { |
| acceptedByFilters = false; |
| break; |
| } |
| } |
| |
| try { |
| executor.setValue(executor.referenceType().fieldByName("saveEventData"), vm.mirrorOf(acceptedByFilters)); |
| } catch (Exception e) { |
| throw new TestBug("Unexpected exception when change object field in debugee VM: " + e, e); |
| } |
| } |
| |
| /* |
| * Find all event generating threads in debuggee VM (instances of |
| * nsk.share.jdi.MonitorEventsDebuggee$MonitorActionsThread) all these |
| * threads have special field - 'executor', this is object which generates |
| * events. If event generating thread and event generating object was |
| * accepted by all filters generating object should store information about |
| * all generated events and this information will be available for debugger |
| */ |
| protected void initializeEventGenerators() { |
| printFiltersInfo(); |
| |
| List<ThreadReference> eventThreads = getEventThreads(); |
| |
| for (ThreadReference eventThread : eventThreads) { |
| ObjectReference executor = (ObjectReference) eventThread.getValue(eventThread.referenceType().fieldByName("executor")); |
| checkEventGenerator(eventThread, executor); |
| } |
| |
| // debuggee's main thread also can generate events, need to filter it in |
| // the same way as other threads |
| checkEventGenerator(debuggee.threadByName(JDIEventsDebuggee.MAIN_THREAD_NAME), findSingleObjectReference(debuggeeClassNameWithoutArgs())); |
| } |
| |
| // find instances of nsk.share.jdi.MonitorEventsDebuggee$MonitorActionsThread |
| protected List<ThreadReference> getEventThreads() { |
| ReferenceType referenceType = debuggee.classByName(JDIEventsDebuggee.EventActionsThread.class.getName()); |
| List<ObjectReference> debuggeeEventThreads = referenceType.instances(0); |
| |
| List<ThreadReference> result = new LinkedList<ThreadReference>(); |
| for (ObjectReference threadReference : debuggeeEventThreads) |
| result.add((ThreadReference) threadReference); |
| |
| return result; |
| } |
| |
| // find instances of nsk.share.jdi.MonitorEventsDebuggee$MonitorActionsThread, |
| // and get value of this object's field with name 'executor' |
| protected List<ObjectReference> getEventObjects() { |
| List<ObjectReference> eventObjects = new LinkedList<ObjectReference>(); |
| |
| List<ThreadReference> eventThreads = getEventThreads(); |
| |
| for (ThreadReference eventThread : eventThreads) { |
| eventObjects.add((ObjectReference) eventThread.getValue(eventThread.referenceType().fieldByName("executor"))); |
| } |
| |
| return eventObjects; |
| } |
| |
| // remove all filters, received and expected events |
| private void clearTestData() { |
| allExpectedEvents.clear(); |
| allReceivedEvents.clear(); |
| eventFilters.clear(); |
| eventsNotGenerated = false; |
| } |
| |
| private boolean isEventSupported(EventType eventType) { |
| switch (eventType) { |
| case MONITOR_CONTENTED_ENTER: |
| case MONITOR_CONTENTED_ENTERED: |
| case MONITOR_WAIT: |
| case MONITOR_WAITED: |
| return vm.canRequestMonitorEvents(); |
| |
| default: |
| throw new TestBug("Invalid tested event type: " + eventType); |
| } |
| } |
| |
| // create instance of EventRequest depending on given eventType |
| private EventRequest createTestRequest(EventType eventType) { |
| switch (eventType) { |
| case MONITOR_CONTENTED_ENTER: |
| return debuggee.getEventRequestManager().createMonitorContendedEnterRequest(); |
| case MONITOR_CONTENTED_ENTERED: |
| return debuggee.getEventRequestManager().createMonitorContendedEnteredRequest(); |
| case MONITOR_WAIT: |
| return debuggee.getEventRequestManager().createMonitorWaitRequest(); |
| case MONITOR_WAITED: |
| return debuggee.getEventRequestManager().createMonitorWaitedRequest(); |
| |
| default: |
| throw new TestBug("Invalid tested event type: " + eventType); |
| } |
| } |
| |
| // create command depending on given eventType |
| private String createCommand(EventType eventTypes[], int eventsNumber) { |
| String command = JDIEventsDebuggee.COMMAND_CREATE_ACTIONS_EXECUTORS + ":" + eventsNumber + ":"; |
| |
| for (EventType eventType : eventTypes) { |
| switch (eventType) { |
| case MONITOR_CONTENTED_ENTER: |
| case MONITOR_CONTENTED_ENTERED: |
| case MONITOR_WAIT: |
| case MONITOR_WAITED: |
| command += " " + eventType.name(); |
| break; |
| |
| default: |
| throw new TestBug("Invalid tested event type: " + eventType); |
| } |
| } |
| |
| return command; |
| } |
| |
| // get list of event requests from EventRequestManager depending on the given eventType |
| private List<?> getEventRequestsFromManager(EventType eventType) { |
| switch (eventType) { |
| case MONITOR_CONTENTED_ENTER: |
| return debuggee.getEventRequestManager().monitorContendedEnterRequests(); |
| case MONITOR_CONTENTED_ENTERED: |
| return debuggee.getEventRequestManager().monitorContendedEnteredRequests(); |
| case MONITOR_WAIT: |
| return debuggee.getEventRequestManager().monitorWaitRequests(); |
| case MONITOR_WAITED: |
| return debuggee.getEventRequestManager().monitorWaitedRequests(); |
| |
| default: |
| throw new TestBug("Invalid tested event type: " + eventType); |
| } |
| } |
| |
| protected EventHandler eventHandler; |
| |
| private EventListener eventListener; |
| |
| // perform event generation before test begins to load all using classes |
| // and avoid unexpected events related to classloading |
| protected void prepareDebuggee(EventType[] eventTypes) { |
| initDefaultBreakpoint(); |
| |
| eventHandler = new EventHandler(debuggee, log); |
| eventHandler.startListening(); |
| |
| // use event listener which just skip all received events |
| DummyEventListener dummyEventListener = new DummyEventListener(); |
| eventHandler.addListener(dummyEventListener); |
| |
| EventRequest eventRequests[] = new EventRequest[eventTypes.length]; |
| |
| for (int i = 0; i < eventRequests.length; i++) { |
| eventRequests[i] = createTestRequest(eventTypes[i]); |
| eventRequests[i].setSuspendPolicy(EventRequest.SUSPEND_NONE); |
| eventRequests[i].enable(); |
| } |
| |
| // debuggee should create event generators |
| pipe.println(createCommand(eventTypes, 1)); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| // start event generation |
| pipe.println(JDIEventsDebuggee.COMMAND_START_EXECUTION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| for (int i = 0; i < eventRequests.length; i++) |
| eventRequests[i].disable(); |
| |
| dummyEventListener.waitBreakpoint(); |
| |
| eventHandler.removeListener(dummyEventListener); |
| |
| pipe.println(JDIEventsDebuggee.COMMAND_WAIT_EXECUTION_COMPLETION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| eventListener = new EventListener(eventDataByEventTypes(eventTypes)); |
| eventHandler.addListener(eventListener); |
| } |
| |
| /* |
| * Method for stress testing, allows specify requests for several event |
| * types, number of events which should be generated during test and number |
| * of threads which simultaneously generate events |
| */ |
| protected void stressTestTemplate(EventType[] eventTypes, int eventsNumber, int threadsNumber) { |
| for (EventType eventType : eventTypes) { |
| if (!isEventSupported(eventType)) { |
| log.complain("Can't test event because of it isn't supported: " + eventType); |
| return; |
| } |
| } |
| |
| // Used framework is intended for testing event filters and debuggee |
| // creates 3 threads performing event generation and there is possibility |
| // to filter events from some threads |
| for (int i = 0; i < threadsNumber; i++) { |
| pipe.println(createCommand(eventTypes, eventsNumber)); |
| |
| if (!isDebuggeeReady()) |
| return; |
| } |
| |
| // clear data(if this method is executed several times) |
| clearTestData(); |
| |
| initializeEventGenerators(); |
| |
| EventRequest eventRequests[] = new EventRequest[eventTypes.length]; |
| |
| // create event requests |
| for (int i = 0; i < eventTypes.length; i++) { |
| eventRequests[i] = createTestRequest(eventTypes[i]); |
| eventRequests[i].setSuspendPolicy(EventRequest.SUSPEND_NONE); |
| eventRequests[i].enable(); |
| |
| log.display("Use following event request: " + eventRequests[i]); |
| } |
| |
| // stressTestTemplate can control only execution time, so ignore iteration count |
| stresser.start(0); |
| try { |
| // start event generation |
| pipe.println(JDIEventsDebuggee.COMMAND_START_EXECUTION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| // check is stressTime exceeded |
| while (stresser.continueExecution()) { |
| try { |
| Thread.sleep(100); |
| } catch (InterruptedException e) { |
| unexpectedException(e); |
| } |
| |
| // periodically check is test completed |
| if (eventListener.breakpointWasReceived) |
| break; |
| } |
| } finally { |
| stresser.finish(); |
| } |
| |
| // debugger should interrupt test because of timeout |
| if (!eventListener.breakpointWasReceived) { |
| |
| eventListener.executionWasInterrupted = true; |
| |
| log.complain("WARNING: time is exceeded, interrupt test"); |
| |
| pipe.println(JDIEventsDebuggee.COMMAND_STOP_EXECUTION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| } |
| |
| pipe.println(JDIEventsDebuggee.COMMAND_WAIT_EXECUTION_COMPLETION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| for (int i = 0; i < eventRequests.length; i++) |
| eventRequests[i].disable(); |
| } |
| |
| /* |
| * Hook method for subclasses implementing tests against event filters (it is called from eventFilterTestTemplate) |
| */ |
| protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) { |
| throw new TestBug("Not implemented"); |
| } |
| |
| /* |
| * Test event request with filter |
| * |
| * Also this method check following: |
| * - InvalidRequestStateException is thrown if add filter for deleted or enabled request |
| * - EventRequestManager.xxxRequests() returns created event request |
| */ |
| protected void eventFilterTestTemplate(EventType eventType, int testedFilterIndex) { |
| if (!isEventSupported(eventType)) { |
| log.complain("Can't test event because of it isn't supported: " + eventType); |
| return; |
| } |
| |
| // debuggee create event generators |
| pipe.println(createCommand(new EventType[] { eventType }, 1)); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| clearTestData(); |
| |
| EventFilters.DebugEventFilter[] filters = createTestFilters(testedFilterIndex); |
| |
| for (EventFilters.DebugEventFilter filter : filters) { |
| if (filter.isSupported(vm)) |
| eventFilters.add(filter); |
| else { |
| log.complain("Can't test filter because of it isn't supported: " + filter); |
| return; |
| } |
| } |
| |
| initializeEventGenerators(); |
| |
| // create event request |
| EventRequest request = createTestRequest(eventType); |
| request.setSuspendPolicy(EventRequest.SUSPEND_NONE); |
| |
| // try add filter to enabled request, expect |
| // 'InvalidRequestStateException' |
| request.enable(); |
| try { |
| for (EventFilters.DebugEventFilter filter : filters) |
| filter.addFilter(request); |
| |
| setSuccess(false); |
| log.complain("Expected 'InvalidRequestStateException' was not thrown"); |
| } catch (InvalidRequestStateException e) { |
| // expected exception |
| } catch (Throwable e) { |
| setSuccess(false); |
| log.complain("Unexpected exception: " + e); |
| e.printStackTrace(log.getOutStream()); |
| } |
| |
| // add event filter |
| request.disable(); |
| |
| for (EventFilters.DebugEventFilter filter : filters) |
| addFilter(filter, request); |
| |
| request.enable(); |
| |
| log.display("Use following event request: " + request); |
| |
| // start event generation |
| pipe.println(JDIEventsDebuggee.COMMAND_START_EXECUTION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| // wait execution completion |
| pipe.println(JDIEventsDebuggee.COMMAND_WAIT_EXECUTION_COMPLETION); |
| |
| if (!isDebuggeeReady()) |
| return; |
| |
| // check that method EventRequestManager.xxxRequests() return created |
| // request |
| if (!getEventRequestsFromManager(eventType).contains(request)) { |
| setSuccess(false); |
| log.complain("EventRequestManager doesn't return request: " + request); |
| } |
| |
| // delete event request |
| debuggee.getEventRequestManager().deleteEventRequest(request); |
| |
| // try add filter to removed request, expect |
| // 'InvalidRequestStateException' |
| try { |
| for (EventFilters.DebugEventFilter filter : filters) |
| filter.addFilter(request); |
| setSuccess(false); |
| log.complain("Expected 'InvalidRequestStateException' was not thrown"); |
| } catch (InvalidRequestStateException e) { |
| // expected exception |
| } catch (Throwable t) { |
| unexpectedException(t); |
| } |
| } |
| |
| private void addFilter(EventFilters.DebugEventFilter filter, EventRequest request) { |
| try { |
| filter.addFilter(request); |
| } catch (Throwable t) { |
| unexpectedException(t); |
| } |
| } |
| |
| // used to parse parameters -allowExtraEvents and -allowMissedEvents |
| private Class<?>[] createEventClassArray(String string) { |
| String eventTypesNames[] = string.split(":"); |
| EventType eventTypes[] = new EventType[eventTypesNames.length]; |
| try { |
| for (int i = 0; i < eventTypesNames.length; i++) { |
| eventTypes[i] = EventType.valueOf(eventTypesNames[i]); |
| } |
| } catch (IllegalArgumentException e) { |
| throw new TestBug("Invalid event type", e); |
| } |
| |
| if (eventTypesNames.length == 0) |
| throw new TestBug("Event types weren't specified"); |
| |
| Class<?>[] result = new Class[eventTypesNames.length]; |
| |
| for (int i = 0; i < result.length; i++) |
| result[i] = testedEventData.get(eventTypes[i]).eventClass; |
| |
| return result; |
| } |
| |
| } |
