import java.util.List;

public interface BuildTreeFinishExecutor {
    /**
     * Finishes any work and runs any pending user clean up code such as build finished hooks, build service cleanup and so on.
     *
     * @param failures The failures to report to the build finished hooks.
     * @return The exception to throw, packages up the given failures plus any failures finishing the build.
     */
    @Nullable

	// Indicates whether kubelet should assume resize operation as finished.
	// For kubelet - resize operation could be assumed as finished even if
	// actual resizing is *not* finished. This can happen, because certain prechecks
	// are failing and kubelet should not retry expansion, or it could happen
	// because resize operation is genuinely finished.
	assumeResizeFinished bool
}

    assertThat(stopwatch.elapsed(MILLISECONDS)).isIn(Range.closed(NOT_ENOUGH_MS, DELAY_MS * 2));
    // Is it still computing away anyway?
    assertThat(target.finished).isFalse();
    MILLISECONDS.sleep(ENOUGH_MS);
    assertThat(target.finished).isFalse();
  }

  public void testNewProxy_badMethodWithEnoughTime() throws Exception {
    SampleImpl target = new SampleImpl(DELAY_MS);

                if (cacheValues != null) {
                    // Already visited this node
                    details.values = cacheValues;
                    details.finished = true;
                    queue.removeFirst();
                    continue;
                }

                graph.getNodeValues(node, details.values, details.successors);

        'started'          | EmptyDetails   | startedNotification(EmptyDetails)
        'progress'         | SimpleProgress | progressNotification(SimpleProgress)
        'finished'         | SimpleResult   | finishedNotification(SimpleResult)
        'finished'         | NestedResult   | finishedNotification(NestedResult)
    }

    def "throws if public type cannot be determined"() {
        given:
        def listener = listener()

     */
    <T> T withEmptyBuild(Function<? super SettingsInternal, T> action);

    /**
     * Schedules the work graph for the tasks specified in the {@link org.gradle.StartParameter} associated with the build, runs the scheduled work and finishes up the build.
     * When this method returns, all user code will have completed, including 'build finished' hooks.
     *

    def "logging is live"() {
        server.start()
        def waitingMessage = "logging task: connecting to ${server.uri}"
        def finishedMessage = "logging task: finished"

        file("build.gradle") << """
task log {
    doLast {
        println "${waitingMessage}"
        ${server.callFromBuild("waiting")}
        println "${finishedMessage}"
    }
}
"""

						Terminated: &core.ContainerStateTerminated{
							ContainerID: "docker://numbers",
							Reason:      "Completed",
							StartedAt:   metav1.NewTime(time.Now()),
							FinishedAt:  metav1.NewTime(time.Now()),
						},
					},
				}},
			},
		},
		core.Pod{
			ObjectMeta: metav1.ObjectMeta{
				Name: "foo",
			},
			Status: core.PodStatus{

import org.gradle.internal.remote.internal.Connection;
import org.gradle.launcher.daemon.protocol.Command;
import org.gradle.launcher.daemon.protocol.Failure;
import org.gradle.launcher.daemon.protocol.Finished;
import org.gradle.launcher.daemon.protocol.Message;
import org.gradle.launcher.daemon.protocol.Result;
import org.gradle.launcher.daemon.protocol.Status;
import org.gradle.launcher.daemon.protocol.Success;

Hello!