return FINISHED
            }
        })

        then:
        disposition == expectedDisposition

        and:
        !lock1.lockedState
        !lock2.lockedState

        where:
        lock1Locked | lock2Locked | expectedDisposition
        true        | true        | FINISHED
        true        | false       | FINISHED
        false       | true        | FINISHED

        0 * tracker1._
        0 * tracker2._
        0 * tracker3._

        when:
        generator.finished(operation, finishEvent)

        then:
        1 * tracker1.finished(operation, finishEvent)
        1 * tracker2.finished(operation, finishEvent)
        1 * tracker3.finished(operation, finishEvent)

        then:
        1 * tracker1.discardState(operation)

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

- Return zero time (midnight on Jan. 1, 1970) instead of negative number when reporting startedAt and finishedAt of the not started or a running Pod when using `dockershim` as a runtime. ([#99585](https://github.com/kubernetes/kubernetes/pull/99585), [@Iceber](https://github.com/Iceber))

        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: