Date expected4 = new Date();
        doc.put("key4", expected4);
        assertEquals(expected4, DocumentUtil.getValue(doc, "key4", Date.class));
    }

    public void test_long() {
        Map<String, Object> doc = new HashMap<>();

        long expected5 = 999999999999999999L;
        doc.put("key5", expected5);

	if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) {
		t.Fatalf("value differs from expected")
	}

	if lc.Resize(0) != 0 {
		t.Fatalf("evicted count differs from expected")
	}
	if lc.Resize(2) != 0 {
		t.Fatalf("evicted count differs from expected")
	}
	lc.Add("key2", "val2")
	if lc.Resize(1) != 1 {
		t.Fatalf("evicted count differs from expected")
	}
}

func TestLRUEdgeCases(t *testing.T) {

	VSOXEI8V	V3, X11, V0, (X10)		// ERROR "expected vector register in vs2 position"
	VL1RV		(X10), X10			// ERROR "expected vector register in vd position"
	VL1RV		(V1), V3			// ERROR "expected integer register in rs1 position"
	VS1RV		X11, (X11)			// ERROR "expected vector register in vs1 position"
	VS1RV		V3, (V1)			// ERROR "expected integer register in rd position"

    }

    @Test
    void testReadString_Oem() {
        response.useUnicode = false;
        String expected = "test";
        // Simulate OEM encoding with a null terminator
        byte[] src = (expected + "\0").getBytes(StandardCharsets.UTF_8);
        String result = response.readString(src, 0, src.length);
        // The method should remove the null terminator

        String expected = "[testParam, [value1, value2]]";
        assertEquals(expected, param.toString());
    }

    public void test_toString_withNullName() {
        // Test toString with null name
        String[] values = { "value1" };
        RequestParameter param = new RequestParameter(null, values);

        String expected = "[null, [value1]]";

    @MethodSource("encodeProvider")
    void testEncode(byte[] input, String expected) {
        // Arrange & Act
        String actual = Base64.encode(input);
        // Assert
        assertEquals(expected, actual, "Base64.encode should match expected string");
    }

    /**
     * Data provider for Base64 strings and expected decoded byte arrays.
     */
    static Stream<Arguments> decodeProvider() {

        byte[] expected = new byte[1 + dirName.length() + 1];
        expected[0] = 0x04; // buffer format
        System.arraycopy(dirName.getBytes(), 0, expected, 1, dirName.length());
        expected[dirName.length() + 1] = 0x00; // null terminator

        byte[] dst = new byte[100];
        int len = sdd.writeBytesWireFormat(dst, 0);

        assertEquals(expected.length, len);

			t.Errorf("%s: Expected the object name to be `%s`, but instead found `%s`", instanceType, "newPrefix", result.Objects[0].Name)
		}
		if result.Objects[1].Name != "newPrefix2" {
			t.Errorf("%s: Expected the object name to be `%s`, but instead found `%s`", instanceType, "newPrefix", result.Objects[1].Name)
		}
		if result.Objects[2].Name != "obj0" {

      for (RoundingMode mode : ALL_SAFE_ROUNDING_MODES) {
        BigDecimal expected = new BigDecimal(d).setScale(0, mode);
        boolean isInBounds =
            expected.compareTo(MAX_INT_AS_BIG_DECIMAL) <= 0
                & expected.compareTo(MIN_INT_AS_BIG_DECIMAL) >= 0;

        try {
          assertEquals(expected.intValue(), DoubleMath.roundToInt(d, mode));
          assertTrue(isInBounds);

		}
		// Failed as expected, but does it fail for the expected reason.
		if actualErr != nil && !testCase.shouldPass {
			if testCase.expectedError.Error() != actualErr.Error() {
				t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but instead failed with error \"%s\" instead.", i+1, instanceType, testCase.expectedError.Error(), actualErr.Error())
			}
		}
		// Test passes as expected, but the output values are verified for correctness here.