void testElapsedTime() throws InterruptedException {
        // Given
        exception = new SmbOperationException(SmbOperationException.ErrorCode.BUSY, "Server busy");

        // When
        Thread.sleep(100);

        // Then
        assertTrue(exception.getElapsedTime() >= 100);
        assertTrue(exception.getElapsedTime() < 200);
    }

    @Test

    private int pageSize;

    /** Current page number. */
    private int currentPageNumber;

    /** ID of the failure URL record. */
    public String id;

    /** Name of the thread that encountered the failure. */
    public String threadName;

    /** Number of errors encountered for this URL. */
    public String errorCount;

    /** Last time this URL was accessed. */

 * contract.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 * @since 12.0
 */
@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>

 * contract.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 * @since 12.0
 */
@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>

        // start
        AccessTimeoutTarget accessTimeoutTarget = null;
        TimeoutTask accessTimeoutTask = null;
        if (accessTimeout != null) {
            accessTimeoutTarget = new AccessTimeoutTarget(Thread.currentThread());
            accessTimeoutTask = TimeoutManager.getInstance().addTimeoutTarget(accessTimeoutTarget, accessTimeout, false);
        }

        final ExtractData data = new ExtractData();

    }

    private void negotiate(int port, final ServerMessageBlock resp) throws IOException {
        /* We cannot use Transport.sendrecv() yet because
         * the Transport thread is not setup until doConnect()
         * returns and we want to supress all communication
         * until we have properly negotiated.
         */
        synchronized (sbuf) {
            if (port == 139) {

            + "^\\s*data:|" //
            + "^\\s*android-app:|" //
            + "^\\s*ios-app:|" //
            + "^\\s*callto:", Pattern.CASE_INSENSITIVE);

    /** Thread-local XPathAPI instance for thread-safe XPath operations. */
    private final ThreadLocal<XPathAPI> xpathAPI = new ThreadLocal<>();

    @Override
    public ResultData transform(final ResponseData responseData) {

    call: Call,
    delay: Long,
  ): Thread {
    val thread =
      object : Thread("canceler") {
        override fun run() {
          try {
            sleep(delay)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          call.cancel()
        }
      }
    thread.start()
    return thread
  }

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * A ScheduledExecutorService that executes all scheduled actions immediately in the calling thread.
 *
 * <p>See {@link TestingExecutors#sameThreadScheduledExecutor()} for a full list of constraints.
 *
 * @author John Sirois
 * @author Zach van Schouwen
 */
@GwtIncompatible

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * A ScheduledExecutorService that executes all scheduled actions immediately in the calling thread.
 *
 * <p>See {@link TestingExecutors#sameThreadScheduledExecutor()} for a full list of constraints.
 *
 * @author John Sirois
 * @author Zach van Schouwen
 */
@GwtIncompatible