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.
   *

   * be included, and it's much easier to implement the interpretation that they not be. Finally, a
   * call to {@code shutdown} or {@code shutdownNow} may result in concurrent calls to {@code
   * invokeAll/invokeAny} throwing RejectedExecutionException, although a subset of the tasks may
   * already have been executed.
   *
   * @since 32.0.0 (taking the place of a method with a different return type from 15.0)
   */

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

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

        try {
            throw new ScriptEngineException(message);
        } catch (ScriptEngineException e) {
            assertEquals(message, e.getMessage());

        @Override
        public void call(Object object) {
          throw new RuntimeException();
        }

        @Override
        public String toString() {
          return "throwing()";
        }
      };

  public void testEnqueueAndDispatch() {
    Object listener = new Object();
    ListenerCallQueue<Object> queue = new ListenerCallQueue<>();
    queue.addListener(listener, directExecutor());

        @Override
        public void call(Object object) {
          throw new RuntimeException();
        }

        @Override
        public String toString() {
          return "throwing()";
        }
      };

  public void testEnqueueAndDispatch() {
    Object listener = new Object();
    ListenerCallQueue<Object> queue = new ListenerCallQueue<>();
    queue.addListener(listener, directExecutor());