}

  private static void runTestFuzzyCompare(int toleranceIndex) {
    double tolerance = get(TOLERANCE_CANDIDATES, toleranceIndex);
    for (double a : ALL_DOUBLE_CANDIDATES) {
      for (double b : ALL_DOUBLE_CANDIDATES) {
        int expected = DoubleMath.fuzzyEquals(a, b, tolerance) ? 0 : Double.compare(a, b);
        int actual = DoubleMath.fuzzyCompare(a, b, tolerance);

  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public int drainTo(Collection<? super E> c, int maxElements) {
    if (c == null) throw new NullPointerException();
    if (c == this) throw new IllegalArgumentException();
    if (maxElements <= 0) return 0;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      int n = 0;
      E e;
      while (n < maxElements && (e = q.poll()) != null) {

        new SecureRandom().nextBytes(challenge);

        int flags = NtlmFlags.NTLMSSP_NEGOTIATE_UNICODE | NtlmFlags.NTLMSSP_NEGOTIATE_NTLM;

        return new Type2Message(createMockContext(), flags, challenge, "TARGET");
    }

    /**
     * Helper method to create a test string of specified length
     */
    private String createTestString(int length) {
        StringBuilder sb = new StringBuilder(length);

                            + "'. Value must be positive.");
                }

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

     * Returns the maximum retry count.
     * @return The maximum retry count.
     */
    public int getMaxRetryCount() {
        return maxRetryCount;
    }

    /**
     * Sets the maximum retry count.
     * @param maxRetryCount The maximum retry count.
     */
    public void setMaxRetryCount(final int maxRetryCount) {
        this.maxRetryCount = maxRetryCount;
    }

    /**

        final String registrationId;
        final String shareName;
        final String serverAddress;
        final int flags;
        final long timestamp;

        MockRegistration(String registrationId, String shareName, String serverAddress, int flags) {
            this.registrationId = registrationId;
            this.shareName = shareName;
            this.serverAddress = serverAddress;

@GwtCompatible
abstract class CommonMatcher {
  public abstract boolean matches();

  public abstract boolean find();

  public abstract boolean find(int index);

  public abstract String replaceAll(String replacement);

  public abstract int end();

  public abstract int start();

  private final Random random;

  public RandomAmountInputStream(InputStream in, Random random) {
    super(checkNotNull(in));
    this.random = checkNotNull(random);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return super.read(b, off, random.nextInt(len) + 1);
  }

        return false;
      }
    }

    return !iteratorA.hasNext() && !iteratorB.hasNext();
  }

  @Override
  protected int doHash(Iterable<T> iterable) {
    int hash = 78721;
    for (T element : iterable) {
      hash = hash * 24943 + elementEquivalence.hash(element);
    }
    return hash;
  }

  @Override

    public void test_isContinue_belowMaxThreadCheckCount() throws Exception {
        // Use reflection to access protected method
        final java.lang.reflect.Method method = CrawlerThread.class.getDeclaredMethod("isContinue", int.class);
        method.setAccessible(true);
        final boolean result = (boolean) method.invoke(crawlerThread, 5);

        assertTrue(result);
    }

    /**