.callTimeout(10, TimeUnit.SECONDS)
      .build()

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

    client.newCall(request).execute().use { response ->
      println("Response completed: $response")
    }
  }
}

fun main() {
  ConfigureTimeouts().run()

 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *
 * A task has at most one next execution. If the same task instance is scheduled multiple times, the
 * earliest one wins. This applies to both executions scheduled with [TaskRunner.Queue.schedule] and
 * those implied by the returned execution delay.
 *
 * Cancellation
 * ------------
 *

        .callTimeout(10, TimeUnit.SECONDS)
        .build();
  }

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

    try (Response response = client.newCall(request).execute()) {
      System.out.println("Response completed: " + response);
    }
  }

        // Test with rule that has no delay
        helper.addIntervalRule("01:30", "15:15", "*", 0);
        start = System.currentTimeMillis();
        helper.delayByRules();
        end = System.currentTimeMillis();
        assertTrue(end - start < 50); // Should return quickly

        // Test with rule that has delay (we'll use a very short delay for testing)
        helper.ruleList.clear();

type BatchJobRetry struct {
	line, col int
	Attempts  int           `yaml:"attempts" json:"attempts"` // number of retry attempts
	Delay     time.Duration `yaml:"delay" json:"delay"`       // delay between each retries
}

var _ yaml.Unmarshaler = &BatchJobRetry{}

// UnmarshalYAML - BatchJobRetry extends unmarshal to extract line, column information

    @Override
    public <V> ListenableScheduledFuture<V> schedule(
        Callable<V> callable, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override
    public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override

            if (!exponentialBackoff) {
                return initialDelayMs;
            }

            long delay = initialDelayMs;
            for (int i = 1; i < attemptNumber; i++) {
                delay = (long) (delay * backoffMultiplier);
            }

            return Math.min(delay, maxDelayMs);
        }

        public int getMaxAttempts() {
            return maxAttempts;
        }

   */
  @Override
  protected void expectContents(Collection<E> expectedCollection) {
    List<E> expectedList = copyToList(expectedCollection);
    // Avoid expectEquals() here to delay reason manufacture until necessary.
    if (getList().size() != expectedList.size()) {
      fail("size mismatch: " + reportContext(expectedList));
    }
    for (int i = 0; i < expectedList.size(); i++) {

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

      notifyStopped();
    }
  }

  /*
   * A NoOp service that will delay the startup and shutdown notification for a configurable amount
   * of time.
   */
  private static class NoOpDelayedService extends NoOpService {
    private final long delay;

    NoOpDelayedService(long delay) {
      this.delay = delay;
    }

    @Override
    protected void doStart() {
      new Thread() {