factory.fire(skipped)
            signalBuildFinished()
        }

        then:
        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskSuccessResult })
        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskFailureResult })
        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskSkippedResult })
        0 * listener._
    }

        adapter.onStart(test)
        adapter.onFinish(test)

        then:
        1 * listener.onTestStart(result)
        1 * listener.onTestSuccess(result)
        1 * listener.onTestFailure(result)
        1 * listener.onTestSkipped(result)
        1 * listener.onTestFailedButWithinSuccessPercentage(result)
        1 * listener.onStart(test)
        1 * listener.onFinish(test)
    }
}

 *
 * @since 6.1
 */
public interface OperationCompletionListener {
    /**
     * Called when an operation completes.
     */
    void onFinish(FinishEvent event);

import org.gradle.tooling.events.task.TaskFinishEvent;

public abstract class TaskEventsService implements BuildService<BuildServiceParameters.None>,
    OperationCompletionListener { // <1>

    @Override
    public void onFinish(FinishEvent finishEvent) {
        if (finishEvent instanceof TaskFinishEvent) { // <2>
            // Handle task finish event...
// end::build-service[]
            System.out.println(

                Property<String> getPrefix()
            }

            abstract class BlockingListener implements OperationCompletionListener, BuildService<Params> {
                @Override
                void onFinish(FinishEvent event) {
                    if (event instanceof TaskFinishEvent) {
                        ${server.callFromBuildUsingExpression("parameters.prefix.get() + event.descriptor.taskPath")}
                    } else {

            apply plugin: JavaCompileModifyingPlugin

            abstract class JavaCompileListener implements BuildService<BuildServiceParameters.None>, OperationCompletionListener {
                void onFinish(FinishEvent event) {
                    println("EVENT: \$event")
                }
            }

            abstract class JavaCompileModifyingPlugin implements Plugin<Project> {
                @Inject

            val remaining = ArrayList<Any?>(remainingSize).apply {
                for (j in 0 until remainingSize) {
                    add(read())
                }
            }
            onFinish {
                container.addAll(remaining)
            }
            return container
        }
        container.add(element)
    }
    return container
}


private

    void onTestFailure(ITestResult result) {}
    void onTestSkipped(ITestResult result) {

    }
    void onTestFailedButWithinSuccessPercentage(ITestResult result) {}
    void onStart(ITestContext context) {}
    void onFinish(ITestContext context) {}
}

public class ATestNGClassWithSkippedTest {
    @org.testng.annotations.Test
    public void skipMe() {}
}

public class ATestNGClass {
    @BeforeClass public void beforeClass() {}

            apply plugin: SomePlugin

            abstract class ListenerImpl implements BuildService<BuildServiceParameters.None>, OperationCompletionListener {
                void onFinish(FinishEvent event) {
                    // Only generic task details are exposed for now
                    assert !(event.result instanceof JavaCompileTaskOperationResult)
                }
            }

    override val sharedIdentities = ReadIdentities()

    private
    var singletonProperty: Any? = null

    override lateinit var classLoader: ClassLoader

    override fun onFinish(action: () -> Unit) {
        pendingOperations.add(action)
    }

    fun finish() {
        for (op in pendingOperations) {
            op()
        }
        pendingOperations.clear()
    }