void shouldReturnCorrectBytesConsumed() throws SMBProtocolDecodingException {
            // Given - larger buffer than needed
            byte[] buffer = new byte[100];
            ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);
            bb.putLong(1000L);
            bb.putLong(500L);
            bb.putInt(8);
            bb.putInt(512);

            // When

    private final Object connectionLock = new Object();

    /**
     * Creates a new RDMA transport wrapping the given delegate transport.
     *
     * @param delegate the underlying SMB transport to wrap
     * @param context the CIFS context for configuration
     */
    public RdmaTransport(SmbTransportInternal delegate, CIFSContext context) {
        this.delegate = delegate;

        assertNotNull(conn);
        assertTrue(conn instanceof SmbFile, "Connection should be an instance of SmbFile");
        SmbFile file = (SmbFile) conn;
        assertEquals(url, file.getURL(), "Returned SmbFile should wrap the given URL");
        assertSame(mockCtx, file.getContext(), "SmbFile must use the provided CIFSContext");
        verify(mockCtx, atLeastOnce()).getConfig(); // interaction with dependency
    }

    @Test

      addressAsLong = getEmbeddedIPv4ClientAddress(ip6).hashCode();
    } else {
      // Just extract the high 64 bits (assuming the rest is user-modifiable).
      addressAsLong = ByteBuffer.wrap(ip6.getAddress(), 0, 8).getLong();
    }

    // Many strategies for hashing are possible. This might suffice for now.
    int coercedHash = Hashing.murmur3_32_fixed().hashLong(addressAsLong).asInt();

    assertThat(formEncode(128)).isEqualTo("%C2%80")
    assertThat(formEncode(255)).isEqualTo("%C3%BF")
  }

  @Throws(IOException::class)
  private fun formEncode(codePoint: Int): String {
    // Wrap the codepoint with regular printable characters to prevent trimming.
    val body =
      FormBody
        .Builder()
        .add("a", String(intArrayOf('b'.code, codePoint, 'c'.code), 0, 3))
        .build()

        T value = entry.getValue();
        mapBuilder.put(type, cast(type, value));
      }
      return this;
    }

    private static <T> T cast(Class<T> type, Object value) {
      return Primitives.wrap(type).cast(value);
    }

    /**
     * Returns a new immutable class-to-instance map containing the entries provided to this
     * builder.
     *

		wantEncryption := crypto.Requested(r.Header)
		s2c, cb := newS2CompressReader(reader, actualSize, wantEncryption)
		dstOpts.IndexCB = cb
		defer s2c.Close()
		reader = etag.Wrap(s2c, reader)
		length = -1
	} else {
		delete(srcInfo.UserDefined, ReservedMetadataPrefix+"compression")
		delete(srcInfo.UserDefined, ReservedMetadataPrefix+"actual-size")
		reader = gr
	}

    checkNotNull(byteArray);
    checkArgument(
        byteArray.length == BYTES,
        "Expected PairedStats.BYTES = %s, got %s",
        BYTES,
        byteArray.length);
    ByteBuffer buffer = ByteBuffer.wrap(byteArray).order(ByteOrder.LITTLE_ENDIAN);
    Stats xStats = Stats.readFrom(buffer);
    Stats yStats = Stats.readFrom(buffer);
    double sumOfProductsOfDeltas = buffer.getDouble();

  val listener = RecordingEventListener()
  var client =
    clientTestRule
      .newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20
    dispatcher.maxRequestsPerHost = 10
    listener.forbidLock(dispatcher)
  }

  @Test
  fun maxRequestsZero() {

/** Benchmarks for {@link ExecutionList}. */
@VmOptions({"-Xms8g", "-Xmx8g"})
@NullUnmarked
public class ExecutionListBenchmark {
  private static final int NUM_THREADS = 10; // make a param?

  // simple interface to wrap our two implementations.
  interface ExecutionListWrapper {
    void add(Runnable runnable, Executor executor);

    void execute();

    /** Returns the underlying implementation, useful for the Footprint benchmark. */