verify(request, times(1)).isResponseAsync();
        verify(request, times(1)).getNext();
        verify(request, times(1)).split();
        verify(request, times(1)).allowChain(nextRequest);
        verify(request, times(1)).createCancel();
        verify(request, times(1)).size();
        verify(request, times(1)).getOverrideTimeout();
    }

    @Test

  @Override
  public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().offer(e, timeout, unit);
  }

  @CanIgnoreReturnValue // TODO(kak): consider removing this
  @Override
  public @Nullable E poll(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().poll(timeout, unit);
  }

  @Override

     * @param millis The maximum time to wait in milliseconds. A value of 0 means wait indefinitely.
     */
    public void awaitTermination(final long millis) {
        if (parentThread != null) {
            try {
                if (logger.isDebugEnabled()) {
                    logger.debug("Waiting for crawler termination: thread={}, timeout={}ms", parentThread.getName(), millis);
                }

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.junit.jupiter.api.BeforeEach;

  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    long timeoutNanos = unit.toNanos(timeout);
    if (timeoutNanos <= OverflowAvoidingLockSupport.MAX_NANOSECONDS_THRESHOLD) {
      return super.get(timeout, unit);
    }
    // Waiting 68 years should be enough for any program.
    return super.get(

    protected Map<String, Object> initParamMap;

    /** The maximum cached content size in bytes. Default is 1MB. */
    protected long maxCachedContentSize = 1024L * 1024L; // 1MB

    /** The access timeout in seconds. Default is null (no timeout). */
    protected Integer accessTimeout = null; // seconds

    /** The maximum content length in bytes. Default is null (no limit). */
    protected Long maxContentLength = null;

    /**

        assertFalse(filter.accept(smbFile), "Negative size should be rejected");
        verify(smbFile, times(1)).length();

        // zero size -> reject
        reset(smbFile);
        when(smbFile.length()).thenReturn(0L);
        assertFalse(filter.accept(smbFile), "Zero size should be rejected");
        verify(smbFile, times(1)).length();

        // positive size -> accept
        reset(smbFile);

     */
    public void setCreateTime(final long time) throws SmbException {
        if (getUncPath0().length() == 1) {
            throw new SmbException("Invalid operation for workgroups, servers, or shares");
        }

        setPathInformation(0, time, 0L);
    }

    /**
     * Set the last modified time of the file. The time is specified as milliseconds

        requestWithPath.setResolveInDfs(true);
        verify(requestWithPath, times(1)).setResolveInDfs(true);

        doNothing().when(requestWithPath).setResolveInDfs(false);
        requestWithPath.setResolveInDfs(false);
        verify(requestWithPath, times(1)).setResolveInDfs(false);

        // Test with implementation
        testImplementation.setResolveInDfs(true);

        // Verify precise interactions
        verify(mockEntry, times(1)).getName();
        verify(mockEntry, times(2)).getType();
        verify(mockEntry, times(1)).getAttributes();
        verify(mockEntry, times(1)).createTime();
        verify(mockEntry, times(1)).lastModified();
        verify(mockEntry, times(1)).lastAccess();
        verify(mockEntry, times(1)).length();
        verify(mockEntry, never()).getFileIndex();