buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)
        buffer.putShort((short) 50); // maxMpxCount
        buffer.putShort((short) 10); // maxNumberVcs
        buffer.putInt(8192); // maxBufferSize
        buffer.putInt(65536); // maxRawSize
        buffer.putInt(123456789); // sessionKey
        buffer.putInt(SmbConstants.CAP_UNICODE | SmbConstants.CAP_NT_SMBS); // capabilities

        testFileId = new byte[16];
        Arrays.fill(testFileId, (byte) 0xAB);

        // Use lenient stubbing for default configuration values
        lenient().when(mockConfig.getNotifyBufferSize()).thenReturn(8192);
        lenient().when(mockContext.getConfig()).thenReturn(mockConfig);

        request = new Smb2ChangeNotifyRequest(mockConfig, testFileId);
    }

    @Test

	ADDW	R1, R2                // 1a21
	ADDW	R1, R2, R3            // b9f81032
	ADDW	$8192, R1             // a71a2000
	ADDW	$8192, R1, R2         // ec21200000d8
	ADDE	R1, R2                // b9880021
	SUB	R3, R4                // b9090043
	SUB	R3, R4, R5            // b9e93054
	SUB	$8192, R3             // a73be000
	SUB	$8192, R3, R4         // ec43e00000d9
	SUBC	R1, R2                // b90b0021

        // Test default values
        assertFalse(config.isUseRDMA(), "RDMA should be disabled by default");
        assertEquals("auto", config.getRdmaProvider(), "Default provider should be auto");
        assertEquals(8192, config.getRdmaReadWriteThreshold(), "Default threshold should be 8KB");
        assertEquals(65536, config.getRdmaMaxSendSize(), "Default max send size should be 64KB");

            int bytesDecoded = localResponse.decode(buffer, offset, responseData.length);

            assertEquals(12, bytesDecoded);
            assertEquals(7, localResponse.getChunksWritten());
            assertEquals(8192, localResponse.getChunkBytesWritten());
            assertEquals(57344, localResponse.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should decode minimum buffer size")

    void testBufferConfigurationDelegation() {
        // Given
        when(mockDelegate.getSendBufferSize()).thenReturn(8192);
        when(mockDelegate.getReceiveBufferSize()).thenReturn(8192);
        when(mockDelegate.getMaximumBufferSize()).thenReturn(65536);
        when(mockDelegate.getTransactionBufferSize()).thenReturn(65024);

        assertEquals(3000, info.alloc);
        assertEquals(1500, info.free);
        assertEquals(4, info.sectPerAlloc);
        assertEquals(8192, info.bytesPerSect);
        assertEquals(3000L * 4 * 8192, info.getCapacity(), "Capacity calculation should be correct");
        assertEquals(1500L * 4 * 8192, info.getFree(), "Free space calculation should be correct");
    }

    /**

        assertTrue(transaction.maxParameterCount > 0);
    }

    @Test
    @DisplayName("Test setMaxBufferSize")
    void testSetMaxBufferSize() {
        transaction.setMaxBufferSize(8192);
        assertEquals(8192, transaction.maxBufferSize);
    }

    @Test
    @DisplayName("Test setMaxDataCount")
    void testSetMaxDataCount() {
        transaction.setMaxDataCount(4096);

	lru.Add("key3", 3)
	time.Sleep(time.Second * 3)
	if lru.Cap() != 0 {
		t.Errorf("Expected lru to be empty, but it was not")
	}

}

func BenchmarkLRU_Rand_NoExpire(b *testing.B) {
	l := lru.NewLRU[int64, int64](8192, nil, 0)

	trace := make([]int64, b.N*2)
	for i := 0; i < b.N*2; i++ {
		trace[i] = getRand(b) % 32768
	}

	b.ResetTimer()

	var hit, miss int
	for i := 0; i < 2*b.N; i++ {
		if i%2 == 0 {

    void getSendBufferSize_returns() throws Exception {
        // Arrange
        when(handle.getSendBufferSize()).thenReturn(8192);

        // Act
        int size = handle.getSendBufferSize();

        // Assert
        assertEquals(8192, size);
        verify(handle).getSendBufferSize();
    }

    @Test
    @DisplayName("getSendBufferSize(): propagates CIFSException on failure")