@Test
    public void test_getTimeAdjustTimeMillis_stringValues() {
        // Test various string formats
        String[] testValues = { "0", "1000", "-1000", "999999999", "-999999999", "1", "-1" };

        for (String value : testValues) {
            FessConfig testConfig = new FessConfig.SimpleImpl() {
                private static final long serialVersionUID = 1L;

                @Override

        // Test various values
        long[] testValues = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 0x123456789ABCDEFL };

        for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

    }

    @Test
    public void test_encode_decode_symmetry() {
        String[] testValues =
                { "guest", "{user}guest", "{group}guest", "{role}guest", "(deny){user}guest", "(deny){group}guest", "(deny){role}guest" };

        for (String value : testValues) {
            String encoded = permissionHelper.encode(value);
            if (encoded != null) {

        };

        for (long testValue : testValues) {
            FileInternalInfo testInfo = new FileInternalInfo();
            byte[] buffer = new byte[8];
            SMBUtil.writeInt8(testValue, buffer, 0);

            int bytesDecoded = testInfo.decode(buffer, 0, buffer.length);
            assertEquals(8, bytesDecoded);
            assertEquals(testValue, testInfo.getIndexNumber());

        try {
            // Test multiple value changes
            String[] testValues = { "http://localhost:9200", "https://elasticsearch.example.com", "http://127.0.0.1:9201",
                    "https://search.domain.com:443" };

            for (String testValue : testValues) {
                System.setProperty(Constants.FESS_SEARCH_ENGINE_HTTP_ADDRESS, testValue);
                String result = SystemUtil.getSearchEngineHttpAddress();

    Set<String> keys = bimap.keySet();
    assertEquals(newHashSet("one", "two", "three", "four"), keys);
    assertThat(keys).containsExactly("one", "two", "three", "four").inOrder();
  }

  public void testValues() {
    ImmutableBiMap<String, Integer> bimap =
        ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4));
    Set<Integer> values = bimap.values();

      } catch (UnsupportedOperationException | NullPointerException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }

  public void testValues() {
    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    assertInvariants(map);

      } catch (UnsupportedOperationException | NullPointerException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }

  public void testValues() {
    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    assertInvariants(map);

        List<String> testValue = null;
        OptionalEntity<List<String>> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertFalse(result.isPresent());
    }

    @Test
    public void test_ofNullable_withMap() {
        Map<String, Object> testValue = new HashMap<>();
        testValue.put("key1", "value1");
        testValue.put("key2", 42);

            // Given: NdrShort with test value
            int testValue = 123;
            NdrShort ndrShort = new NdrShort(testValue);

            // When: Encoding the value
            ndrShort.encode(mockBuffer);

            // Then: Should call enc_ndr_short with masked value
            verify(mockBuffer).enc_ndr_short(testValue & 0xFF);
            verifyNoMoreInteractions(mockBuffer);
        }