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

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

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

      }
    }
  }

  public void testDivideByZeroThrows() {
    for (long a : TEST_LONGS) {
      assertThrows(
          ArithmeticException.class,
          () -> UnsignedLong.fromLongBits(a).dividedBy(UnsignedLong.ZERO));
    }
  }

  public void testMod() {
    for (long a : TEST_LONGS) {
      for (long b : TEST_LONGS) {
        if (b != 0) {
          UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);

        byte[] buffer = new byte[10];
        // Should throw exception when buffer is too small
        assertThrows(IllegalStateException.class, () -> hmac.engineDigest(buffer, 0, 10));
    }

    @Test
    void testClone() {
        // Test clone() method
        HMACT64 originalHmac = new HMACT64(TEST_KEY);
        originalHmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length / 2);

        try {
            labelTypeHelper.init();
        } catch (Exception e) {
            fail("init() should not throw an exception: " + e.getMessage());
        }
    }

    @Test
    public void test_load() {
        int result = labelTypeHelper.load();
        assertTrue(result >= 0);
    }

    @Test
    public void test_refresh() {
        List<LabelType> labelTypeList = createTestLabelTypeList();

        assertEquals("/etc/passwd", AdminLogAction.sanitizeFilename("../../etc/passwd"));
        assertEquals("test.log", AdminLogAction.sanitizeFilename("..test.log"));
        assertEquals("testlog", AdminLogAction.sanitizeFilename("test..log"));
    }

    @Test
    public void test_sanitizeFilename_removesMultipleDoubleDots() {
        // "...." becomes "" (two ".." are removed)

            HMACT64 hmac = new HMACT64(TEST_KEY);
            assertThrows(IllegalStateException.class, () -> hmac.engineDigest(new byte[10], 0, 10));
        }
    }

    @Test
    void testClone() throws NoSuchAlgorithmException, CloneNotSupportedException {
        // Test clone() method
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {

    assertThat(UnsignedInts.saturatedCast(Long.MAX_VALUE)).isEqualTo(GREATEST);
    assertThat(UnsignedInts.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

  public void testToLong() {
    for (long a : UNSIGNED_INTS) {
      assertThat(UnsignedInts.toLong((int) a)).isEqualTo(a);
    }
  }

  public void testCompare() {
    for (long a : UNSIGNED_INTS) {