publishDummyPlugin(executer)
        }

        buildFile << """
            def notifier = services.get(${BuildScanEndOfBuildNotifier.name})
        """
    }

    def "can observe successful build after completion of user logic and build outcome is reported"() {
        when:
        buildFile << """
            notifier.notify {
                println "failure is null: \${it.failure == null}"
            }

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nullable;

/**
 * Service to create providers from {@link ValueSource}s.
 *
 * Notifies interested parties when values are obtained from their sources.
 *
 * @since 6.1
 */
@ServiceScope(Scope.Build.class)
public interface ValueSourceProviderFactory {

// ThresholdNotifier manages CgroupNotifiers based on memory eviction thresholds, and performs a function
// when memory eviction thresholds are crossed
type ThresholdNotifier interface {
	// Start calls the notifier function when the CgroupNotifier notifies the ThresholdNotifier that an event occurred
	Start()
	// UpdateThreshold updates the memory cgroup threshold based on the metrics provided.

    private final RunNotifier notifier;

    public RunNotifierWrapper(RunNotifier notifier) {
        this.notifier = notifier;
    }

    @Override
    public void fireTestSuiteStarted(Description description) {
        notifier.fireTestSuiteStarted(description);
    }

    @Override
    public void fireTestSuiteFinished(Description description) {
        notifier.fireTestSuiteFinished(description);
    }

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Tests {@code Notifier}.
 *
 */
class NotifierTest {

    @Test
    void testHashCodeNullSafe() {
        new Notifier().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Notifier().equals(null));

        new Notifier().equals(new Notifier());
    }

    @Test
    void testEqualsIdentity() {

class InstrumentedTest extends Specification {
    @Rule
    final SetSystemProperties systemProperties = new SetSystemProperties()

    def cleanup() {
        InstrumentedInputs.discardListener()
    }

    def "notifies listener when system property is used"() {
        def listener = withInstrumentedInputsListener()

        System.setProperty("prop", "value")

        when:

class ModelGraphTest extends RegistrySpec {
    def graph = new ModelGraph(root())
    def nodes = [:]

    def setup() {
        nodes[graph.root.path] = graph.root
    }

    def "notifies listener when node added"() {
        def listener = allAcceptingListener()
        def a = node("a")
        def b = node("b")

        given:
        graph.addListener(listener)

        when:

 */
@UsedByScanPlugin("test-distribution, test-retry")
public interface TestResultProcessor {
    /**
     * Notifies this processor that a test has started execution.
     */
    @UsedByScanPlugin("test-distribution")
    void started(TestDescriptorInternal test, TestStartEvent event);

    /**
     * Notifies this processor that a test has completed execution.
     */
    @UsedByScanPlugin("test-distribution")

                    public void run(RunNotifier notifier) {
                        for (Description description : testSuiteDescription.getChildren()) {
                            notifier.fireTestStarted(description);
                            try {
                                if (testContainingInstance.doSomething()) {
                                    notifier.fireTestFinished(description);
                                } else {

			notifierFactory := NewMockNotifierFactory(mockCtrl)
			notifier := NewMockCgroupNotifier(mockCtrl)

			m := newTestMemoryThresholdNotifier(tc.evictionThreshold, notifierFactory, nil)
			notifierFactory.EXPECT().NewCgroupNotifier(testCgroupPath, memoryUsageAttribute, tc.expectedThreshold.Value()).Return(notifier, tc.updateThresholdErr).Times(1)
			var events chan<- struct{} = m.events
			notifier.EXPECT().Start(events).Return().AnyTimes()