******@****.***()
      }
    }.apply {
      timeout(client.callTimeoutMillis.toLong(), MILLISECONDS)
    }

  private val executed = AtomicBoolean()

  // These properties are only accessed by the thread executing the call.

  /** Initialized in [callStart]. */
  private var callStackTrace: Any? = null

  /** Finds an exchange to send the next request and receive the next response. */

 *  Fix: Don't crash when the URL hostname contains an underscore on Android.
 *  Fix: Change HTTP/2 to use a daemon thread for its socket reader. If you've ever seen a command
    line application hang after all of the work is done, it may be due to a non-daemon thread like
    this one.
 *  New: Include suppressed exceptions when all routes to a target service fail.


## Version 4.4.1

_2020-03-08_

    val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)
    sink.writeUtf8("abcdefghij")
    Thread.sleep(500)
    sink.writeUtf8("klmnopqrst")
    sink.close()
    assertThat<ByteString>(future1.get())
      .isEqualTo("abcdefghijklmnopqrst".encodeUtf8())

    call: Call,
    delay: Long,
  ): Thread {
    val thread =
      object : Thread("canceler") {
        override fun run() {
          try {
            sleep(delay)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          call.cancel()
        }
      }
    thread.start()
    return thread
  }

    assertThat(recordedRequest!!.method).isEqualTo("GET")
    assertThat(recordedRequest.path).isEqualTo(
      "/lookup?ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ",
    )
    Thread.sleep(2000)
    server.enqueue(
      dnsResponse(
        "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c000500010" +

   * cache size. The application needs to be aware of calling this function during the
   * initialization phase and preferably in a background worker thread.
   *
   * Note that if the application chooses to not call this method to initialize the cache. By
   * default, OkHttp will perform lazy initialization upon the first usage of the cache.
   */

            coordinatorWaiting = false
          }
        }
      }
    }
  }

  /** Start another thread, unless a new thread is already scheduled to start. */
  private fun startAnotherThread() {
    lock.assertHeld()
    if (executeCallCount > runCallCount) return // A thread is still starting.

    executeCallCount++
    backend.execute(this@TaskRunner, runnable)
  }

      throw AssertionError("Thread ${Thread.currentThread().name} MUST hold lock on $this")
    }
  }

  @Suppress("NOTHING_TO_INLINE")
  internal inline fun Any.assertThreadDoesntHoldLock() {
    if (assertionsEnabled && taskRunner.lock.isHeldByCurrentThread) {
      throw AssertionError("Thread ${Thread.currentThread().name} MUST NOT hold lock on $this")
    }
  }

    assertThat(realTaskRunner.activeQueues()).isNotEmpty()
    Thread.sleep(100)
    val threads = arrayOfNulls<Thread>(Thread.activeCount() * 2)
    Thread.enumerate(threads)
    for (t in threads) {
      if (t != null && t.name == "OkHttp TaskRunner") {
        t.interrupt()
      }
    }
    Thread.sleep(100)
    assertThat(realTaskRunner.activeQueues()).isEmpty()
  }

  }

  private fun makeSynchronousCall(call: Call): Thread {
    val thread =
      Thread {
        try {
          call.execute()
          throw AssertionError()
        } catch (expected: IOException) {
        }
      }
    thread.start()
    return thread
  }

  private fun newRequest(url: String): Request {
    return Request.Builder().url(url).build()