}
  }

  @Test
  fun fullCallTimeoutDoesNotApplyOnceConnected() {
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()
        .sendResponse("response A\n")
        .sleep(750, TimeUnit.MILLISECONDS)
        .sendResponse("response B\n")
        .receiveRequest("request C\n")
        .exhaustResponse()
        .exhaustRequest()
    server.enqueue(
      MockResponse

 *
 * As bytes are returned from upstream they are written to a local file. Downstream sources read
 * from this file as necessary.
 *
 * This class also keeps a small buffer of bytes recently read from upstream. This is intended to
 * save a small amount of file I/O and data copying.
 */
class Relay private constructor(
  /**

 * }
 *
 * <p>Even if your non-test code does not use finalization, you can use this class to test for
 * leaks, by ensuring that objects are no longer strongly referenced:
 *
 * {@snippet :
 * // Helper function keeps victim stack-unreachable.
 * private WeakReference<Foo> fooWeakRef() {
 *   Foo x = ....;
 *   WeakReference<Foo> weakRef = new WeakReference<>(x);
 *   // ... use x ...

      DerHeader(
        tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
        tag = DerHeader.TAG_END_OF_CONTENTS,
        constructed = false,
        length = -1L,
      )
  }

  /** A source that keeps track of how many bytes it's consumed. */
  private class CountingSource(
    source: Source,
  ) : ForwardingSource(source) {
    var bytesRead = 0L

    override fun read(
      sink: Buffer,

        mockBhv.setTestData(testData);

        relatedQueryHelper.update();
        // Give a moment for async execution
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // ignore
        }

        results = relatedQueryHelper.getRelatedQueries("test");
        assertEquals("updated", results[0]);
    }

 * }
 *
 * <p>Even if your non-test code does not use finalization, you can use this class to test for
 * leaks, by ensuring that objects are no longer strongly referenced:
 *
 * {@snippet :
 * // Helper function keeps victim stack-unreachable.
 * private WeakReference<Foo> fooWeakRef() {
 *   Foo x = ....;
 *   WeakReference<Foo> weakRef = new WeakReference<>(x);
 *   // ... use x ...

         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.
         * This avoids out-of-control memory consumption, and it keeps the cache from growing so
         * large that doing the lookup is noticeably slower than redoing the work would be.
         *
         * Ideally we'd have a real eviction policy, but until we see a problem in practice, I hope

                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Waiting threads: {}", waitingThreadNames);
                }
                ThreadUtil.sleep(systemCpuCheckInterval);
                current = getSystemCpuPercent();
            }
        } finally {
            waitingThreadNames.remove(threadName);
        }
        return true;
    }

     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**
     * Calculates the delay in milliseconds based on current time and configured rules.
     * The method checks each rule to see if it applies to the current time and day.
     *

   * elements.length) are all {@code null}.
   */
  @VisibleForTesting transient @Nullable Object @Nullable [] elements;

  /**
   * Keeps track of metadata like the number of hash table bits and modifications of this data
   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note