.build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) {
        Headers responseHeaders = response.headers();
        for (int i = 0; i < responseHeaders.size(); i++) {
          System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
        }

        throw new IOException("Unexpected code " + response);
      }

    ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create();
    multimap.put("foo", 1);
    multimap.put("foo", 2);
    multimap.put("bar", 3);
    multimap.trimToSize();
    assertEquals(3, multimap.size());
    assertThat(multimap.get("foo")).containsExactly(1, 2).inOrder();
    assertThat(multimap.get("bar")).contains(3);
  }

    ms.add(Color.BLUE, 3);
    ms.add(Color.YELLOW, 1);
    ms.add(Color.RED, 2);

    Set<Object> uniqueEntries = Sets.newIdentityHashSet();
    uniqueEntries.addAll(ms.entrySet());
    assertEquals(3, uniqueEntries.size());
  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).
  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.

    // This is an extremely fast implementation of BigInteger.doubleValue(). JDK patch pending.
    BigInteger absX = x.abs();
    int exponent = absX.bitLength() - 1;
    // exponent == floor(log2(abs(x)))
    if (exponent < Long.SIZE - 1) {
      return x.longValue();
    } else if (exponent > MAX_EXPONENT) {
      return x.signum() * POSITIVE_INFINITY;
    }

    /*

            final StringBuilder readingBuf = new StringBuilder(text.length());
            if (readingTokenList != null && termTokenList != null) {
                int offset = 0;
                for (int i = 0; i < readingTokenList.size(); i++) {
                    final String term = termTokenList.get(i).getTerm();
                    String reading = readingTokenList.get(i).getTerm();
                    if (Strings.isNullOrEmpty(reading)) {

     *
     * @return Array of all registered SSO authenticators
     */
    public SsoAuthenticator[] getAuthenticators() {
        return authenticatorList.toArray(new SsoAuthenticator[authenticatorList.size()]);
    }

    /**
     * Registers an SSO authenticator with this manager.
     *
     * @param authenticator The SSO authenticator to register
     */

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }

    assertEquals(2, sessionIds.size)
    assertNotEquals(sessionIds[0], sessionIds[1])
    assertThat(sessionIds[0]).isNotEmpty()
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(

    client
      .newCall(request)
      .execute()
      .use { response ->
        if (!response.isSuccessful) {
          val responseHeaders = response.headers
          for (i in 0 until responseHeaders.size) {
            println(responseHeaders.name(i) + ": " + responseHeaders.value(i))
          }
          throw IOException("Unexpected code $response")
        }
        println(response.body.string())

     * @return true if persistent
     */
    public boolean isPersistent() {
        return (flags & Smb2HandleCapabilities.SMB2_DHANDLE_FLAG_PERSISTENT) != 0;
    }

    @Override
    public int size() {
        // Context header (16) + name length (4) + padding to 8-byte alignment (4) + data (32)
        return 16 + 4 + 4 + STRUCTURE_SIZE;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {

        //     throw new RuntimeException("Failed to register memory region", e);
        // }

        this.memoryRegister = new Object(); // Placeholder

        log.debug("DiSNI memory region registered, size: {}", buffer.remaining());
    }

    @Override
    public void invalidate() {
        if (valid && memoryRegister != null) {
            try {