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

}