/*

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

    }

}