}
        }
    }

    @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);
            if (operation != null) {

        _ * taskDescriptor.getParentId() >> null

        def startEvent = Mock(InternalOperationStartedProgressEvent)
        _ * startEvent.getEventTime() >> 999
        _ * startEvent.getDescriptor() >> taskDescriptor

        adapter.onEvent(startEvent)
        adapter.onEvent(startEvent)

        then:
        def e = thrown(IllegalStateException)

                    buildStartTimestamp = startEvent.getTimestamp();
                    buildProgressOperationId = startEvent.getProgressOperationId();
                    phaseStarted(startEvent, Phase.Initializing);
                } else if (startEvent.getBuildOperationCategory() == BuildOperationCategory.CONFIGURE_ROOT_BUILD) {
                    // Once the root build starts configuring, we are in Configuring phase

        _ * workItemDescriptor.getClassName() >> 'SomeRunnable'

        def startEvent = Mock(InternalOperationStartedProgressEvent)
        _ * startEvent.getEventTime() >> 999
        _ * startEvent.getDisplayName() >> 'Test Work started'
        _ * startEvent.getDescriptor() >> workItemDescriptor

        adapter.onEvent(startEvent)

        then:

 */

package org.gradle.tooling.events.internal;

import org.gradle.tooling.events.OperationDescriptor;
import org.gradle.tooling.events.StartEvent;

/**
 * Base implementation of the {@code StartEvent} interface.
 */
public class DefaultStartEvent extends BaseProgressEvent implements StartEvent {

    public DefaultStartEvent(long eventTime, String displayName, OperationDescriptor descriptor) {

        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:

        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),
            start("2", id1),

 * limitations under the License.
 */

package org.gradle.tooling.events.task;

import org.gradle.tooling.events.StartEvent;

/**
 * An event that informs about a task having started its execution.
 *
 * @since 2.5
 */
public interface TaskStartEvent extends TaskProgressEvent, StartEvent {

 * limitations under the License.
 */

package org.gradle.tooling.events.download;

import org.gradle.tooling.events.StartEvent;

/**
 * An event that indicates the start of a file download.
 *
 * @since 7.3
 */
public interface FileDownloadStartEvent extends FileDownloadProgressEvent, StartEvent {

        unit = new FailFastTestListenerInternal(testExecuter, delegate)
    }

    def "started invokes delegate"() {
        when:
        unit.started(testDescriptor, startEvent)

        then:
        1 * delegate.started(testDescriptor, startEvent)
    }

    def "output invokes delegate"() {
        when:
        unit.output(testDescriptor, event)

        then:
        1 * delegate.output(testDescriptor, event)