updateCRD()

	drained := make(chan struct{})
	go func() {
		defer close(drained)
		wg.Wait()
	}()

	select {
	case <-drained:
	case <-time.After(wait.ForeverTestTimeout):
		t.Fatal("timed out waiting for watchers to be terminated")
	}

	stopChan := make(chan struct{})

	// Set up loop to modify CRD in the background
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			select {

				// after (or too close before) the test has already timed out.
				// Add a shorter timeout so that the test will produce useful output.
				ctx, cancelCtx = context.WithTimeout(ctx, cmdTimeout)
			}
		}
	}

	cmd := exec.CommandContext(ctx, name, args...)
	cmd.Cancel = func() error {
		if cancelCtx != nil && ctx.Err() == context.DeadlineExceeded {
			// The command timed out due to running too close to the test's deadline.

func (t *TestWatcher) Update(meshConfig *meshconfig.MeshConfig, timeout time.Duration) error {
	t.HandleMeshConfig(meshConfig)
	select {
	case <-t.doneCh:
		return nil
	case <-time.After(timeout):
		return errors.New("timed out waiting for mesh.Watcher handler to trigger")
	}

        client.performRequest(new HttpGet("${httpServer.uri}/"), false)

        then:
        def e = thrown(HttpRequestException)
        e.cause instanceof SocketTimeoutException
        e.cause.message == 'Read timed out'
    }

    private HttpSettings getHttpSettings() {
        Stub(HttpSettings) {
            getProxySettings() >> Mock(HttpProxySettings)
            getSecureProxySettings() >> Mock(HttpProxySettings)

        """
        openJpmsModulesForConfigurationCache()
        def waitForExpirationResult = executer.withArgument('waitForExpiration').runWithFailure()

        then:
        waitForExpirationResult.assertHasCause("Timed out waiting for expiration event")

        and:
        !file(EXPIRATION_EVENT).exists()
    }

    def "a daemon expiration listener receives expiration reasons when daemons run in the foreground"() {

      }
      val nowMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime())
      if (nowMillis >= timeoutMillis) break
      (this as Object).wait(timeoutMillis - nowMillis)
    }

    throw AssertionError("Timed out waiting for response to $url")
  }

  companion object {
    val TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(10)
  }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String {
    return logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")
  }

	writeMessage(t, path, &n)

	select {
	case <-doneCh:
		g.Expect(newN).To(Equal(&n))
		g.Expect(w.Networks()).To(Equal(newN))
		break
	case <-time.After(time.Second * 5):
		t.Fatal("timed out waiting for update")
	}
}

func newNetworksWatcher(t *testing.T, filename string) mesh.NetworksWatcher {
	t.Helper()
	w, err := mesh.NewNetworksWatcher(filewatcher.NewWatcher(), filename)
	if err != nil {

      throws TimeoutException, ExecutionException {
    SettableFuture<String> future = SettableFuture.create();
    future.set(RESULT);
    /*
     * getUninterruptibly should call the timed get method once with a
     * wait of 0 seconds (and it should succeed, since the result is already
     * available).
     */
    assertEquals(RESULT, getUninterruptibly(future, 0, SECONDS));
  }

	for {
		select {
		case e := <-fx.Events:
			if e.Type == et {
				return &e
			}
			log.Infof("skipping event %q want %q", e.Type, et)
			continue
		case <-delay.C:
			t.Fatalf("timed out waiting for %v", et)
		}
	}
}

// MatchOrFail expects the provided events to arrive, skipping unmatched events
func (fx *Updater) MatchOrFail(t test.Failer, events ...Event) {
	t.Helper()