// Test basic buffer allocation
            RdmaMemoryRegion sendRegion = bufferManager.getSendRegion(4096);
            assertNotNull(sendRegion, "Send region should not be null");
            assertTrue(sendRegion.getSize() >= 4096, "Send region should be at least 4KB");
            assertNotNull(sendRegion.getBuffer(), "Send region buffer should not be null");

            buffer.putInt(4096);
            byte[] bufferArray = buffer.array();

            // When
            int bytesConsumed = fileFsFullSizeInfo.decode(bufferArray, 10, 32);

            // Then
            assertEquals(32, bytesConsumed);
            assertEquals(2048L * 4 * 4096, fileFsFullSizeInfo.getCapacity());
            assertEquals(1024L * 4 * 4096, fileFsFullSizeInfo.getFree());
        }

    @Test
    public void testReturnFromReadParameterWordsWireFormatIs8() {
        // ensure the method returns 8 as claimed
        byte[] buf = new byte[12];
        buf[0] = 0x00;
        buf[1] = 0x10; // count = 4096 in little-endian (0x1000)
        int returned = resp.readParameterWordsWireFormat(buf, 0);
        assertEquals(8, returned, "Method should return 8 bytes processed");
    }

        // Prepare buffer with invalid ACE count (> 4096)
        prepareSecurityDescriptorBufferWithInvalidAceCount(testBuffer, 0);

        assertThrows(SMBProtocolDecodingException.class, () -> securityDescriptor.decode(testBuffer, 0, testBuffer.length),
                "Should throw exception for ACE count > 4096");
    }

    @Test
    @DisplayName("Test getType returns correct value")

import okio.Buffer

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(

        this.maxReferralLevel = maxReferralLevel;
        this.request = new DfsReferralRequestBuffer(filename, maxReferralLevel);
        this.totalDataCount = 0;
        this.maxParameterCount = 0;
        this.maxDataCount = 4096;
        this.maxSetupCount = (byte) 0x00;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#isForceUnicode()
     */
    @Override

        FileFsFullSizeInformation info = (FileFsFullSizeInformation) response.getInfo();
        assertEquals(2000000L * 16L * 4096L, info.getCapacity());
        assertEquals(800000L * 16L * 4096L, info.getFree()); // This is caller available allocation units
    }

    @Test
    void testReadDataWireFormat_UnsupportedInformationLevel() throws Exception {

        void testConstructorWithValidParameters() {
            // Given
            long sourceOffset = 1024L;
            long targetOffset = 2048L;
            int length = 4096;

            // When
            SrvCopychunk chunk = new SrvCopychunk(sourceOffset, targetOffset, length);

            // Then
            assertNotNull(chunk);
        }

        @ParameterizedTest

 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})
     * @return a {@link FileInputStream} to read from the file

    assumeTrue(provider.isAvailable());
    
    ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
    RdmaMemoryRegion region = provider.registerMemory(buffer, 
        EnumSet.of(RdmaAccess.LOCAL_READ, RdmaAccess.REMOTE_READ));
    
    assertNotNull(region);
    assertEquals(4096, region.getSize());
    assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ));
    
    region.close();
}

@Test