@Test fun get() {
    server.enqueue(MockResponse(body = "hello, OkHttp"))

    val client = OkHttpClient()

    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Accept", "text/plain")
        .build()
    val response = client.newCall(request).execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("hello, OkHttp")

  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

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

    val startNanos = System.nanoTime()
    val call = client.newCall(request)

    // Schedule a job to cancel the call in 1 second.
    executor.schedule({

---

## Architecture

### Package Structure

```
org.codelibs.fess.suggest/
├── Suggester.java              # Main entry point (Facade)
├── SuggesterBuilder.java       # Builder for Suggester
├── analysis/                   # Suggest analyzer
├── constants/                  # Field names, constants
├── exception/                  # Custom exceptions
├── index/

   */
  private <T extends @Nullable Object> ImmutableList<Callable<T>> wrapTasks(
      Collection<? extends Callable<T>> tasks) {
    ImmutableList.Builder<Callable<T>> builder = ImmutableList.builder();
    for (Callable<T> task : tasks) {
      builder.add(wrapTask(task));
    }
    return builder.build();
  }

  // These methods wrap before delegating.
  @Override
  public final void execute(Runnable command) {

        QueryBuilder builder = queryCommand.convertTermQuery(queryContext, (TermQuery) query, 1.0f);
        if (text.startsWith("sort:")) {
            assertNull(builder);
        } else {
            logger.info("{} => {}", text, builder.toString());
            assertEquals(expectedClass, builder.getClass());
            assertEquals(expectedQuery, builder.toString().replaceAll("[\s\n]", ""));
        }

        error -> error.printStackTrace());
```

## API Overview

- `org.codelibs.curl.Curl`: entry point for HTTP methods (GET, POST, PUT, DELETE, HEAD, OPTIONS, CONNECT, TRACE).
- `org.codelibs.curl.CurlRequest`: builder for HTTP requests.
- `org.codelibs.curl.CurlResponse`: wrapper for HTTP responses.
- `org.codelibs.curl.CurlException`: unchecked exception for errors.

   * method exists only to hide {@link ImmutableSet#builder} from consumers of {@code
   * ContiguousSet}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Use {@link #create}.
   */
  @Deprecated
  @DoNotCall("Always throws UnsupportedOperationException")
  public static <E> ImmutableSortedSet.Builder<E> builder() {
    throw new UnsupportedOperationException();
  }

                    ImmutableSortedMap.Builder<String, String> builder =
                        ImmutableSortedMap.naturalOrder();
                    for (Entry<String, String> entry : entries) {
                      builder.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingSortedMap<>(builder.build());
                  }
                })

    MutableGraph<Integer> g2 = builder.build();

    // for g1, add 1->2 first, then 3->1
    g1.putEdge(N1, N2);
    g1.putEdge(N3, N1);

    // for g2, add 3->1 first, then 1->2
    g2.putEdge(N3, N1);
    g2.putEdge(N1, N2);

    assertThat(g1).isEqualTo(g2);
  }

  @Test
  public void equivalent_edgeDirectionsDiffer() {
    graph.putEdge(N1, N2);

    client =
      OkHttpClient
        .Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

  @Test
  fun testRequestExternal() {
    assumeNetwork()

    val request = Request("https://www.google.com/robots.txt".toHttpUrl())

    val networkRequest =
      request
        .newBuilder()
        .build()

    val call = client.newCall(networkRequest)