*/
    public void node(T node) {
    }

    /**
     * Starts visiting the children of the most recently visited node.
     */
    public void startChildren() {
    }

    /**
     * Finishes visiting the children of the most recently started node.
     */
    public void endChildren() {
    }

     * task execution and other work, so event handling does not block task execution. This means that a task finish event is delivered to the listener some time "soon" after the task
     * has completed. The events contain timestamps to allow you collect timing information.
     * </p>
     *
     * <p>The listener is automatically unsubscribed when the build finishes.</p>
     *

    /**
     * Returns the number of byte written since {@link #start(long)} was called.
     */
    public long getBytesWritten() {
        return countingOutputStream.getCount();
    }

    /**
     * Finishes writing, flushing and resetting any buffered state
     */
    public void done() throws IOException {
        countingOutputStream.flush();
        countingOutputStream = null;
    }

     *
     * @param failure Can be null, in which case this method does nothing.
     */
    void failed(@Nullable Throwable failure);

    /**
     * Finishes the build operation which should only be done once.
     */
    void setResult(@Nullable Object result);

    /**
     * Record a status or outcome for given build operation.
     *

    }

    /**
     * Returns the number of bytes read since {@link #start(long)} was called.
     */
    public long getBytesRead() {
        return countingInputStream.getCount();
    }

    /**
     * Finishes reading, resetting any buffered state.
     */
    public void done() {
        countingInputStream = null;
    }

    private static class ResettableBufferedInputStream extends BufferedInputStream {

    /**
     * Updates the VFS and the watchers before the build finishes.
     *
     * For example, this removes everything from the root which can't be kept after the current build finished.
     * This is anything which is not within a watchable hierarchy or in a cache directory.
     *

			if (verbose) {
				printf("attempting external signal test\n");
			}

			fprintf(stderr, "OK\n");
			fflush(stderr);

			// The program should be interrupted before
			// this sleep finishes. We use select rather
			// than sleep because in older versions of
			// glibc the sleep function does some signal
			// fiddling to handle SIGCHLD.  If this
			// program is fiddling signals just when the

     * The copy operation happens only once. Sets the Jansi-related system property.
     *
     * This hackery is to prevent Jansi from creating a shared lib in a tmp dir which is deleted when
     * the Java process finishes. To avoid performance impacts caused by Jansi's default behavior the
     * library is proactively extracted into a known directory and reused by subsequent invocations.
     *

Double-click **tutorial > app > build > build**.

image::tutorial/intellij-idea-build.png[]

Once the build finishes, make sure it is successful in the IntelliJ console:
[source,text]
----
BUILD SUCCESSFUL in 966ms
7 actionable tasks: 7 executed
3:18:24 AM: Execution finished 'build'.
----

== Step 6. Running Tasks in the Terminal
Run the following command in your terminal:
[source,text]
----

func jobFinishTime(finishedJob *batch.Job) (metav1.Time, error) {
	for _, c := range finishedJob.Status.Conditions {
		if (c.Type == batch.JobComplete || c.Type == batch.JobFailed) && c.Status == v1.ConditionTrue {
			finishAt := c.LastTransitionTime
			if finishAt.IsZero() {