when:
        logger.beforeSuite(rootSuite)
        logger.beforeTest(test())
        logger.afterTest(test(), result())
        logger.afterSuite(rootSuite, result())

        then:
        !logger.hadFailures()
        logger.totalTests == 1

        when:
        logger.beforeSuite(rootSuite)
        logger.beforeTest(test())
        logger.afterTest(test(), result())

            package it;

            import org.testng.annotations.BeforeTest;
            import org.testng.annotations.Test;

            import static org.testng.Assert.assertEquals;

            public class IntegrationTest {

                protected int value = 0;

                @BeforeTest
                public void before() {
                    value = 1;
                }

        when:
        task.executeTests()

        then:
        1 * testListener.beforeTest(_)

        when:
        // rewire a mocked TestReporter as it gets removed by AbstractTestTask#createReporting()
        task.testReporter = Mock(TestReporter)
        task.executeTests()

        then:
        0 * testListener.beforeTest(_)
    }

    def "removes listeners even if execution fails"() {

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

    public static void beforeClass() {
        System.out.println("beforeClass out");
        System.err.println("beforeClass err");
    }

    @BeforeTest
    public void beforeTest() {
        System.out.println("beforeTest out");
        System.err.println("beforeTest err");
    }

    @Test public void m1() {
        System.out.println("m1 out");
        System.err.println("m1 err");
    }

        buildFile """
            def testListener = new TestListener() {
                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 afterSuite(TestDescriptor suite, TestResult result) { println "FINISH [\$suite] [\$suite.name]" }
                void beforeTest(TestDescriptor test) { println "START [\$test] [\$test.name]" }
                void afterTest(TestDescriptor test, TestResult result) { println "FINISH [\$test] [\$test.name] [\$result.exception]" }
            }

        ImmutableSet.<String>builder()
        .add("Lorg/testng/annotations/Test;")
        .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;")

    @Override
    public void started(TestDescriptorInternal test, TestStartEvent startEvent) {
        if (test.isComposite()) {
            testListener.beforeSuite(test);
        } else {
            testListener.beforeTest(test);
        }
    }

    @Override
    public void completed(TestDescriptorInternal test, TestResult result, TestCompleteEvent completeEvent) {
        if (test.isComposite()) {

        }

        @Override
        String getAfterClassAnnotation() {
            return "@AfterClass"
        }

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

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

        @Override
        String getIgnoreOrDisabledAnnotation() {