fun networkInterceptorThrowsRuntimeExceptionAsynchronous() {
    interceptorThrowsRuntimeExceptionAsynchronous(true)
  }

  /**
   * When an interceptor throws an unexpected exception, asynchronous calls are canceled. The
   * exception goes to the uncaught exception handler.
   */
  private fun interceptorThrowsRuntimeExceptionAsynchronous(network: Boolean) {
    val boom = RuntimeException("boom!")

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) = logEvent(CallFailed(System.nanoTime(), call, ioe))

  override fun canceled(call: Call) = logEvent(Canceled(System.nanoTime(), call))

  override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) = logEvent(SatisfactionFailure(System.nanoTime(), call))

  internal var activeTask: Task? = null

  /** Scheduled tasks ordered by [Task.nextExecuteNanoTime]. */
  internal val futureTasks = mutableListOf<Task>()

  /** True if the [activeTask] should be canceled when it completes. */
  internal var cancelActiveTask = false

  /**
   * Returns a snapshot of tasks currently scheduled for execution. Does not include the

    logWithTime("callEnd")
  }

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")
  }

  override fun canceled(call: Call) {
    logWithTime("canceled")
  }

  override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) {
    logWithTime("satisfactionFailure: $response")
  }

  override fun cacheHit(

 * Prefer to alternate IP addresses from different address families, (IPv6 / IPv4), starting with IPv6.
 * Don't start a new attempt until 250 ms after the most recent attempt was started.
 * Keep whichever TCP connection succeeds first and cancel all the others.

Calls can be canceled from any thread. This will fail the call if it hasn’t yet completed! Code that is writing the request body or reading the response body will suffer an `IOException` when its call is canceled.

## Dispatch

      printEvent("callEnd");
    }

    @Override public void callFailed(Call call, IOException ioe) {
      printEvent("callFailed");
    }

    @Override public void canceled(Call call) {
      printEvent("canceled");
    }
  }

 *  Fix: Attempt to read the response body even if the server canceled the request. This will cause
    some calls to return nice error codes like `HTTP/1.1 429 Too Many Requests` instead of transport
    errors like `SocketException: Connection reset` and `StreamResetException: stream was reset:
    CANCEL`.
 *  New: Support OSGi metadata.
 *  Upgrade: [Okio 2.9.0][okio_2_9_0].

    ```kotlin

            constructor.setAccessible(true);
            SmbComNtCancel cancel = constructor.newInstance(config, testMid);

            // Then
            assertNotNull(cancel);
            assertEquals(testMid, cancel.getMid());
            assertTrue(cancel.isCancel());
        }
    }

    @Nested
    @DisplayName("Method Behavior Tests")

    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {
    assertThat(future.cancel(false /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, false);
  }

  public void testInterrupted() throws Exception {
    assertThat(future.cancel(true /* mayInterruptIfRunning */)).isTrue();
    assertCancelled(future, true);
  }