assertThat(read).isEqualTo(8192)

    // Make a second call that should transmit the response headers. The response body won't be
    // transmitted until the flow-control window is updated from the first request.
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.code).isEqualTo(200)

  private static final String E34 = "3-4";
  private static final String E44 = "4-4";
  private static final int NODE_COUNT = 20;
  private static final int EDGE_COUNT = 20;
  // TODO(user): Consider adding both error messages from here and {@link AbstractNetworkTest}
  // in one class (may be a utility class for error messages).
  private static final String ERROR_PARALLEL_EDGE = "connected by a different edge";

    assertThat(set.maxSize()).isEqualTo(max);
    assertThat(set.size()).isAtMost(max);
  }

  /**
   * A {@link Set} that throws {@link NullPointerException} and {@link ClassCastException} from
   * {@link #contains}.
   */
  private static final class SetContainsThrows extends AbstractSet<Void> {
    @Override
    public boolean contains(@Nullable Object o) {

          case 0:
            return first;
          case 1:
            return second;
          default:
            return rest[index - 2];
        }
      }
    };
  }

  // cloned from ImmutableCollection
  private static int expandedCapacity(int oldCapacity, int minCapacity) {
    if (minCapacity < 0) {
      throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");

  TF_Graph* g1 = TF_NewGraph();
  TF_Graph* g2 = TF_NewGraph();

  TF_Operation* feed = Placeholder(g1, s);
  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  // Attempt to create node in g2 with input from g1
  Neg(feed, g2, s);
  EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s));
  EXPECT_STREQ("foo", TF_Message(s));

  TF_DeleteGraph(g1);
  TF_DeleteGraph(g2);
  TF_DeleteStatus(s);
}
*/

   * already split off another thread to stream the request body. Because we permit at most one
   * exchange at a time we break the request stream out from under that writer.
   */
  @Test
  fun duplexWithRedirect() {
    enableProtocol(Protocol.HTTP_2)
    val duplexResponseSent = CountDownLatch(1)
    listener =
      object : RecordingEventListener() {

        bb.position(24); // Aligned position
        String path = "\\\\test";
        bb.put(path.getBytes(StandardCharsets.UTF_16LE));
        bb.putShort((short) 0);

        // Decode from position 1
        int decodedSize = referral.decode(testBuffer, 1, testBuffer.length - 1);

        // Verify
        assertEquals(34, decodedSize);
        assertEquals(path, referral.getRpath());
    }

        int result = response.readBytesWireFormat(buffer, bufferIndex);

        assertTrue(result >= 8);
        assertNotNull(response.getInfo());
    }

    @Test
    @DisplayName("Test inheritance from ServerMessageBlock2Response")
    void testInheritance() {
        response = new Smb2QueryInfoResponse(mockConfig, (byte) 1, (byte) 2);
        assertTrue(response instanceof ServerMessageBlock2Response);

		throttledHandler := gzippedHandler
		if !handlerFlags.has(noThrottleS3HFlag) {
			throttledHandler = maxClients(throttledHandler)
		}

		// Collect API stats using the API name got from reflection in
		// `getHandlerName`.
		statsCollectedHandler := collectAPIStats(handlerName, throttledHandler)

		// Call the final handler.
		statsCollectedHandler(w, r)
	}

	return handler
}

					ModTime:   baseTime.Add(90 * time.Minute).UnixNano(),
					Signature: [4]byte{6, 1, 1, 1},
					Type:      DeleteType,
					Flags:     0,
				}},
			},
		},
		// Delete marker and version from 1
		9: {
			versions: []xlMetaV2ShallowVersion{
				{header: xlMetaV2VersionHeader{
					VersionID: [16]byte{7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7},
					ModTime:   baseTime.Add(90 * time.Minute).UnixNano(),