latch.countDown()
    }

    void onFailure(GradleConnectionException failure) {
        this.failure = failure
        latch.countDown()
    }

    def finished() {
        finished(20)
    }

    def finished(int seconds) {
        if (!latch.await(seconds, TimeUnit.SECONDS)) {
            throw new AssertionError("Timeout waiting for operation to complete.")
        }
    }

import java.util.concurrent.ExecutionException;

/**
 * Asynchronously cleans up the VFS after a build.
 *
 * Unblocks the client to receive the build finished event while the cleanup is happening.
 * However, the next build is not allowed to start until the cleanup is finished.
 */
@NonNullApi
public class CleanUpVirtualFileSystemAfterBuild extends BuildCommandOnly implements Stoppable {

 */

package org.gradle.tooling.events;

/**
 * An event that informs about an operation having finished its execution.
 *
 * @since 2.4
 */
public interface FinishEvent extends ProgressEvent {

    /**
     * Returns the result of the finished operation.
     *
     * @return the result of the finished operation
     */
    OperationResult getResult();

			return err
		}
	}

	// Reject duplicates among analyzers.
	// Precondition:  color[a] == black.
	// Postcondition: color[a] == finished.
	for _, a := range analyzers {
		if color[a] == finished {
			return fmt.Errorf("duplicate analyzer: %s", a.Name)
		}
		color[a] = finished
	}

	return nil
}

func validIdent(name string) bool {
	for i, r := range name {

            }

            Object finished = daemonConnection.receive(60, TimeUnit.SECONDS);
            if (finished != null) {
                LOGGER.debug("Received finished message: {}", finished);
            } else {
                LOGGER.warn(String.format("Timed out waiting for finished message from client %s. Discarding connection.", connection));
            }
        }
    }

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

        and:
        1 * connector.maybeConnect(daemon2) >>> connection
        _ * connection.daemon >> daemon2
        1 * connection.dispatch({it instanceof ReportStatus})
        1 * connection.receive() >> new Success(new Status(12346, "3.0", "BOGUS"))
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

	finishedVerifyLength = 12 // Length of verify_data in a Finished message.
)

var masterSecretLabel = []byte("master secret")
var extendedMasterSecretLabel = []byte("extended master secret")
var keyExpansionLabel = []byte("key expansion")
var clientFinishedLabel = []byte("client finished")
var serverFinishedLabel = []byte("server finished")

		cmp := p.components[component]
		// The component has completed
		cmp.mu.Lock()
		finished := cmp.finished
		cmpErr := cmp.err
		cmp.mu.Unlock()
		successIcon := "✅"
		if icon, found := name.IstioComponentSuccessIcons[cmpName]; found {
			successIcon = icon
		}
		if finished || cmpErr != "" {
			if finished {
				p.SetMessage(fmt.Sprintf(`%s %s installed`, successIcon, cliName), true)
			} else {

            }
        }

        /**
         * @param finished
         *            The finished to set.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * @return Returns the teminated.
         */
        public boolean isTeminated() {
            return teminated;
        }
    }

// error until the poststarthook is finished.
type postStartHookHealthz struct {
	name string

	// done will be closed when the postStartHook is finished
	done chan struct{}
}

var _ healthz.HealthChecker = postStartHookHealthz{}

func (h postStartHookHealthz) Name() string {
	return h.name
}

var errHookNotFinished = errors.New("not finished")