// large aligned offset, use two instructions(add+ldr/str).
	MOVB	R1, 0x1001(R2) 		// MOVB		R1, 4097(R2)		// 5b04409161070039
	MOVB	R1, 0xffffff(R2)	// MOVB		R1, 16777215(R2)	// 5bfc7f9161ff3f39
	MOVH	R1, 0x2002(R2)		// MOVH		R1, 8194(R2)		// 5b08409161070079
	MOVH	R1, 0x1000ffe(R2)	// MOVH		R1, 16781310(R2)	// 5bfc7f9161ff3f79
	MOVW	R1, 0x4004(R2)		// MOVW		R1, 16388(R2)		// 5b104091610700b9
	MOVW	R1, 0x1002ffc(R2)	// MOVW		R1, 16789500(R2)	// 5bfc7f9161ff3fb9

        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

        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

        // 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");

done
DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"

# Increase the V8 stack size from the default of 984K
# to 8192K to ensure all tests can pass without hitting
# stack size limits.

            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")

        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 {

/**
 * Transformed artifact is derived with some transformation from source artifact.
 *
 * @since TBD
 */
class TransformedArtifact extends DefaultArtifact {

    private static final int SHA1_BUFFER_SIZE = 8192;
    private final PomArtifactTransformer pomArtifactTransformer;
    private final MavenProject project;
    private final Supplier<ModelSource> sourcePathProvider;
    private final Path target;

        writeInt8(1500, buffer, 8); // caller available allocation units
        writeInt8(1500, buffer, 16); // actual free units (skipped)
        writeInt4(4, buffer, 24); // sectors per allocation unit
        writeInt4(8192, buffer, 28); // bytes per sector

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(32, bytesRead, "Should read 32 bytes");