t.Fatal(err)
			}

			// Listen for isReady to be set to true
			ticker := time.NewTicker(500 * time.Millisecond)
			defer ticker.Stop()
			readyChan := make(chan bool)
			go func(ctx context.Context, tick <-chan time.Time) {
				for {
					select {
					case <-ctx.Done():
						return
					case <-tick:
						if isReady.Load().(bool) {

		})
	}
}

type timerWrapper struct {
	timer   clock.Timer
	resets  []time.Duration
	onReset func(d time.Duration)
}

func (w *timerWrapper) C() <-chan time.Time { return w.timer.C() }
func (w *timerWrapper) Stop() bool          { return w.timer.Stop() }
func (w *timerWrapper) Reset(d time.Duration) bool {
	w.resets = append(w.resets, d)
	b := w.timer.Reset(d)
	if w.onReset != nil {
		w.onReset(d)
	}

        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)

	u_long  ifi_imcasts;
	u_long  ifi_omcasts;
	u_long  ifi_iqdrops;
	u_long  ifi_noproto;
	u_long  ifi_hwassist;
// FIXME: these are now unions, so maybe need to change definitions?
#undef ifi_epoch
	time_t  ifi_epoch;
#undef ifi_lastchange
	struct  timeval ifi_lastchange;
};

// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE.
// See /usr/include/net/if.h.
struct if_msghdr8 {
	u_short ifm_msglen;

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

				continue
			}

			// Steal timers from p2. This call to checkTimers is the only place
			// where we might hold a lock on a different P's timers. We do this
			// once on the last pass before checking runnext because stealing
			// from the other P's runnext should be the last resort, so if there
			// are timers to steal do that first.
			//
			// We only check timers on one of the stealing iterations because

		g.e.totalRequests.Inc()
		g.e.activeRequests.Inc()
		defer g.e.activeRequests.Dec()

		// Acquire the group concurrency semaphore.
		if err := g.sem.Acquire(ctx, 1); err != nil {
			return fmt.Errorf("request set timed out: %v", err)
		}
		defer g.sem.Release(1)

		return work()
	})
}

func (g *execGroup) Wait() *multierror.Error {
	return g.g.Wait()
}

func (e *executor) Close() {
	close(e.stopCh)

    @Rule BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        server.start()
    }

    def "tears down the daemon process when the client disconnects and build does not cancel in a timely manner"() {
        buildFile << """
            task block {
                doLast {
                    ${server.callFromBuild("block")}
                }
            }
        """

        when:

  private static void runUntimedInterruptsTest(int times)
      throws InterruptedException, ExecutionException, TimeoutException {
    SettableFuture<String> future = SettableFuture.create();
    FutureTask<Boolean> interruptReporter = untimedInterruptReporter(future, false);

    runNInterruptsTest(times, future, interruptReporter);
  }

  private static void runTimedInterruptsTest(int times)

func (fx *Updater) WaitOrFail(t test.Failer, et string) *Event {
	t.Helper()
	delay := time.NewTimer(time.Second * 5)
	defer delay.Stop()
	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)
		}
	}
}