</tr>
            <tr>
                <td>afterSuite</td>
            </tr>
            <tr>
                <td>beforeTest</td>
            </tr>
            <tr>
                <td>afterTest</td>
            </tr>
            <tr>
                <td>onOutput</td>
            </tr>
            <tr>
                <td>reports</td>
            </tr>
            <tr>

        if (test.isComposite()) {
            testListener.afterSuite(test, result);
        } else {
            testListener.afterTest(test, result);
        }
    }

    @Override
    public void output(TestDescriptorInternal test, TestOutputEvent event) {
        testOutputListener.onOutput(test, event);
    }

                void beforeSuite(TestDescriptor suite) {}
                void afterSuite(TestDescriptor suite, TestResult result) {}
                void beforeTest(TestDescriptor testDescriptor) {}
                void afterTest(TestDescriptor testDescriptor, TestResult result) {}
            }
            def testOutputListener = new TestOutputListener() {
                void onOutput(TestDescriptor testDescriptor, TestOutputEvent outputEvent) {}

        .add("Lorg/testng/annotations/BeforeSuite;")
        .add("Lorg/testng/annotations/AfterSuite;")
        .add("Lorg/testng/annotations/BeforeTest;")
        .add("Lorg/testng/annotations/AfterTest;")
        .add("Lorg/testng/annotations/BeforeGroups;")
        .add("Lorg/testng/annotations/AfterGroups;")
        .add("Lorg/testng/annotations/Factory;")
        .build();

        }

        @Override
        String getBeforeTestAnnotation() {
            return "@BeforeTest"
        }

        @Override
        String getAfterTestAnnotation() {
            return "@AfterTest"
        }

        @Override
        String getIgnoreOrDisabledAnnotation() {
            return "@Ignore"
        }

        @Override

        cleanUpDaemons()
    }

    fun newDaemonListener() =
        object : TestListener {
            override fun beforeTest(test: TestDescriptor) = Unit
            override fun afterTest(test: TestDescriptor, result: TestResult) = Unit
            override fun beforeSuite(suite: TestDescriptor) {
                if (suite.parent == null) {
                    forEachJavaProcess { pid, _ ->

    /**
     * Called after an atomic test is finished.
     * @param testDescriptor The test which has finished executing.
     * @param result The test result.
     */
    void afterTest(TestDescriptor testDescriptor, TestResult result);

        task.addTestListener(listener)

        when:
        task.executeTests()

        then:
        1 * listener.beforeSuite(_)
        1 * listener.beforeTest(_)
        1 * listener.afterTest(_, _)
        1 * listener.afterSuite(_, _)
        0 * listener._
    }

    def "notifies closure before suite"() {
        def closure = Mock(Closure)

        given:

        after(descriptor, result);
    }

    @Override
    public void beforeTest(TestDescriptor descriptor) {
        before(descriptor);
    }

    @Override
    public void afterTest(TestDescriptor descriptor, TestResult result) {
        after(descriptor, result);
    }

    @Override
    public void onOutput(TestDescriptor descriptor, TestOutputEvent outputEvent) {

        this.factory = factory;
        this.logger = logger;
    }

    @Override
    public void beforeTest(TestDescriptor testDescriptor) {
    }

    @Override
    public void afterTest(TestDescriptor testDescriptor, TestResult result) {
        totalTests += result.getTestCount();
        failedTests += result.getFailedTestCount();
        skippedTests += result.getSkippedTestCount();