*/
  public interface ClosingCallable<V extends @Nullable Object> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * <p>Any objects that are passed to {@link DeferredCloser#eventuallyClose(Object, Executor)
     * closer.eventuallyClose()} will be closed when the {@link ClosingFuture} pipeline is done (but

        assertEquals("PASSED", pom.getValue(prefix + "propertiesFile"));
        assertEquals("PASSED", pom.getValue(prefix + "parent"));
        assertEquals("PASSED-1", pom.getValue(prefix + "stringParams/stringParam[1]"));
        assertEquals("PASSED-3", pom.getValue(prefix + "stringParams/stringParam[2]"));
        assertEquals("PASSED-2", pom.getValue(prefix + "stringParams/stringParam[3]"));

   *
   * <p>The returned {@code Future} reflects the input's cancellation state directly, and any
   * attempt to cancel the returned Future is likewise passed through to the input Future.
   *
   * <p>Note that calls to {@linkplain Future#get(long, TimeUnit) timed get} only apply the timeout
   * to the execution of the underlying {@code Future}, not to the execution of the

   * IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code fromKey}.
   * However, this method doesn't throw an exception in that situation, but instead keeps the
   * original {@code fromKey}. Similarly, this method keeps the original {@code toKey}, instead of
   * throwing an exception, if passed a {@code toKey} greater than an earlier {@code toKey}.
   */
  @Override

   * references, instead of calling {@code equals}, to determine whether a provided object matches
   * an element in the set. For example, {@code contains} returns {@code false} when passed an
   * object that equals a set member, but isn't the same instance. This behavior is similar to the
   * way {@code IdentityHashMap} handles key lookups.
   *
   * @since 8.0
   */

                slf4jLogger.warn(
                        "The property '{}' has been set using a JVM system property which is deprecated. "
                                + "The property can be passed as a Maven argument or in the Maven project configuration file,"
                                + "usually located at ${session.rootDirectory}/.mvn/maven-user.properties.",
                        Constants.MAVEN_EXT_CLASS_PATH);

/**
 * Synchronized collection views. The returned synchronized collection views are serializable if the
 * backing collection and the mutex are serializable.
 *
 * <p>If {@code null} is passed as the {@code mutex} parameter to any of this class's top-level
 * methods or inner class constructors, the created object uses itself as the synchronization mutex.
 *
 * <p>This class should be used by other collection classes only.

/**
 * Synchronized collection views. The returned synchronized collection views are serializable if the
 * backing collection and the mutex are serializable.
 *
 * <p>If {@code null} is passed as the {@code mutex} parameter to any of this class's top-level
 * methods or inner class constructors, the created object uses itself as the synchronization mutex.
 *
 * <p>This class should be used by other collection classes only.

        assertTrue(initialFile.isFile(), "Initial file should be a file");
        assertTrue(initialFile.canRead(), "Should be able to read initial file");

        log.info("Basic connectivity test passed - can connect, list, and read files");
    }

    @Test
    void testCreateNewFile() throws Exception {
        SmbFile file = new SmbFile(baseUrl + "shared/newfile.txt", context);

    Iterator<String> itr2 = Iterators.concat(itr1, singletonIterator("d"));
    assertEquals("c", itr2.next());
    assertEquals("d", itr2.next());
  }

  /** Illustrates the somewhat bizarre behavior when a null is passed in. */
  public void testConcatContainingNull() {
    Iterator<Iterator<Integer>> input =
        (Iterator<Iterator<Integer>>)
            Arrays.<@Nullable Iterator<Integer>>asList(iterateOver(1, 2), null, iterateOver(3))