def testEvent = new TestStartEvent(2, "1")

        processor.started(new DefaultTestSuiteDescriptor("1", "Foo"), new TestStartEvent(1))

        when: processor.started(test, testEvent)

        then:
        1 * target.started(test, testEvent)
        1 * redirector.setOutputOwner("2")
        0 * _
    }

    def "when test completes its parent will be the owner of output"() {

            }
        """

        def started = blockingHttpServer.expectConcurrentAndBlock("item1", "item2", "item3", "submitted")
        def finished = blockingHttpServer.expectConcurrentAndBlock("finished")

        when:
        def gradle = executer.withTasks("runWork").start()

        then:
        started.waitForAllPendingCalls()

        then:
        started.release("submitted")
        started.release("item1")

            return op.detailsType == detailsClass.name && op.details.subMap(details.keySet()) == details
        }
        return found
    }

    void started(Class<?> type, Predicate<? super Map<String, ?>> payloadTest) {
        has(true, type, payloadTest)
    }

    void started(Class<?> type, Map<String, ?> payload = null) {
        has(true, type, (Map) payload)
    }

var (
	mutex      = sync.Mutex{}
	cThreadToM = map[uintptr]uintptr{}
	started    = atomic.Uint32{}
)

// same as CTHREADS in C, make sure all the C threads are actually started.
const cThreadNum = 2

func init() {
	register("EnsureBindM", EnsureBindM)
}

//export GoCheckBindM
func GoCheckBindM(thread uintptr) {
	// Wait all threads start
	if started.Load() != cThreadNum {

        when:
        logger.logEvent(rootDescriptor, TestLogEvent.STARTED)

        then:
        textOutputFactory.toString() == "{TestEventLogger}{INFO}${sep}Test Run STARTED${sep}"
    }

    def "log Gradle worker event"() {
        createLogger(LogLevel.INFO)

        when:
        logger.logEvent(workerDescriptor, TestLogEvent.STARTED)

        then:

        if (stdoutListeners.add(listener) && started) {
            loggingOutput.addStandardOutputListener(listener);
        }
    }

    @Override
    public void addStandardErrorListener(StandardOutputListener listener) {
        if (stderrListeners.add(listener) && started) {
            loggingOutput.addStandardErrorListener(listener);
        }
    }

        try {
            if (stopped) {
                throw new IllegalStateException("server connector cannot be started as it is either stopping or has been stopped");
            }
            if (started) {
                throw new IllegalStateException("server connector cannot be started as it has already been started");
            }

                doLast {
                    new URL("${getUrl('started')}").text
                    new URL("${getUrl('block')}").text
                }
            }
        """

        given:
        executer.beforeExecute {
            executer.withStackTraceChecksDisabled()
        }
        expectEvent("started")
        expectEvent("block")

        def generator = new ClientBuildEventGenerator(consumer, subscriptions, [mapper], fallback)

        when:
        generator.started(operation, startEvent)

        then:
        1 * tracker1.started(operation, startEvent)
        1 * tracker2.started(operation, startEvent)
        1 * tracker3.started(operation, startEvent)
        0 * tracker1._
        0 * tracker2._
        0 * tracker3._

        when:

        def testDescriptor1 = createTestDescriptor(testEvent1)
        def testDescriptor2 = createTestDescriptor(testEvent2)

        when:
        testWorkerProgressListener.started(testDescriptor1, createTestStartEvent())
        testWorkerProgressListener.started(testDescriptor2, createTestStartEvent())

        then: