import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import java.util.logging.Logger
import okhttp3.TestUtil.threadFactory

/**
 * Runs a [TaskRunner] in a controlled environment so that everything is sequential and
 * deterministic.
 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test

      }
    }
  }

  /**
   * Returns an immediately-executable task for the calling thread to execute, sleeping as necessary
   * until one is ready. If there are no ready queues, or if other threads have everything under
   * control this will return null. If there is more than a single task ready to execute immediately
   * this will start another thread to handle that work.
   */
  fun awaitTaskToRun(): Task? {

   * explicitly closed.
   */
  fun truncateLastFrame(length: Int): Http2Writer {
    val lastFrame = outFrames.removeAt(outFrames.size - 1)
    require(length < bytesOut.size - lastFrame.start)

    // Move everything from bytesOut into a new buffer.
    val fullBuffer = Buffer()
    bytesOut.read(fullBuffer, bytesOut.size)

    // Copy back all but what we're truncating.
    fullBuffer.read(bytesOut, lastFrame.start + length)

Upgrading to OkHttp 4
=====================

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:

     */
    int getMaxMpxCount();

    /**
     *
     * Property {@code jcifs.smb.client.signingPreferred} (boolean, default false)
     *
     * @return whether to enable SMB signing (for everything), if available
     */
    boolean isSigningEnabled();

    /**
     *
     * Property {@code jcifs.smb.client.ipcSigningEnforced} (boolean, default true)
     *

makes HTTP and HTTPS calls. It lets you specify which responses to return and
then verify that requests were made as expected.

Because it exercises your full HTTP stack, you can be confident that you're
testing everything. You can even copy & paste HTTP responses from your real web
server to create representative test cases. Or test that your code survives in
awkward-to-reproduce situations like 500 errors or slow-loading responses.

        dstIndex++;
        dst[dstIndex++] = (byte) (this.byteCount >> 8 & 0xFF);
        dstIndex += this.byteCount;

        /*
         * Normally, without intervention everything would batch
         * with everything else. If the below clause evaluates true
         * the andx command will not be written and therefore the
         * response will not read a batched command and therefore

        .body(gzip("abcabcabc"))
        .addHeader("Content-Encoding: gzip")
        .build(),
    )
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        // The network request has everything: User-Agent, Host, Accept-Encoding.
        val networkRequest = chain.request()
        assertThat(networkRequest.header("User-Agent")).isNotNull()
        assertThat(networkRequest.header("Host")).isEqualTo(

@DoNotMock("Use ImmutableList.of or another implementation")
@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization
// TODO(kevinb): I think we should push everything down to "BaseImmutableCollection" or something,
// just to do everything we can to emphasize the "practically an interface" nature of this class.
public abstract class ImmutableCollection<E> extends AbstractCollection<E> implements Serializable {
  /*

      Thread w = thread;
      if (w != null) {
        thread = null;
        LockSupport.unpark(w);
      }
    }
  }

  /*
   * Now that we've initialized everything else, we can run the initialization code for
   * ATOMIC_HELPER. That initialization code may log after we assign to ATOMIC_HELPER.
   */

  private static final AtomicHelper ATOMIC_HELPER;

  static {