// until any memory allocated from it is no longer needed.
//
// An Arena must never be used concurrently by multiple goroutines.
type Arena struct {
	a unsafe.Pointer
}

// NewArena allocates a new arena.
func NewArena() *Arena {
	return &Arena{a: runtime_arena_newArena()}
}

// Free frees the arena (and all objects allocated from the arena) so that

        assertSame(c, second, "Second get should return second cached buffer");
        assertNotSame(d, third, "Third get should allocate a new buffer (not the dropped one)");
        assertEquals(3, third.length, "Allocated buffer length matches configured maximum size");
    }

    // Parameterized: exercise small variations of cache size for a simple reuse cycle
    @ParameterizedTest

  }

  fun assertRequests(vararg expectedHosts: String?) {
    assertThat(requestedHosts).containsExactly(*expectedHosts)
    requestedHosts.clear()
  }

  /** Allocates and returns `count` fake IPv4 addresses like [255.0.0.100, 255.0.0.101].  */
  fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {

     * Test that buffer cache handles allocation when cache is full.
     */
    @Test
    public void testBufferAllocationWhenCacheFull() {
        // Given - Allocate many buffers to potentially fill the cache
        List<byte[]> buffers = new ArrayList<>();

        // Allocate more buffers than cache can hold
        for (int i = 0; i < 20; i++) {
            byte[] buffer = BufferCache.getBuffer();

        // Allocate regions larger than pool buffer size to force new allocations
        RdmaMemoryRegion region1 = bufferManager.getSendRegion(131072); // 128KB > 64KB pool size
        RdmaMemoryRegion region2 = bufferManager.getSendRegion(131072); // Another large allocation

        assertTrue(bufferManager.getTotalAllocated() > initialAllocated, "Total allocated should increase");

  }

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {

    CharBuffer buf2 = CharBuffer.allocate(expected.length());
    assertEquals(expected.length() == 0 ? -1 : expected.length(), reader.read(buf2));
    Java8Compatibility.flip(buf2);
    assertEquals(expected, buf2.toString());
    assertFullyRead(reader);

    // read in chunks to fixed CharBuffer
    reader = new CharSequenceReader(charSequence);
    buf2 = CharBuffer.allocate(5);
    builder = new StringBuilder();

        response = new SmbComNegotiateResponse(serverData);
    }

    @Test
    void testReadParameterWordsWireFormat() {
        // Prepare a byte array with sample parameter words
        ByteBuffer buffer = ByteBuffer.allocate(34);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short) 0); // dialectIndex
        buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)

	if err != nil {
		b.Fatal(err)
	}

	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
	b.ReportAllocs()
	// the actual benchmark for PutObject starts here. Reset the benchmark timer.
	b.ResetTimer()

	if err := req.ParseForm(); err != nil {
		b.Fatal(err)
	}

    private final int pointer;

    /**
     * Constructs a new PacUnicodeString instance.
     *
     * @param length the actual length of the string in bytes
     * @param maxLength the maximum allocated length for the string in bytes
     * @param pointer the pointer/offset to the string data
     */
    public PacUnicodeString(final short length, final short maxLength, final int pointer) {
        this.length = length;