* Tests related to the lifecycle management of the handle (e.g., closing).
     */
    @Nested
    public class LifecycleManagementTest {

        /**
         * Verifies that the close method can be called without throwing an exception.
         * @throws CIFSException if an error occurs during close.
         */
        @Test
        public void testClose() throws CIFSException {

    multimap.put("foo", 3);
    assertTrue(multimap.replaceValues("foo", asList(2, 4)) instanceof RandomAccess);
    assertTrue(multimap.replaceValues("bar", asList(2, 4)) instanceof RandomAccess);
  }

  /** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */
  public void testSublistConcurrentModificationException() {
    ListMultimap<String, Integer> multimap = create();

        shutdownMethod.setAccessible(true);

        // Invoke the method
        shutdownMethod.invoke(curtainFinallyHook);

        // Method should complete without throwing exceptions to the caller
        assertTrue(true);
    }

    // Test behavior when an exception occurs during reflection
    @Test
    public void test_shutdownCommonsHttpClient_withException() throws Exception {

        emptyGenerator.setName("empty");
        String path = "/path/to/thumbnail.jpg";

        // Since createTask requires FessConfig, it may not work properly
        // We test that the method can be called without throwing exceptions
        try {
            emptyGenerator.createTask(path, docMap);
        } catch (Exception e) {
            // Expected when FessConfig is not available
        }
    }

        try {
            Path nonExistingFile = tempDir.resolve("non_existing.tmp");
            assertFalse(Files.exists(nonExistingFile));

            // Should return false without throwing exception
            boolean deleted = Files.deleteIfExists(nonExistingFile);

            assertFalse(deleted);
        } finally {
            deleteDirectory(tempDir.toFile());
        }
    }

    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "Thrown exception";

        try {
            throw new UnsupportedSearchException(expectedMessage);
            // fail("Exception was not thrown");
        } catch (UnsupportedSearchException e) {
            assertEquals(expectedMessage, e.getMessage());

    multimap.put("foo", 3);
    assertTrue(multimap.replaceValues("foo", asList(2, 4)) instanceof RandomAccess);
    assertTrue(multimap.replaceValues("bar", asList(2, 4)) instanceof RandomAccess);
  }

  /** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */
  public void testSublistConcurrentModificationException() {
    ListMultimap<String, Integer> multimap = create();

        assertNotSame(exception2, exception3);
        assertNotSame(exception1, exception3);
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String errorMessage = "LDAP server not reachable";

        try {
            throw new LdapConfigurationException(errorMessage);
        } catch (LdapConfigurationException e) {

  private final List<E> expectedElements;
  private final int startIndex;
  private final KnownOrder knownOrder;

  /**
   * Meta-exception thrown by {@link AbstractIteratorTester.MultiExceptionListIterator} instead of
   * throwing any particular exception type.
   */
  private abstract static class PermittedMetaException extends RuntimeException {
    static final PermittedMetaException UOE_OR_ISE =

    }

    throw new IllegalArgumentException(
        "Domain name does not have a recognized public suffix: " + host);
  }

  /**
   * Attempts to return a {@code HostSpecifier} for the given string, throwing an exception if
   * parsing fails. Always use this method in preference to {@link #fromValid(String)} for a
   * specifier that is not already known to be valid.
   *