Preconditions.checkNotNull(command, "command must not be null");
    Preconditions.checkNotNull(unit, "unit must not be null!");
    return schedule(java.util.concurrent.Executors.callable(command), delay, unit);
  }

  @Override
  public <V> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, long delay, TimeUnit unit) {

    Preconditions.checkNotNull(command, "command must not be null");
    Preconditions.checkNotNull(unit, "unit must not be null!");
    return schedule(java.util.concurrent.Executors.callable(command), delay, unit);
  }

  @Override
  public <V> ListenableScheduledFuture<V> schedule(
      Callable<V> callable, long delay, TimeUnit unit) {

  fun setBodyDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {
    bodyDelayAmount = delay
    bodyDelayUnit = unit
  }

  fun getBodyDelay(unit: TimeUnit): Long = unit.convert(bodyDelayAmount, bodyDelayUnit)

  fun setHeadersDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {
    headersDelayAmount = delay
    headersDelayUnit = unit
  }

	for _, httpRoute := range vs.Http {
		if httpRoute.Fault != nil {
			if httpRoute.Fault.Delay != nil {
				// nolint: staticcheck
				if httpRoute.Fault.Delay.Percent > 0 {
					ctx.Report(gvk.VirtualService,
						msg.NewDeprecated(r, replacedMessage("HTTPRoute.fault.delay.percent", "HTTPRoute.fault.delay.percentage")))
				}
			}
		}
	}
}

import okhttp3.Request

class PerCallSettings {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build()

    // Copy to customize OkHttp for this request.
    val client1 =
      client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build()
    try {

	})
	t.Run("only user", func(t *testing.T) {
		cms, w := setup(t)
		if _, err := cms.Create(context.Background(), cmUser, metav1.CreateOptions{}); err != nil {
			t.Fatal(err)
		}
		retry.UntilOrFail(t, func() bool { return w.Mesh().GetIngressClass() == "user" }, retry.Delay(time.Millisecond), retry.Timeout(time.Second))
	})

      String message = "inputFuture=[" + localInputFuture + "]";
      if (localTimer != null) {
        long delay = localTimer.getDelay(TimeUnit.MILLISECONDS);
        // Negative delays look confusing in an error message
        if (delay > 0) {
          message += ", remaining delay=[" + delay + " ms]";
        }
      }
      return message;
    }
    return null;
  }

  @Override

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build();

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build();

func netpollBreak() {}

func netpoll(delay int64) (gList, int32) {
	lock(&mtx)

	// If delay >= 0, we include a subscription of type Clock that we use as
	// a timeout. If delay < 0, we omit the subscription and allow poll_oneoff
	// to block indefinitely.
	pollsubs := subs
	if delay >= 0 {
		timeout := &subs[0]
		clock := timeout.u.subscriptionClock()
		clock.timeout = uint64(delay)
	} else {
		pollsubs = subs[1:]

		callCount int
		configs   []*config.Config
		err       error
	)

	delay := make(chan struct{}, 1)

	someConfigFunc := func() ([]*config.Config, error) {
		switch callCount {
		case 0:
			configs = createConfigSet
			err = nil
		case 3:
			configs = nil
			err = errors.New("snapshotFunc can't connect")
			delay <- struct{}{}
		}

		callCount++
		return configs, err
	}