metadata:
  annotations:
    internal.istio.io/parents: HTTPRoute/http-timeout-backend-request.default
    internal.istio.io/route-semantics: gateway
  creationTimestamp: null
  name: http-timeout-backend-request-0-istio-autogenerated-k8s-gateway
  namespace: default
spec:
  gateways:
  - istio-system/gateway-istio-autogenerated-k8s-gateway-default
  hosts:
  - timeout-backend.domain.example
  http:
  - match:
    - uri:

  }

  /** @since 28.0 */
  @Override
  public final void awaitRunning(Duration timeout) throws TimeoutException {
    Service.super.awaitRunning(timeout);
  }

  /** @since 15.0 */
  @Override
  public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException {
    delegate.awaitRunning(timeout, unit);
  }

  /** @since 15.0 */
  @Override
  public final void awaitTerminated() {

    delegate().putLast(e);
  }

  @Override
  public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerFirst(e, timeout, unit);
  }

  @Override
  public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offerLast(e, timeout, unit);
  }

  @Override
  public E takeFirst() throws InterruptedException {

			client := &http.Client{
				Timeout: time.Duration(requestTimeoutMillis) * time.Millisecond,
			}
			log.Infof("Waiting for Envoy proxy to be ready (timeout: %d seconds)...", timeoutSeconds)

			var err error
			timeout := time.After(time.Duration(timeoutSeconds) * time.Second)

			for {
				select {
				case <-timeout:
					return fmt.Errorf("timeout waiting for Envoy proxy to become ready. Last error: %v", err)

			args:             strings.Split("--timeout 20ms virtual-service bar.default", " "),
			wantException:    true,
			expectedOutput:   "Error: timeout expired before resource networking.istio.io/v1alpha3/VirtualService/default/bar became effective on all sidecars\n",
		},
		{
			execClientConfig: cannedResponseMap,
			args:             strings.Split("--timeout 2s virtualservice foo.default", " "),
			wantException:    false,

    private List<Throwable> failures = []
    private timeout = 5000

    ConcurrentTestUtil() {}

    ConcurrentTestUtil(int timeout) {
        this.timeout = timeout
    }

    @Override
    protected void after() {
        finished()
    }

    /**
     * Polls the given assertion until it succeeds, or the timeout expires.
     * <p>

    this.session = session;
    this.notifyAll();
  }

  /** Waits for an OAuth session for this client to be set. */
  public synchronized void awaitAccessToken(Timeout timeout) throws InterruptedIOException {
    while (session == null) {
      timeout.waitUntilNotified(this);
    }
  }

  /** Starts a real time messaging session. */
  public void startRtm() throws IOException {
    String accessToken;

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().awaitTermination(timeout, unit);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks) throws InterruptedException {

    }

    public ExecJob logSuffix(final String logSuffix) {
        this.logSuffix = logSuffix.trim().replaceAll("\\s", "_");
        return this;
    }

    public ExecJob timeout(final int timeout) {
        this.timeout = timeout;
        return this;
    }

    public ExecJob useLocalFesen(final boolean useLocalFesen) {
        this.useLocalFesen = useLocalFesen;
        return this;
    }

					}
				case <-max.C:
					t.Fatalf("timeout (%v) waiting for client to timeout (%v) reading", tooLong, timeout)
				}

				select {
				case res := <-pasvch:
					t.Logf("writer in %v wrote %d: %v", res.d, res.n, res.err)
				case <-max.C:
					t.Fatalf("timeout waiting for writer to finish writing")
				}
			})
		}
	}
}