readCompleteLatch.await()
      } catch (_: InterruptedException) {
        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }

    if (!::bytes.isInitialized) {
      // May have failed with an IOException
      throw IllegalStateException("Unable to load $path resource.").apply {
        initCause(readFailure)
      }
    }
  }

  abstract val path: Any

  /**

                }
            } catch (final SmbUnsupportedOperationException e) {
                if (!src.getContext().getConfig().isIgnoreCopyToException()) {
                    throw e;
                }
                log.warn("Failed to set file attributes on " + path, e);
            } catch (final SmbException se) {
                log.trace("copyTo0", se);

  public void testAwaitWithNoWait() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    CountDownLatch latch = new CountDownLatch(0);
    awaitUninterruptibly(latch);
    assertTrue(awaitUninterruptibly(latch, 0, MILLISECONDS));
    assertTrue(awaitUninterruptibly(latch, -42, MILLISECONDS));
    assertTrue(awaitUninterruptibly(latch, LONG_DELAY_MS, MILLISECONDS));
    assertTimeNotPassed(stopwatch, LONG_DELAY_MS);
  }

    PathMatcher deriveDirectoryMatcher(@Nonnull PathMatcher fileMatcher);

    /**
     * Returns the path matcher that unconditionally returns {@code true} for all files.
     * It should be the matcher returned by the other methods of this interface when the
     * given patterns match all files.
     *
     * @return path matcher that unconditionally returns {@code true} for all files
     */
    @Nonnull

     * @param server the server data containing security information
     * @param path the UNC path to the shared resource
     * @param service the service type (e.g., "A:" for disk share, "LPT1:" for printer)
     * @param andx the next command in the AndX chain, or null
     */
    public SmbComTreeConnectAndX(final CIFSContext ctx, final ServerData server, final String path, final String service,
            final ServerMessageBlock andx) {

    }

    private static class TestServletContext implements ServletContext {
        File parentFile = new File("/test/webapp");

        @Override
        public String getRealPath(String path) {
            if (path != null && path.contains("WEB-INF")) {
                return new File(parentFile, "WEB-INF").getAbsolutePath();
            }
            return parentFile.getAbsolutePath();
        }

public abstract class AbstractListenableFutureTest extends TestCase {

  protected CountDownLatch latch;
  protected ListenableFuture<Boolean> future;

  @Override
  protected void setUp() throws Exception {

    // Create a latch and a future that waits on the latch.
    latch = new CountDownLatch(1);
    future = createListenableFuture(Boolean.TRUE, null, latch);
  }

  @Override
  protected void tearDown() throws Exception {

  private final ListenableFuture<?> future;
  private final CountDownLatch latch;

  public ListenableFutureTester(ListenableFuture<?> future) {
    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);
    this.latch = new CountDownLatch(1);
  }

  public void setUp() {
    future.addListener(latch::countDown, exec);

    assertEquals(1, latch.getCount());
    assertFalse(future.isDone());

    /**
     * Guesses the content type.
     *
     * @param path
     *            The path. Must not be {@literal null} or an empty string.
     * @return The content type.
     */
    public static String guessContentType(final String path) {
        assertArgumentNotEmpty("path", path);

        final InputStream is = ResourceUtil.getResourceAsStream(path);
        try {

                    }
                } else if (path.length() == 0 || path.equals("/")) {
                    this.addresses = this.ctx.getNameServiceClient().getAllByName(host, true);
                } else {
                    this.addresses = this.ctx.getNameServiceClient().getAllByName(host, false);
                }
            } catch (final UnknownHostException e) {