System.out.println("\nMost frequent values across all paths:");
            for (ValueFrequency v : group.mostFrequentValues) {
                System.out.printf("  %-70s %d times%n", v.value, v.frequency);
            }

            System.out.println("\nIndividual paths:");
            System.out.println("----------------------------------------");

    server.listener.assertClosed(1000, "Hello!")
  }

  @Test
  @Throws(Exception::class)
  fun clientAndServerCloseClosesConnection() {
    // Send close from both sides at the same time.
    server.webSocket!!.close(1000, "Hello!")
    client.processNextFrame() // Read close, close connection close.
    assertThat(client.closed).isFalse()
    client.webSocket!!.close(1000, "Hi!")

            entry.dfs_name = "consistent_share_" + i;
            testArray.s[i] = entry;
        }

        setDfsEnumArray(dfsRootEnum, testArray);

        // Call getEntries multiple times
        FileEntry[] entries1 = dfsRootEnum.getEntries();
        FileEntry[] entries2 = dfsRootEnum.getEntries();
        FileEntry[] entries3 = dfsRootEnum.getEntries();

        // Verify consistency

    this.supportsFastOffset = supportsFastOffset;
  }

  /**
   * Returns, conceptually, "origin + distance", or equivalently, the result of calling {@link
   * #next} on {@code origin} {@code distance} times.
   */
  C offset(C origin, long distance) {
    C current = origin;
    checkNonnegative(distance, "distance");
    for (long i = 0; i < distance; i++) {
      current = next(current);

  // We calculate the constant below by:
  //   1. Omitting the most significant bit (because it's always 1). => 0x1EDC6F41
  //   2. Flipping the bits of the constant so we can process a byte at a time. => 0x82F63B78
  private static final int CRC32C_GENERATOR = 0x1EDC6F41; // 0x11EDC6F41
  private static final int CRC32C_GENERATOR_FLIPPED = Integer.reverse(CRC32C_GENERATOR);

  public void testCrc32cByteTable() {

    val cookie =
      Cookie
        .Builder()
        .name("a")
        .value("b")
        .hostOnlyDomain("example.com")
        .expiresAt(date("1970-01-01T00:00:01.000+0000").time)
        .build()
    assertThat(cookie.toString()).isEqualTo("a=b; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/")
  }

  @Test fun builderClampsMinDate() {
    val cookie =
      Cookie
        .Builder()

OkHttp 4.x upgrades our implementation language from Java to Kotlin and keeps everything else the
same. We’ve chosen Kotlin because it gives us powerful new capabilities while integrating closely
with Java.

We spent a lot of time and energy on retaining strict compatibility with OkHttp 3.x. We’re even
keeping the package name the same: `okhttp3`!

There are three kinds of compatibility we’re tracking:

import org.jspecify.annotations.Nullable;

/**
 * Executor ensuring that all Runnables submitted are executed in order, using the provided
 * Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.

import org.jspecify.annotations.Nullable;

/**
 * Executor ensuring that all Runnables submitted are executed in order, using the provided
 * Executor, and sequentially such that no two will ever be running at the same time.
 *
 * <p>Tasks submitted to {@link #execute(Runnable)} are executed in FIFO order.
 *
 * <p>The execution of tasks is done by one thread as long as there are tasks left in the queue.

The same models are shared among requests, so, it's not one model per request, or one per user or something similar.

Let's imagine that loading the model can **take quite some time**, because it has to read a lot of **data from disk**. So you don't want to do it for every request.