new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            // adds two nanoseconds to the ticker
            ticker.advance(1L);
            Thread.sleep(10);
            ticker.advance(1L);
            return null;
          }
        });

    assertEquals(numberOfThreads * 2, ticker.read());
  }

  @GwtIncompatible // concurrency

     */
    Set<List<E>> getAllStates();
  }

  /**
   * Returns a {@link ConcurrentlyMutatedList} that performs the given operations as its concurrent
   * modifications. The mutations occur in the same thread as the triggering method call.
   */
  private static ConcurrentlyMutatedList<Integer> newConcurrentlyMutatedList(
      Collection<Integer> initialContents, Iterable<ListFrobber> actionsToPerformConcurrently) {

    }

    protected static File getFileForClasspathResource(String resource)
            throws FileNotFoundException, URISyntaxException {
        ClassLoader cloader = Thread.currentThread().getContextClassLoader();

        URL resourceUrl = cloader.getResource(resource);

        if (resourceUrl == null) {
            throw new FileNotFoundException("Unable to find: " + resource);

    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>

        this.localInterfaces = new ArrayList<>();
        this.remoteInterfaces = new ArrayList<>();
        this.scheduler = Executors.newScheduledThreadPool(2, r -> {
            Thread t = new Thread(r, "MultiChannelScheduler");
            t.setDaemon(true);
            return t;
        });
        this.loadBalancer = new ChannelLoadBalancer(this);
        this.failover = new ChannelFailover(this);

    }

    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) {

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