}

    @Override
    public void await() throws InterruptedException {
      lock.lock();
      try {
        condition.await();
      } finally {
        lock.unlock();
      }
    }

    @Override
    public boolean await(long time, TimeUnit unit) throws InterruptedException {
      lock.lock();
      try {
        return condition.await(time, unit);
      } finally {

    }

    @Override
    public void await() throws InterruptedException {
      lock.lock();
      try {
        condition.await();
      } finally {
        lock.unlock();
      }
    }

    @Override
    public boolean await(long time, TimeUnit unit) throws InterruptedException {
      lock.lock();
      try {
        return condition.await(time, unit);
      } finally {

            })
        .start();

    future.cancel(true);

    assertTrue(future.isCancelled());
    assertTrue(future.isDone());

    assertTrue(successLatch.await(200, MILLISECONDS));
    assertTrue(listenerLatch.await(200, MILLISECONDS));

    latch.countDown();

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**

            waiting.countDown()
            result = daemonConnection.receive(20, TimeUnit.SECONDS)
            received.countDown()
        }
        waiting.await()
        Thread.sleep(500)
        connection.queueIncoming("incoming")
        received.await()

        then:
        result instanceof Received
        result.message == "incoming"
    }

    def "receive blocks until connection stopped"() {

            previous.assertCanWait();
            if (notReceived.isEmpty()) {
                // Have received all requests so downstream can wait.
                return;
            }
            if (!isAutoRelease()) {
                throw new IllegalStateException(String.format("Cannot wait as no requests have been released. Waiting for %s, received %s.", format(notReceived), format(received)));
            }
        } finally {

        val (_, asyncResp2) = pendingTasks[1]
        assertThat(
            asyncResp2.await(),
            nullValue()
        )

        // only then the most recent request will be given its response
        assertThat(
            asyncRespLast.await(),
            sameInstance(respLast)
        )

        // and no other requests are left to process
        assertThat(

            })
        .start();

    future.cancel(true);

    assertTrue(future.isCancelled());
    assertTrue(future.isDone());

    assertTrue(successLatch.await(200, MILLISECONDS));
    assertTrue(listenerLatch.await(200, MILLISECONDS));

    latch.countDown();

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**

		os.Exit(1)
	}
	want, err = filepath.EvalSymlinks(want)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if !strings.EqualFold(goroot, want) {
		fmt.Fprintf(os.Stderr, "go env GOROOT:\nhave %s\nwant %s\n", goroot, want)
		os.Exit(1)
	}
	fmt.Fprintf(os.Stderr, "go env GOROOT: %s\n", goroot)

}
-- check_runtime_goroot.go --
package main

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"

        lock.lock();
        try {
            boolean interrupted = false;
            while (state != State.Stopped && queue.isEmpty()) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    interrupted = true;
                }
            }
            if (interrupted) {
                Thread.currentThread().interrupt();

        }

        // Need to wait for work to complete, so release worker lease while waiting
        workerLeases.blocking(() -> {
            lock.lock();
            try {
                // Wait for any work still running in other threads
                while (pendingOperations > 0) {
                    try {
                        operationsComplete.await();
                    } catch (InterruptedException e) {