* AtomicReferenceFieldUpdaterAtomicHelper, which would fail with a similar problem to
   * VarHandleAtomicHelperMaker, forcing us all the way to SynchronizedHelper.
   *
   * Additionally, it seems that nestmates do not help with runtime reflection under *Android*, even
   * when we use a newer -source and -target. That doesn't normally matter for AbstractFutureState,

   * AtomicReferenceFieldUpdaterAtomicHelper, which would fail with a similar problem to
   * VarHandleAtomicHelperMaker, forcing us all the way to SynchronizedHelper.
   *
   * Additionally, it seems that nestmates do not help with runtime reflection under *Android*, even
   * when we use a newer -source and -target. That doesn't normally matter for AbstractFutureState,

   * services will either be {@linkplain Service.State#TERMINATED terminated} or {@linkplain
   * Service.State#FAILED failed}.
   */
  public void awaitStopped() {
    state.awaitStopped();
  }

  /**
   * Waits for the all the services to reach a terminal state for no more than the given time. After

    private var done: Boolean = false

    /**
     * Prevents this editor from completing normally. This is necessary either when the edit causes
     * an I/O error, or if the target entry is evicted while this editor is active. In either case
     * we delete the editor's created files and prevent new files from being created. Note that once

   *     always a bug if {@code formal} isn't a type variable and contains no type variable. Make
   *     sure you are passing the two parameters in the right order.
   * @param actual The type that the formal type variable(s) are mapped to. It can be or contain yet
   *     other type variables, in which case these type variables will be further resolved if

        void testEquals() {
            testBlock.setMid(0x1234);

            TestServerMessageBlock other = new TestServerMessageBlock(mockConfig);
            other.setMid(0x1234);

            assertTrue(testBlock.equals(other));

            other.setMid(0x5678);
            assertFalse(testBlock.equals(other));

            assertFalse(testBlock.equals(null));

    // array slot is read and written exactly once. However, it can have very poor memory locality:
    // benchmarking shows it can take 7 times longer than the other two in some cases. The other two
    // do n swaps, minus a delta (0 or 2 for Reversal, gcd(d, n) for Successive), so that's about
    // twice as many reads and writes. But benchmarking shows that they usually perform better than

  // entry was, and adjusting index links accordingly.

  /**
   * The hashtable object. This can be either:
   *
   * <ul>
   *   <li>a byte[], short[], or int[], with size a power of two, created by
   *       CompactHashing.createTable, whose values are either
   *       <ul>
   *         <li>UNSET, meaning "null pointer"
   *         <li>one plus an index into the keys, values, and entries arrays

      "CallEnd",
    )
  }

  private fun assertBytesReadWritten(
    listener: RecordingEventListener,
    requestHeaderLength: Matcher<Long?>?,
    requestBodyBytes: Matcher<Long?>?,
    responseHeaderLength: Matcher<Long?>?,
    responseBodyBytes: Matcher<Long?>?,
  ) {
    if (requestHeaderLength != null) {
      val responseHeadersEnd = listener.removeUpToEvent<RequestHeadersEnd>()

   * <b>after</b> the returned {@code Future} is done: the future completes before closing starts,
   * rather than once it has finished.
   *
   * <p>After calling this method, you may not call {@link
   * #finishToValueAndCloser(ValueAndCloserConsumer, Executor)}, this method, or any other
   * derivation method on the original {@code ClosingFuture} instance.
   *