}
	s.hm.Lock()
	defer s.hm.Unlock()
	s.started = stop
}

var _ Informer[controllers.Object] = &delayedClient[controllers.Object]{}

func (s *delayedClient[T]) set(inf Informer[T]) {
	if inf != nil {
		s.inf.Swap(&inf)
		s.hm.Lock()
		defer s.hm.Unlock()
		for _, h := range s.handlers {
			inf.AddEventHandler(h)
		}
		s.handlers = nil
		if s.started != nil {
			inf.Start(s.started)
		}
	}

                + "Expect the resultProcessor to break. "
                + "Don't expect to see this assertion stack trace due to the current architecture";

            parentId = testMethodParentId.get(iTestResult.getMethod());
            assert parentId != null;
        }

        owner.startThread {
            withLock {
                started = true
                condition.signalAll()
            }

            action.run()

            withLock {
                completed = true
                condition.signalAll()
            }
        }

        withLock {
            while (!started) {
                condition.await()
            }
        }
    }

//
// testinggoroutine: report calls to (*testing.T).Fatal from goroutines started by a test
//
// Functions that abruptly terminate a test, such as the Fatal, Fatalf, FailNow, and
// Skip{,f,Now} methods of *testing.T, must be called from the test goroutine itself.
// This checker detects calls to these functions that occur within a goroutine
// started by the test. For example:
//
//	func TestFoo(t *testing.T) {
//	    go func() {

                dest.add(tracker);
            }
        }
    }

    @Override
    public void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {
        for (BuildOperationTracker tracker : trackers) {
            tracker.started(buildOperation, startEvent);
        }
        for (Mapper mapper : mappers) {
            Operation operation = mapper.accept(buildOperation);

 */

package org.gradle.launcher.daemon.logging;

public abstract class DaemonMessages {
    public final static String PROCESS_STARTED = "Daemon server started.";
    public final static String ABOUT_TO_CLOSE_STREAMS = "Daemon started. About to close the streams. Daemon details: ";
    public final static String STARTED_RELAYING_LOGS = "The client will now receive all logging from the daemon (pid: ";

		wantErr               error
	}{
		{
			desc:                  "not-started",
			inValues:              "",
			startRender:           false,
			inChart:               chart.Chart{},
			objFileTemplateReader: Renderer{},
			wantResult:            "",
			wantErr:               errors.New("fileTemplateRenderer for not started in renderChart"),
		},
		{
			desc: "started-random-template",
			inValues: `
description: test
`,

[19515] [INFO] Booting worker with pid: 19515
[19511] [INFO] Started server process [19511]
[19511] [INFO] Waiting for application startup.
[19511] [INFO] Application startup complete.
[19513] [INFO] Started server process [19513]
[19513] [INFO] Waiting for application startup.
[19513] [INFO] Application startup complete.
[19514] [INFO] Started server process [19514]
[19514] [INFO] Waiting for application startup.

            task log { }
        """

        def runs = GradleContextualExecuter.isConfigCache() ? 2 : 1
        runs.times {
            barrier.expectConcurrent("child-build-started", "1-started", "2-started")
            barrier.expectConcurrent("child-build-finished", "1-finished", "2-finished")
        }

        when:
        runs.times {
            executer.withArgument("--parallel")

 */

package org.gradle.internal.buildevents;

/**
 * The holder for when the build is considered to have started.
 *
 * This is primarily used to provide user feedback on how long the “build” took (see BuildResultLogger).
 *
 * The build is considered to have started as soon as the user, or some tool, initiated the build.
 * During continuous build, subsequent builds are timed from when changes are noticed.
 */