crawler.getCrawlerContext().setMaxAccessCount(maxCount);
            crawler.getCrawlerContext().setNumOfThread(numOfThread);
            final String sessionId = crawler.execute();
            Thread.sleep(3000);
            assertEquals(CrawlerStatus.RUNNING, crawler.crawlerContext.getStatus());
            crawler.awaitTermination();
            assertEquals(maxCount, dataService.getCount(sessionId));

labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing
labels.includedDocUrls=Included URLs For Indexing
labels.maxAccessCount=Max Access Count
labels.name=Name
labels.numOfThread=Num of Thread
labels.duplicateHostName=Duplicate Name
labels.pageNumber=Page Number
labels.password=Password
labels.paths=Paths
labels.port=Port
labels.regex=Regular Expression
labels.regularName=Regular Name

                    throw new IllegalArgumentException("Invalid threads core multiplier value: '" + threadConfiguration
                            + "'. Value must be positive.");
                }

                int procs = Runtime.getRuntime().availableProcessors();
                int threads = (int) (coreMultiplier * procs);
                return threads == 0 ? 1 : threads;
            } else {

    }
    body.awaitSuccess()
  }

  /**
   * Duplex calls that have follow-ups are weird. By the time we know there's a follow-up we've
   * already split off another thread to stream the request body. Because we permit at most one
   * exchange at a time we break the request stream out from under that writer.
   */
  @Test
  fun duplexWithRedirect() {
    enableProtocol(Protocol.HTTP_2)

      isRunning = runningCallsCount() > 0
    }

    // Avoid resubmitting if we can't logically progress
    // particularly because RealCall handles a RejectedExecutionException
    // by executing on the same thread.
    if (executorService.isShutdown) {
      for (i in 0 until executableCalls.size) {
        val asyncCall = executableCalls[i]
        asyncCall.callsPerHost.decrementAndGet()

        this.withLock {

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

 *  New: Share threads more aggressively between OkHttp's HTTP/2 connections, connection pool,
    web sockets, and cache. OkHttp has a new internal task runner abstraction for managed task
    scheduling. In your debugger you will see new thread names and more use of daemon threads.

 *  Fix: Don't drop callbacks on unexpected exceptions. When an interceptor throws an unchecked

            return new Metadata(new MetadataStaxReader().read(in, false));
        } catch (FileNotFoundException e) {
            throw new RepositoryMetadataReadException("Cannot read metadata from '" + mappingFile + "'", e);
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryMetadataReadException(
                    "Cannot read metadata from '" + mappingFile + "': " + e.getMessage(), e);
        }

    assertEquals(0, ticker.read());
    assertEquals(10, ticker.read());
    assertEquals(20, ticker.read());
  }

  public void testAutoIncrementStep_millis() {
    FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, MILLISECONDS);
    assertEquals(0, ticker.read());
    assertEquals(1000000, ticker.read());
    assertEquals(2000000, ticker.read());
  }