test/hotspot/jtreg/vmTestbase/nsk/share/jdi/EventTestTemplates.java - platform/libcore - Git at Google

 /*
  * 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.*;
 import java.util.*;

 import com.sun.jdi.*;
 import com.sun.jdi.event.*;
 import nsk.share.Consts;
 import nsk.share.TestBug;

 /*
  * Class contains debugger classes based on JDIEventsDebugger intended for JDI events testing
  */
 public class EventTestTemplates {

     // how many times rerun test in case when tested events aren't generated
     static final int MAX_TEST_RUN_NUMBER = 10;

     /*
      * Method contains common code used by EventFilterTests and StressTestTemplate
      */
     static void runTestWithRerunPossibilty(JDIEventsDebugger debugger, Runnable testRunner) {
         for (int i = 0; i < MAX_TEST_RUN_NUMBER; i++) {
             testRunner.run();

             /*
              * If events weren't generated at all but test accepts missing events
              * try to rerun test (rerun test only if it didn't fail yet)
              */
             if (debugger.eventsNotGenerated() && debugger.getSuccess()) {
                 if (i < MAX_TEST_RUN_NUMBER - 1) {
                     debugger.log.display("\nWARNING: tested events weren't generated at all, trying to rerun test (rerun attempt " + (i + 1) + ")\n");
                     continue;
                 } else {
                     debugger.setSuccess(false);
                     debugger.log.complain("Tested events weren't generated after " + MAX_TEST_RUN_NUMBER + " runs, test FAILED");
                 }
             } else
                 break;
         }
     }

     /*
      * Debugger class for testing event filters, subclasses should parse command
      * line and call method JDIEventsDebugger.eventFilterTestTemplate with
      * required arguments.
      *
      * Class handles common for event filter tests parameters:
      * - debuggee class name (e.g. -debuggeeClassName nsk.share.jdi.MonitorEventsDebuggee)
      * - tested event type (e.g. -eventType MONITOR_CONTENTED_ENTER)
      */
     public static abstract class EventFilterTest extends JDIEventsDebugger {
         protected String debuggeeClassName;

         protected EventType eventType;

         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("-debuggeeClassName") && (i < args.length - 1)) {
                     debuggeeClassName = args[i + 1];
                     i++;
                 } else if (args[i].equals("-eventType") && (i < args.length - 1)) {
                     try {
                         eventType = EventType.valueOf(args[i + 1]);
                     } catch (IllegalArgumentException e) {
                         TestBug testBug = new TestBug("Invalid event type : " + args[i + 1], e);
                         throw testBug;
                     }
                     i++;
                 } else
                     standardArgs.add(args[i]);
             }

             if (eventType == null)
                 throw new TestBug("Test requires 'eventType' parameter");

             if (debuggeeClassName == null)
                 throw new TestBug("Test requires 'debuggeeClassName' parameter");

             return standardArgs.toArray(new String[] {});
         }

         abstract protected int getTestFiltersNumber();

         // This class is required to call runTestWithRerunPossibilty()
         class FilterTestRunner implements Runnable {
             private int filterIndex;

             FilterTestRunner(int filterIndex) {
                 this.filterIndex = filterIndex;
             }

             public void run() {
                 eventFilterTestTemplate(eventType, filterIndex);
             }
         }

         public final void doTest() {
             prepareDebuggee(new EventType[] {eventType});

             int filtersNumber = getTestFiltersNumber();

             if (filtersNumber <= 0)
                 throw new TestBug("Invalid filtersNumber: " + filtersNumber);

             for (int filterIndex = 0; filterIndex < getTestFiltersNumber(); filterIndex++) {
                 runTestWithRerunPossibilty(this, new FilterTestRunner(filterIndex));
             }

             eventHandler.stopEventHandler();
             removeDefaultBreakpoint();
         }

         // can't control events from system libraries, so save events only from nsk packages
         protected boolean shouldSaveEvent(Event event) {
             return isEventFromNSK(event);
         }

         protected String debuggeeClassName() {
             return debuggeeClassName;
         }
     }

     /*
      * Class for testing class exclusion filter, this filter is added by
      * request's method addClassExclusionFilter(String classPattern) Expected
      * command line parameter:
      * - class patterns which should be passed to adding filter method (e.g. -classPatterns java.*:*.Foo)
      */
     public static class ClassExclusionFilterTest extends EventFilterTest {
         protected String classPatterns[];

         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new ClassExclusionFilterTest().runIt(argv, out);
         }

         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("-classPatterns") && (i < args.length - 1)) {
                     classPatterns = args[i + 1].split(":");
                     i++;
                 } else
                     standardArgs.add(args[i]);
             }

             if (classPatterns == null || classPatterns.length == 0)
                 throw new TestBug("Test requires at least one class name pattern");

             return standardArgs.toArray(new String[] {});
         }

         protected int getTestFiltersNumber() {
             return classPatterns.length;
         }

         protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
             if (testedFilterIndex < 0 || testedFilterIndex >= classPatterns.length)
                 throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

             return new EventFilters.DebugEventFilter[]{new EventFilters.ClassExclusionFilter(classPatterns[testedFilterIndex])};
         }
     }

     /*
      * Subclass of ClassExclusionFilterTest, create ClassFilter instead of
      * ClassExclusionFilter, this filter is added by request's method
      * addClassFilter(String classPattern)
      */
     public static class ClassFilterTest_ClassName extends ClassExclusionFilterTest {
         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new ClassFilterTest_ClassName().runIt(argv, out);
         }

         protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
             if (testedFilterIndex < 0 || testedFilterIndex >= classPatterns.length)
                 throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

             return new EventFilters.DebugEventFilter[]{new EventFilters.ClassFilter(classPatterns[testedFilterIndex])};
         }
     }

     /*
      * Subclass of ClassExclusionFilterTest, create ClassReferenceFilter instead
      * of ClassExclusionFilter, this filter is added by request's method
      * addClassFilter(ReferenceType referenceType)
      */
     public static class ClassFilterTest_ReferenceType extends ClassExclusionFilterTest {
         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new ClassFilterTest_ReferenceType().runIt(argv, out);
         }

         protected int getTestFiltersNumber() {
             return classPatterns.length;
         }

         protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
             if (testedFilterIndex < 0 || testedFilterIndex >= classPatterns.length)
                 throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

             ReferenceType referenceType = debuggee.classByName(classPatterns[testedFilterIndex]);
             if (referenceType == null)
                 throw new TestBug("Invalid class name is passed: " + classPatterns[testedFilterIndex]);

             return new EventFilters.DebugEventFilter[]{new EventFilters.ClassReferenceFilter(referenceType)};
         }
     }

     /*
      * Class for testing instance filter, this filter is added by request's
      * method addInstanceFilter(ObjectReference instance). Class tests 3 following
      * cases:
      * - add filter for single object
      * - add filter for the same object 2 times, expect behavior such as in previous case
      * - add filter for 2 different objects, so events shouldn't be received
      */
     public static class InstanceFilterTest extends EventFilterTest {
         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new InstanceFilterTest().runIt(argv, out);
         }

         protected int getTestFiltersNumber() {
             return 3;
         }

         protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
             List<ObjectReference> objects = getEventObjects();

             if (objects.size() < 2) {
                 throw new TestBug("Debuggee didn't create event generating objects");
             }

             switch (testedFilterIndex) {
             case 0:
                 // filter for 1 object
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0))};
             case 1:
                 // add 2 filters for the same object
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0)),
                         new EventFilters.ObjectReferenceFilter(objects.get(0))};
             case 2:
                 // add 2 filters for 2 different objects, so don't expect any event
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0)),
                         new EventFilters.ObjectReferenceFilter(objects.get(1))};
             default:
                 throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);
             }
         }
     }

     /*
      * Class for testing thread filter, this filter is added by request's method
      * addThreadFilter(ThreadReference thread). Class test 3 follows cases:
      * - add filter for single thread
      * - add filter for the same thread 2 times, expect behavior such as in previous case
      * - add filter for 2 different threads, so events shouldn't be received
      */
     public static class ThreadFilterTest extends EventFilterTest {
         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new ThreadFilterTest().runIt(argv, out);
         }

         protected int getTestFiltersNumber() {
             return 3;
         }

         protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
             List<ThreadReference> threads = getEventThreads();

             if (threads.size() < 2) {
                 throw new TestBug("Debuggee didn't create event generating threads");
             }

             switch (testedFilterIndex) {
             case 0:
                 // filter for 1 thread
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0))};
             case 1:
                 // add 2 filters for the same thread
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0)),
                         new EventFilters.ThreadFilter(threads.get(0))};
             case 2:
                 // add 2 filters for 2 different threads, so don't expect any event
                 return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0)),
                         new EventFilters.ThreadFilter(threads.get(1))};
             default:
                 throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);
             }
         }
     }

     /*
      * Class is intended for stress testing, expected command line parameters:
      * - debuggee class name (e.g.: -debuggeeClassName nsk.share.jdi.MonitorEventsDebuggee)
      * - one or more tested event types (e.g.: -eventTypes MONITOR_CONTENTED_ENTER:MONITOR_CONTENTED_ENTERED)
      * - number of events which should be generated during test execution (e.g.: -eventsNumber 500)
      * - number of threads which simultaneously generate events (e.g.: -threadsNumber 10)
      *
      * Class parses command line and calls method JDIEventsDebugger.stressTestTemplate.
      */
     public static class StressTestTemplate extends JDIEventsDebugger {
         protected String debuggeeClassName;

         protected EventType testedEventTypes[];

         protected int eventsNumber = 1;

         protected int threadsNumber = 1;

         public static void main(String argv[]) {
             System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
         }

         public static int run(String argv[], PrintStream out) {
             return new StressTestTemplate().runIt(argv, out);
         }

         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("-eventsNumber") && (i < args.length - 1)) {
                     eventsNumber = Integer.parseInt(args[i + 1]);

                     // for this stress test events number is equivalent of iterations
                     // (don't support 0 value of IterationsFactor)
                     if (stressOptions.getIterationsFactor() != 0)
                         eventsNumber *= stressOptions.getIterationsFactor();

                     i++;
                 } else if (args[i].equals("-threadsNumber") && (i < args.length - 1)) {
                     threadsNumber = Integer.parseInt(args[i + 1]);

                     // if 'threadsNumber' is specified test should take in account stress options
                     threadsNumber *= stressOptions.getThreadsFactor();

                     i++;
                 } else if (args[i].equals("-debuggeeClassName") && (i < args.length - 1)) {
                     debuggeeClassName = args[i + 1];
                     i++;
                 } else if (args[i].equals("-eventTypes") && (i < args.length - 1)) {
                     String eventTypesNames[] = args[i + 1].split(":");
                     testedEventTypes = new EventType[eventTypesNames.length];
                     try {
                         for (int j = 0; j < eventTypesNames.length; j++)
                             testedEventTypes[j] = EventType.valueOf(eventTypesNames[j]);
                     } catch (IllegalArgumentException e) {
                         throw new TestBug("Invalid event type", e);
                     }

                     i++;
                 } else
                     standardArgs.add(args[i]);
             }

             if (testedEventTypes == null || testedEventTypes.length == 0)
                 throw new TestBug("Test requires 'eventTypes' parameter");

             if (debuggeeClassName == null)
                 throw new TestBug("Test requires 'debuggeeClassName' parameter");

             return standardArgs.toArray(new String[] {});
         }

         // can't control events from system libraries, so save events only from nsk packages
         protected boolean shouldSaveEvent(Event event) {
             return isEventFromNSK(event);
         }

         protected String debuggeeClassName() {
             return debuggeeClassName;
         }

         public void doTest() {
             prepareDebuggee(testedEventTypes);

             runTestWithRerunPossibilty(this, new Runnable() {
                 public void run() {
                     stressTestTemplate(testedEventTypes, eventsNumber, threadsNumber);
                 }
             });

             eventHandler.stopEventHandler();
             removeDefaultBreakpoint();
         }
     }

     static public boolean isEventFromNSK(Event event) {
         if (event instanceof MonitorContendedEnterEvent) {
             return ((MonitorContendedEnterEvent) event).location() != null && ((MonitorContendedEnterEvent) event).monitor().type().name().startsWith("nsk.");
         }
         if (event instanceof MonitorContendedEnteredEvent) {
             return ((MonitorContendedEnteredEvent) event).location() != null  && ((MonitorContendedEnteredEvent) event).monitor().type().name().startsWith("nsk.");
         }
         if (event instanceof MonitorWaitEvent) {
             return ((MonitorWaitEvent) event).monitor().type().name().startsWith("nsk.");
         }
         if (event instanceof MonitorWaitedEvent) {
             return ((MonitorWaitedEvent) event).monitor().type().name().startsWith("nsk.");
         }

         // don't filter other events
         return true;
     }

 }
	/*
	* 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.*;
	import java.util.*;

	import com.sun.jdi.*;
	import com.sun.jdi.event.*;
	import nsk.share.Consts;
	import nsk.share.TestBug;

	/*
	* Class contains debugger classes based on JDIEventsDebugger intended for JDI events testing
	*/
	public class EventTestTemplates {

	// how many times rerun test in case when tested events aren't generated
	static final int MAX_TEST_RUN_NUMBER = 10;

	/*
	* Method contains common code used by EventFilterTests and StressTestTemplate
	*/
	static void runTestWithRerunPossibilty(JDIEventsDebugger debugger, Runnable testRunner) {
	for (int i = 0; i < MAX_TEST_RUN_NUMBER; i++) {
	testRunner.run();

	/*
	* If events weren't generated at all but test accepts missing events
	* try to rerun test (rerun test only if it didn't fail yet)
	*/
	if (debugger.eventsNotGenerated() && debugger.getSuccess()) {
	if (i < MAX_TEST_RUN_NUMBER - 1) {
	debugger.log.display("\nWARNING: tested events weren't generated at all, trying to rerun test (rerun attempt " + (i + 1) + ")\n");
	continue;
	} else {
	debugger.setSuccess(false);
	debugger.log.complain("Tested events weren't generated after " + MAX_TEST_RUN_NUMBER + " runs, test FAILED");
	}
	} else
	break;
	}
	}

	/*
	* Debugger class for testing event filters, subclasses should parse command
	* line and call method JDIEventsDebugger.eventFilterTestTemplate with
	* required arguments.
	*
	* Class handles common for event filter tests parameters:
	* - debuggee class name (e.g. -debuggeeClassName nsk.share.jdi.MonitorEventsDebuggee)
	* - tested event type (e.g. -eventType MONITOR_CONTENTED_ENTER)
	*/
	public static abstract class EventFilterTest extends JDIEventsDebugger {
	protected String debuggeeClassName;

	protected EventType eventType;

	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("-debuggeeClassName") && (i < args.length - 1)) {
	debuggeeClassName = args[i + 1];
	i++;
	} else if (args[i].equals("-eventType") && (i < args.length - 1)) {
	try {
	eventType = EventType.valueOf(args[i + 1]);
	} catch (IllegalArgumentException e) {
	TestBug testBug = new TestBug("Invalid event type : " + args[i + 1], e);
	throw testBug;
	}
	i++;
	} else
	standardArgs.add(args[i]);
	}

	if (eventType == null)
	throw new TestBug("Test requires 'eventType' parameter");

	if (debuggeeClassName == null)
	throw new TestBug("Test requires 'debuggeeClassName' parameter");

	return standardArgs.toArray(new String[] {});
	}

	abstract protected int getTestFiltersNumber();

	// This class is required to call runTestWithRerunPossibilty()
	class FilterTestRunner implements Runnable {
	private int filterIndex;

	FilterTestRunner(int filterIndex) {
	this.filterIndex = filterIndex;
	}

	public void run() {
	eventFilterTestTemplate(eventType, filterIndex);
	}
	}

	public final void doTest() {
	prepareDebuggee(new EventType[] {eventType});

	int filtersNumber = getTestFiltersNumber();

	if (filtersNumber <= 0)
	throw new TestBug("Invalid filtersNumber: " + filtersNumber);

	for (int filterIndex = 0; filterIndex < getTestFiltersNumber(); filterIndex++) {
	runTestWithRerunPossibilty(this, new FilterTestRunner(filterIndex));
	}

	eventHandler.stopEventHandler();
	removeDefaultBreakpoint();
	}

	// can't control events from system libraries, so save events only from nsk packages
	protected boolean shouldSaveEvent(Event event) {
	return isEventFromNSK(event);
	}

	protected String debuggeeClassName() {
	return debuggeeClassName;
	}
	}

	/*
	* Class for testing class exclusion filter, this filter is added by
	* request's method addClassExclusionFilter(String classPattern) Expected
	* command line parameter:
	* - class patterns which should be passed to adding filter method (e.g. -classPatterns java.:.Foo)
	*/
	public static class ClassExclusionFilterTest extends EventFilterTest {
	protected String classPatterns[];

	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new ClassExclusionFilterTest().runIt(argv, out);
	}

	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("-classPatterns") && (i < args.length - 1)) {
	classPatterns = args[i + 1].split(":");
	i++;
	} else
	standardArgs.add(args[i]);
	}

	if (classPatterns == null \|\| classPatterns.length == 0)
	throw new TestBug("Test requires at least one class name pattern");

	return standardArgs.toArray(new String[] {});
	}

	protected int getTestFiltersNumber() {
	return classPatterns.length;
	}

	protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
	if (testedFilterIndex < 0 \|\| testedFilterIndex >= classPatterns.length)
	throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

	return new EventFilters.DebugEventFilter[]{new EventFilters.ClassExclusionFilter(classPatterns[testedFilterIndex])};
	}
	}

	/*
	* Subclass of ClassExclusionFilterTest, create ClassFilter instead of
	* ClassExclusionFilter, this filter is added by request's method
	* addClassFilter(String classPattern)
	*/
	public static class ClassFilterTest_ClassName extends ClassExclusionFilterTest {
	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new ClassFilterTest_ClassName().runIt(argv, out);
	}

	protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
	if (testedFilterIndex < 0 \|\| testedFilterIndex >= classPatterns.length)
	throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

	return new EventFilters.DebugEventFilter[]{new EventFilters.ClassFilter(classPatterns[testedFilterIndex])};
	}
	}

	/*
	* Subclass of ClassExclusionFilterTest, create ClassReferenceFilter instead
	* of ClassExclusionFilter, this filter is added by request's method
	* addClassFilter(ReferenceType referenceType)
	*/
	public static class ClassFilterTest_ReferenceType extends ClassExclusionFilterTest {
	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new ClassFilterTest_ReferenceType().runIt(argv, out);
	}

	protected int getTestFiltersNumber() {
	return classPatterns.length;
	}

	protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
	if (testedFilterIndex < 0 \|\| testedFilterIndex >= classPatterns.length)
	throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);

	ReferenceType referenceType = debuggee.classByName(classPatterns[testedFilterIndex]);
	if (referenceType == null)
	throw new TestBug("Invalid class name is passed: " + classPatterns[testedFilterIndex]);

	return new EventFilters.DebugEventFilter[]{new EventFilters.ClassReferenceFilter(referenceType)};
	}
	}

	/*
	* Class for testing instance filter, this filter is added by request's
	* method addInstanceFilter(ObjectReference instance). Class tests 3 following
	* cases:
	* - add filter for single object
	* - add filter for the same object 2 times, expect behavior such as in previous case
	* - add filter for 2 different objects, so events shouldn't be received
	*/
	public static class InstanceFilterTest extends EventFilterTest {
	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new InstanceFilterTest().runIt(argv, out);
	}

	protected int getTestFiltersNumber() {
	return 3;
	}

	protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
	List<ObjectReference> objects = getEventObjects();

	if (objects.size() < 2) {
	throw new TestBug("Debuggee didn't create event generating objects");
	}

	switch (testedFilterIndex) {
	case 0:
	// filter for 1 object
	return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0))};
	case 1:
	// add 2 filters for the same object
	return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0)),
	new EventFilters.ObjectReferenceFilter(objects.get(0))};
	case 2:
	// add 2 filters for 2 different objects, so don't expect any event
	return new EventFilters.DebugEventFilter[]{new EventFilters.ObjectReferenceFilter(objects.get(0)),
	new EventFilters.ObjectReferenceFilter(objects.get(1))};
	default:
	throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);
	}
	}
	}

	/*
	* Class for testing thread filter, this filter is added by request's method
	* addThreadFilter(ThreadReference thread). Class test 3 follows cases:
	* - add filter for single thread
	* - add filter for the same thread 2 times, expect behavior such as in previous case
	* - add filter for 2 different threads, so events shouldn't be received
	*/
	public static class ThreadFilterTest extends EventFilterTest {
	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new ThreadFilterTest().runIt(argv, out);
	}

	protected int getTestFiltersNumber() {
	return 3;
	}

	protected EventFilters.DebugEventFilter[] createTestFilters(int testedFilterIndex) {
	List<ThreadReference> threads = getEventThreads();

	if (threads.size() < 2) {
	throw new TestBug("Debuggee didn't create event generating threads");
	}

	switch (testedFilterIndex) {
	case 0:
	// filter for 1 thread
	return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0))};
	case 1:
	// add 2 filters for the same thread
	return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0)),
	new EventFilters.ThreadFilter(threads.get(0))};
	case 2:
	// add 2 filters for 2 different threads, so don't expect any event
	return new EventFilters.DebugEventFilter[]{new EventFilters.ThreadFilter(threads.get(0)),
	new EventFilters.ThreadFilter(threads.get(1))};
	default:
	throw new TestBug("Invalid testedFilterIndex: " + testedFilterIndex);
	}
	}
	}

	/*
	* Class is intended for stress testing, expected command line parameters:
	* - debuggee class name (e.g.: -debuggeeClassName nsk.share.jdi.MonitorEventsDebuggee)
	* - one or more tested event types (e.g.: -eventTypes MONITOR_CONTENTED_ENTER:MONITOR_CONTENTED_ENTERED)
	* - number of events which should be generated during test execution (e.g.: -eventsNumber 500)
	* - number of threads which simultaneously generate events (e.g.: -threadsNumber 10)
	*
	* Class parses command line and calls method JDIEventsDebugger.stressTestTemplate.
	*/
	public static class StressTestTemplate extends JDIEventsDebugger {
	protected String debuggeeClassName;

	protected EventType testedEventTypes[];

	protected int eventsNumber = 1;

	protected int threadsNumber = 1;

	public static void main(String argv[]) {
	System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String argv[], PrintStream out) {
	return new StressTestTemplate().runIt(argv, out);
	}

	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("-eventsNumber") && (i < args.length - 1)) {
	eventsNumber = Integer.parseInt(args[i + 1]);

	// for this stress test events number is equivalent of iterations
	// (don't support 0 value of IterationsFactor)
	if (stressOptions.getIterationsFactor() != 0)
	eventsNumber *= stressOptions.getIterationsFactor();

	i++;
	} else if (args[i].equals("-threadsNumber") && (i < args.length - 1)) {
	threadsNumber = Integer.parseInt(args[i + 1]);

	// if 'threadsNumber' is specified test should take in account stress options
	threadsNumber *= stressOptions.getThreadsFactor();

	i++;
	} else if (args[i].equals("-debuggeeClassName") && (i < args.length - 1)) {
	debuggeeClassName = args[i + 1];
	i++;
	} else if (args[i].equals("-eventTypes") && (i < args.length - 1)) {
	String eventTypesNames[] = args[i + 1].split(":");
	testedEventTypes = new EventType[eventTypesNames.length];
	try {
	for (int j = 0; j < eventTypesNames.length; j++)
	testedEventTypes[j] = EventType.valueOf(eventTypesNames[j]);
	} catch (IllegalArgumentException e) {
	throw new TestBug("Invalid event type", e);
	}

	i++;
	} else
	standardArgs.add(args[i]);
	}

	if (testedEventTypes == null \|\| testedEventTypes.length == 0)
	throw new TestBug("Test requires 'eventTypes' parameter");

	if (debuggeeClassName == null)
	throw new TestBug("Test requires 'debuggeeClassName' parameter");

	return standardArgs.toArray(new String[] {});
	}

	// can't control events from system libraries, so save events only from nsk packages
	protected boolean shouldSaveEvent(Event event) {
	return isEventFromNSK(event);
	}

	protected String debuggeeClassName() {
	return debuggeeClassName;
	}

	public void doTest() {
	prepareDebuggee(testedEventTypes);

	runTestWithRerunPossibilty(this, new Runnable() {
	public void run() {
	stressTestTemplate(testedEventTypes, eventsNumber, threadsNumber);
	}
	});

	eventHandler.stopEventHandler();
	removeDefaultBreakpoint();
	}
	}

	static public boolean isEventFromNSK(Event event) {
	if (event instanceof MonitorContendedEnterEvent) {
	return ((MonitorContendedEnterEvent) event).location() != null && ((MonitorContendedEnterEvent) event).monitor().type().name().startsWith("nsk.");
	}
	if (event instanceof MonitorContendedEnteredEvent) {
	return ((MonitorContendedEnteredEvent) event).location() != null && ((MonitorContendedEnteredEvent) event).monitor().type().name().startsWith("nsk.");
	}
	if (event instanceof MonitorWaitEvent) {
	return ((MonitorWaitEvent) event).monitor().type().name().startsWith("nsk.");
	}
	if (event instanceof MonitorWaitedEvent) {
	return ((MonitorWaitedEvent) event).monitor().type().name().startsWith("nsk.");
	}

	// don't filter other events
	return true;
	}

	}