}
  }

  private fun logEvent(e: ConnectionEvent) {
    if (e.connection != null) {
      assertThat(Thread.holdsLock(e.connection), "Called with lock $${e.connection}")
        .isFalse()
    }
    for (lock in forbiddenLocks) {
      assertThat(Thread.holdsLock(lock), "Called with lock $lock")
        .isFalse()
    }

    if (enforceOrder) {
      checkForStartEvent(e)
    }

          finishLine(true);
          start = pos + 1;
          break;

        default:
          // do nothing
      }
    }
    line.append(cbuf, start, off + len - start);
  }

  /** Called when a line is complete. */
  @CanIgnoreReturnValue
  private boolean finishLine(boolean sawNewline) throws IOException {
    String separator = sawReturn ? (sawNewline ? "\r\n" : "\r") : (sawNewline ? "\n" : "");

    // sanity check on construction of copyOfModifiedSet
    assertThat(wrappedSet).isEqualTo(copyOfModifiedSet);

    // setToTest should throw when it calls equals(), or equals is called on it, except for itself
    assertThat(setToTest).isEqualTo(setToTest);
    assertThrows(IllegalStateException.class, () -> setToTest.equals(wrappedSet));

          executor.execute(
              () -> {
                try {
                  startUp();
                  notifyStarted();
                  // If stopAsync() is called while starting we may be in the STOPPING state in
                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {

        assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ), "Should have local read access");
        assertTrue(region.hasAccess(RdmaAccess.REMOTE_READ), "Should have remote read access");

        // Verify provider was called
        verify(mockProvider, atLeastOnce()).registerMemory(any(ByteBuffer.class), any());
    }

    @Test
    public void testReleaseSendRegion() throws Exception {

	if !ok {
		return nil, nil, fmt.Errorf("response writer does not support hijacking. Type is %T", lrw.ResponseWriter)
	}
	return hj.Hijack()
}

// TTFB of the request - this function needs to be called
// when the request is finished to provide accurate data
func (lrw *ResponseRecorder) TTFB() time.Duration {
	if lrw.ttfbBody != 0 {
		return lrw.ttfbBody
	}
	return lrw.ttfbHeader
}

  @Override
  final UnmodifiableIterator<Cell<R, C, V>> cellIterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  final Spliterator<Cell<R, C, V>> cellSpliterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  public ImmutableCollection<V> values() {
    return (ImmutableCollection<V>) super.values();
  }

If we want to call asynchronous functions in our tests, our test functions have to be asynchronous. AnyIO provides a neat plugin for this, that allows us to specify that some test functions are to be called asynchronously.

## HTTPX { #httpx }

Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath.

Interceptors can be chained. Suppose you have both a compressing interceptor and a checksumming interceptor: you'll need to decide whether data is compressed and then checksummed, or checksummed and then compressed. OkHttp uses lists to track interceptors, and interceptors are called in order.

   * network include {@code node}.
   *
   * <p>This is equal to the union of {@link #inEdges(Object)} and {@link #outEdges(Object)}.
   *
   * <p>If {@code node} is removed from the network after this method is called, the {@code Set}
   * {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>