super.checkForSuiteOperations(iterator, suiteName)
        with(iterator.next()) {
            details.testDescriptor.name == "JUnit Jupiter"
            details.testDescriptor.composite == true
        }
    }

    @Override
    void writeTestSources() {
        buildFile << """
            dependencies {

                void beforeSuite(TestDescriptor suite) { println "START Test Suite [\$suite.className] [\$suite.name]" }
                void afterSuite(TestDescriptor suite, TestResult result) { println "FINISH Test Suite [\$suite.className] [\$suite.name] [\$result.resultType] [\$result.testCount]" }
                void beforeTest(TestDescriptor test) { println "START Test Case [\$test.className] [\$test.name]" }

                for (InternalTestDescriptor testDescriptor : testDescriptors) {
                    if (taskPathOf(testDescriptor).equals(testTaskPath)) {
                        includeTestMatching((InternalJvmTestDescriptor) testDescriptor, testTask);
                    }
                }
            }
        }
    }

            @AnalyzeClasses(packages = "example")
            class DeclaresTestsAsFieldsNotMethodsTest {
                // this will create a JUnit Platform TestDescriptor with neither a Class- nor a MethodSource
                @ArchTest
                static final ArchRule example = classes().should().bePublic();
            }
        '''

        when:

import kotlin.system.exitProcess
import org.junit.jupiter.engine.JupiterTestEngine
import org.junit.platform.console.options.Theme
import org.junit.platform.engine.DiscoverySelector
import org.junit.platform.engine.TestDescriptor
import org.junit.platform.engine.TestEngine
import org.junit.platform.engine.discovery.DiscoverySelectors.selectClass
import org.junit.platform.launcher.Launcher
import org.junit.platform.launcher.LauncherDiscoveryRequest

        where:
        requestType        | descriptors        | internalJvmRequests                                 | expectedClassFilter | expectedMethodFilter | tasksAndTests
        "test descriptors" | [testDescriptor()] | []                                                  | TEST_CLASS_NAME     | TEST_METHOD_NAME     | [:]

                void beforeSuite(TestDescriptor suite) { println "START [$suite] [$suite.name]" }
                void afterSuite(TestDescriptor suite, TestResult result) { println "FINISH [$suite] [$suite.name]" }
                void beforeTest(TestDescriptor test) { println "START [$test] [$test.name]" }

        stopGradle()
        afterBuild()

        then: "test build operations are emitted in expected hierarchy"
        def testRootOperations = operations.all(ExecuteTestBuildOperationType) {
            it.details.testDescriptor.name.startsWith("Gradle Test Run")
        }
        testRootOperations.size() == 2
        assertJunit(testRootOperations[0], operations)
        assertJunit(testRootOperations[1], operations)
    }

                        useJUnitJupiter()
                    }
                }
            }
            tasks.test {
                onOutput(
                    KotlinClosure2<TestDescriptor, TestOutputEvent, Any>({ descriptor, event ->
                        println("onOutput:" + descriptor.displayName + ":" + event.message)
                    })
                )
            }

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

    /**