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]" }

        def rootTestOp = operations.first(ExecuteTestBuildOperationType)
        rootTestOp.details.testDescriptor.name.startsWith("Gradle Test Run :test")
        rootTestOp.details.testDescriptor.className == null
        rootTestOp.details.testDescriptor.composite == true

        assertJunit(rootTestOp, operations)
    }

    def "emitsBuildOperationsForTestNgTests"() {
        given:

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

import spock.lang.Specification

class FullExceptionFormatterTest extends Specification {
    def testDescriptor = new SimpleTestDescriptor()
    def testLogging = Mock(TestLogging)
    def formatter = new FullExceptionFormatter(testLogging)

    def "shows all exceptions that have occurred for a test"() {
        expect:
        formatter.format(testDescriptor, [new RuntimeException("oops"), new Exception("ouch")]) == """\
    java.lang.RuntimeException: oops

        this.logLevel = logLevel;
        this.displayGranularity = displayGranularity;
    }

    protected void logEvent(TestDescriptor descriptor, TestLogEvent event) {
        logEvent(descriptor, event, null);
    }

    protected void logEvent(TestDescriptor descriptor, TestLogEvent event, @Nullable String details) {
        StyledTextOutput output = textOutputFactory.create("TestEventLogger", logLevel);

        expect:
        formatter.format(testDescriptor, exceptions) == """\
    java.io.IOException at FileName1.java:11
    java.lang.AssertionError at FileName0.java:1
"""
    }

    def "shows test entry point if it can be determined"() {
        def exception = new Exception("oops")
        testDescriptor.className = getClass().name

        expect:
        formatter.format(testDescriptor, [exception]) == """\

            }

            Optional<TestDescriptor> parent = descriptor.getParent();
            return parent.isPresent() && shouldRun(parent.get(), true);
        }

        private boolean shouldRun(TestDescriptor descriptor, boolean checkingParent, ClassSource classSource) {
            Set<? extends TestDescriptor> children = descriptor.getChildren();
            if (!checkingParent) {

    }

    private List<StackTraceElement> filterStackTrace(Throwable exception, TestDescriptor descriptor) {
        Spec<StackTraceElement> filterSpec = createCompositeFilter(descriptor);
        StackTraceFilter filter = new StackTraceFilter(filterSpec);
        return filter.filter(exception);
    }

    private Spec<StackTraceElement> createCompositeFilter(TestDescriptor descriptor) {

package org.gradle.api.internal.tasks.testing;

import org.gradle.api.NonNullApi;
import org.gradle.api.tasks.testing.TestDescriptor;
import org.gradle.internal.scan.UsedByScanPlugin;

import javax.annotation.Nullable;

@UsedByScanPlugin
@NonNullApi
public interface TestDescriptorInternal extends TestDescriptor {
    @Nullable
    @Override
    TestDescriptorInternal getParent();

    Object getId();

    /**

@UsedByScanPlugin
@EventScope(Scope.Build.class)
public interface TestListenerInternal {
    void started(TestDescriptorInternal testDescriptor, TestStartEvent startEvent);

    void completed(TestDescriptorInternal testDescriptor, TestResult testResult, TestCompleteEvent completeEvent);

    void output(TestDescriptorInternal testDescriptor, TestOutputEvent event);