dependencies {
                testImplementation 'org.junit.platform:junit-platform-engine:${LATEST_PLATFORM_VERSION}'
            }
            test {
                afterSuite { descriptor, result ->
                    println("afterSuite: \$descriptor -> \$result")
                }
            }
        """
        file('src/test/java/EngineFailingExecution.java') << '''
            import org.junit.platform.engine.*;

        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;")

        this.testLogging = testLogging;
    }

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

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

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

    /**
     * Called after a test suite is finished.
     * @param suite The suite whose tests have finished being executed.
     * @param result The aggregate result for the suite.
     */
    void afterSuite(TestDescriptor suite, TestResult result);

    /**
     * Called before an atomic test is started.
     * @param testDescriptor The test which is about to be executed.
     */

        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:
        expectTestSuitePasses()

            progressLogger.setDescription("Run tests");
            progressLogger.started();
            progressLogger.progress(summary());
        }
    }

    @Override
    public void afterSuite(TestDescriptor suite, TestResult result) {
        if (suite.getParent() == null) {
            if (failedTests > 0) {
                logger.error(TextUtil.getPlatformLineSeparator() + summary());
            }

            }

            class TestListenerImpl implements TestListener {
                void beforeSuite(TestDescriptor suite) { println "START [\$suite] [\$suite.name]" }
                void afterSuite(TestDescriptor suite, TestResult result) { println "FINISH [\$suite] [\$suite.name] [\$result.resultType] [\$result.testCount]" }
                void beforeTest(TestDescriptor test) { println "START [\$test] [\$test.name]" }

     *
     * @param closure The closure to call.
     */
    public void afterSuite(Closure closure) {
        addDispatchAsTestListener("afterSuite", closure);
    }

    /**
     * Adds a closure to be notified before a test is executed. A {@link TestDescriptor} instance is passed to the closure as a parameter.
     *

            } finally {
                rootId = null;
            }
        } else {
            //when test is completed we should redirect output for the parent
            //so that log events emitted during @AfterSuite, @AfterClass are processed
            Object newOwner = parents.remove(testId);
            outputRedirector.setOutputOwner(newOwner);
        }
        processor.completed(testId, event);
    }

    @Override

                addTestListener(new TestListener() {

                    void beforeSuite(TestDescriptor d) {
                        printEventInformation('$STARTED', d)
                    }

                    void afterSuite(TestDescriptor d, TestResult result) {
                        printEventInformation('$FINISHED', d)
                    }

                    void beforeTest(TestDescriptor d) {