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")

        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:

        def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException())

        given:
        idGenerator.generateId() >>> [1, 2]

        and:
        processor.testClassStarted("some-test")

        when:
        processor.testClassFinished(failure)

        then:

        manager.addListener(recordingListener("1"))
        manager.addListener(recordingListener("2"))
        manager.addListener(recordingListener("3"))

        when:
        broadcaster.started(op1, startEvent)
        broadcaster.started(op2, startEvent)
        broadcaster.finished(op1, finishEvent)
        broadcaster.finished(op2, finishEvent)

        then:
        events == [
            start("1", id1),