instant.cancelled
                }
                thread.blockUntil.cancelled
            }
            instant.finished
        }

        thread.blockUntil.started
        writeEnd.close()
        thread.blockUntil.finished

        then:
        cancellationToken.isCancellationRequested()
        executorService.shutdownNow().empty
    }

import org.gradle.tooling.events.FinishEvent;

/**
 * An event that informs about a task having finished its execution. You can query the result of the task using {@link #getResult()}.
 *
 * @since 2.5
 */
public interface TaskFinishEvent extends TaskProgressEvent, FinishEvent {

    /**
     * Returns the result of the finished task operation. Currently, the result will be one of the following sub-types:
     *
     * <ul>

    private UserInput pending;
    private boolean finished;

    @Override
    public void startInput() {
        synchronized (lock) {
            pending = null;
            finished = false;
        }
    }

    @Override
    public void putInput(UserInput input) {
        synchronized (lock) {
            if (input == END_OF_INPUT) {
                finished = true;
                lock.notifyAll();

                    workQueue1.await()

                    signal("finished")
                }
            }
        """

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

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

        then:

		}
		outC <- buf.String()
	}()

	finished := false
	start := time.Now()

	// Clean up in a deferred call so we can recover if the example panics.
	defer func() {
		timeSpent := time.Since(start)

		// Close pipe, restore stdout, get output.
		w.Close()
		os.Stdout = stdout
		out := <-outC

		err := recover()
		ok = eg.processRunResult(out, timeSpent, finished, err)
	}()

	// Run example.
	eg.F()

        4 * logger.log(ERROR, "<output>")
        1 * logger.log(INFO, "Finished <testTask>, see full log $pathToLogStr.")

        logOutput() == """See $pathToLogStr for all output for <testTask>.
<operation> failed.
<output>
<operation> failed.
<output>
<operation> failed.
<output>
<operation> failed.
<output>
Finished <testTask>, see full log $pathToLogStr.
"""
    }

                    instant.running
                    thread.block()
                    instant.finished
                }
            }
            thread.blockUntil.running
            lifecycle.stop()
            instant.stopped
        }

        then:
        instant.finished < instant.stopped
    }

    def "multiple threads can call stop() concurrently"() {
        expect:

        when:
        def models = new CopyOnWriteArrayList<Object>()
        def finished = new CountDownLatch(1)
        def listener = { model -> models.add(model) } as StreamedValueListener
        def handler = { model ->
            models.add(model)
            finished.countDown()
        } as ResultHandler

        withConnection {

        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

        and:
        1 * connector.maybeConnect(daemon2) >>> connection
        _ * connection.daemon >> daemon2
        1 * connection.dispatch({it instanceof StopWhenIdle})
        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        0 * _
    }

    def "runs actions and discards actions when finished"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

        given:
        container.actions >> [action1, action2]

        when:
        action.execute(project)

        then:
        1 * action1.execute(project)
        1 * action2.execute(project)

        and:
        1 * container.finished()
    }