throw UncheckedException.throwAsUncheckedException(e.getCause());
        }
    }

    @Override
    public void complete() {
        finished.countDown();
    }

    @Override
    public boolean isComplete() {
        return finished.getCount() == 0;
    }

    @Override
    public void cancel() {
        runnable.cancel(true);
    }

            def build = connection.newBuild()
            build.forTasks('hang')
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            resultHandler.finished()
        }
        then:
        resultHandler.assertFailedWith(BuildCancelledException)
    }

    def "can cancel build after completion"() {
        buildFile << """
task thing
"""

        has(true, type, payloadTest)
    }

    void started(Class<?> type, Map<String, ?> payload = null) {
        has(true, type, (Map) payload)
    }

    void finished(Class<?> type, Map<String, ?> payload = null) {
        has(false, type, (Map) payload)
    }

    void has(boolean started, Class<?> type, Map<String, ?> payload) {

        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 {

			default:
				postNote(syscall.Getpid(), "alarm")
				runtime.Gosched()
			}
		}
		finished <- true
	}()
	time.Sleep(dur)
	close(done)
	<-finished
	<-finished
	// When run with 'go test -cpu=1,2,4' alarm from this test can slip
	// into subsequent TestSignal() causing failure.
	// Sleep for a while to reduce the possibility of the failure.
	time.Sleep(10 * time.Millisecond)
}

 */

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));
            }
        }
    }

		}
		if readErr != nil {
			fmt.Fprintf(os.Stderr, "testing: read temp file: %v\n", readErr)
			os.Exit(1)
		}

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

	// Run example.
	eg.F()
	finished = true
	return
}

func createTempFile(exampleName string) *os.File {
	for i := 0; ; i++ {
		name := fmt.Sprintf("%s/go-example-stdout-%s-%d.txt", os.TempDir(), exampleName, i)