private final OkHttpClient client;

  public CacheResponse(File cacheDirectory) throws Exception {
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")

    client = new OkHttpClient.Builder()
        .addInterceptor(
            new BasicAuthInterceptor("publicobject.com", "jesse", "password1"))
        .build();
  }

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/secrets/hellosecret.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {

import okhttp3.Response;

public class CancelCall {
  private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
  private final OkHttpClient client = new OkHttpClient();

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

    final long startNanos = System.nanoTime();

        val testClass = access.findClassByName(it)

        if (testClass != null) {
          access.registerAsUsed(testClass)
          registerTest(access, testClass)
        }
      } catch (e: Exception) {
        // If you throw an exception here then native image building fails half way through
        // silently without rewriting the binary. So we report noisily, but keep going and prefer
        // running most tests still.

    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {
    for (HttpUrl url; (url = queue.take()) != null; ) {
      if (!fetchedUrls.add(url)) {
        continue;
      }

 */
public final class PrintEventsNonConcurrent {
  private final OkHttpClient client = new OkHttpClient.Builder()
      .eventListener(new PrintingEventListener())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    System.out.println("REQUEST 1 (new connection)");

import org.junit.jupiter.params.provider.ArgumentsProvider

abstract class SimpleProvider : ArgumentsProvider {
  override fun provideArguments(context: ExtensionContext) = arguments().map { Arguments.of(it) }.stream()

  @Throws(Exception::class)
  abstract fun arguments(): List<Any>

        }
      }
    thread.start()
    thread.join()

    assertFailsWith<AssertionError> {
      testRule.afterEach(extensionContext)
    }.also { expected ->
      assertThat(expected).hasMessage("uncaught exception thrown during test")
      assertThat(expected.cause!!).hasMessage("boom!")
    }
  }

        val paramsClass = Class.forName("$packageName.SSLParametersImpl")

        StandardAndroidSocketAdapter(sslSocketClass, sslSocketFactoryClass, paramsClass)
      } catch (e: Exception) {
        AndroidLog.androidLog(
          loggerName = OkHttpClient::class.java.name,
          logLevel = Platform.WARN,
          message = "unable to load android socket classes",
          t = e,
        )

  return try {
    val (major, minor, _) = ideaVersionString.split(".", limit = 3)
    KotlinVersion(major.toInt(), minor.toInt()) < KotlinVersion(2023, 2)
  } catch (e: Exception) {
    false // Unknown version, presumably compatible.
  }