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

				},
				"Policy": []string{"policy"},
			},
			expected: ErrNone,
		},
	}

	// Run each test case individually.
	for i, testCase := range testCases {
		_, code := doesPolicySignatureMatch(testCase.form)
		if code != testCase.expected {
			t.Errorf("(%d) expected to get %s, instead got %s", i, niceError(testCase.expected), niceError(code))
		}
	}
}

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

	if [ "${sum1_heal}" != "${sum1}" ]; then
		echo "mismatch expected ${sum1_heal}, got ${sum1}"
		exit 1
	fi
}

verify_checksum_mc() {
	local expected
	expected=$(mc cat "$1" | sha256sum)
	local got
	got=$(mc cat "$2" | sha256sum)

	if [ "${expected}" != "${got}" ]; then
		echo "mismatch - expected ${expected}, got ${got}"
		exit 1
	fi
	echo "matches - ${expected}, got ${got}"
}

add_alias() {

			if err != nil && testCase.success {
				t.Errorf("Expected success but failed instead %s", err)
			}
			if err == nil && !testCase.success {
				t.Errorf("Expected failure but passed instead")
			}
			if !reflect.DeepEqual(testCase.indexes, gotIndexes) {
				t.Errorf("Expected %v, got %v", testCase.indexes, gotIndexes)
			}
		})
	}
}