void testCompleteFlow() {
        request = new Smb2SetInfoRequest(mockConfig);

        // Set all fields
        byte[] newFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            newFileId[i] = (byte) (0xFF - i);
        }
        request.setFileId(newFileId);
        request.setInfoType((byte) 0x02);
        request.setFileInfoClass((byte) 0x08);
        request.setAdditionalInformation(0xABCDEF00);

        .addHeader("h2", "v2")
        .socketHandler(body)
        .build(),
    )
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .method("POST", AsyncRequestBody())
        .build()
    val call = client.newCall(request)
    call.execute().use { response ->
      val sink = (request.body as AsyncRequestBody?)!!.takeSink()
      sink.writeUtf8("hey\n")

        .newBuilder()
        .addInterceptor(Interceptor { throw IOException() })
        .build()
    val request = Request.Builder().url(server.url("/")).build()
    c.newCall(request).enqueue(callback)
    val response = callback.await(request.url)
    assertThat(response.request).isEqualTo(request)
  }

  @Test
  fun reusedSinksGetIndependentTimeoutInstances() {
    server.enqueue(MockResponse())

indexer.webfs.max.document.cache.size=10
# Maximum document request size (bytes) for webfs in the indexer.
indexer.webfs.max.document.request.size=1048576
# Maximum document cache size for data in the indexer.
indexer.data.max.document.cache.size=10000
# Maximum document request size (bytes) for data in the indexer.
indexer.data.max.document.request.size=1048576
# Maximum delete cache size for data in the indexer.

        DefaultProjectBuildingRequest request = new DefaultProjectBuildingRequest();

        request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0);
        request.setResolveDependencies(false);

        request.setLocalRepository(configuration.getLocalRepository());
        request.setBuildStartTime(configuration.getBuildStartTime());
        request.setUserProperties(configuration.getUserProperties());

    }

    /**
     * Reads text from the given {@link Reader}.
     * <p>
     * The {@link Reader} is not closed by this method.
     * </p>
     *
     * @param reader
     *            the character input stream to read from (must not be {@literal null})
     * @return the text read from the reader
     */
    public static String readText(final Reader reader) {
        assertArgumentNotNull("reader", reader);

      }

      override fun fromDer(reader: DerReader): Any? {
        if (isOptional && !reader.hasNext()) return optionalValue

        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")
        for ((_, adapter) in choices) {
          if (adapter.matches(peekedHeader)) {
            return adapter.fromDer(reader)
          }
        }

```java
class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    logger.info(String.format("Sending request %s on %s%n%s",
        request.url(), chain.connection(), request.headers()));

        // Test that the constructor correctly initializes questionName and questionType
        NameQueryRequest request = new NameQueryRequest(mockConfig, mockName);

        assertNotNull(request);
        assertEquals(mockName, request.questionName);
        assertEquals(NameServicePacket.NB, request.questionType);
    }

    @Test
    void testWriteBodyWireFormat() {

        }
      }

    // Make the first request waiting until we get our auth challenge.
    val request = Request(server.url("/"))
    blockingAuthClient.newCall(request).enqueue(callback)
    val response1 = responses.take()
    assertThat(response1).isEqualTo("")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)