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

     * 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);
    }

    /**

                valid = false;
            }
        }
    }

    @Override
    protected int generateLocalKey() {
        // In real implementation, this would get the local key from DiSNI:
        // return memoryRegister.getLkey();
        return keyGenerator.getAndIncrement();
    }

    @Override
    protected int generateRemoteKey() {
        // In real implementation, this would get the remote key from DiSNI:

     */
    boolean haveCapabilitiy(int cap);

    /**
     * Gets the negotiated send buffer size.
     *
     * @return the send buffer size
     */
    int getSendBufferSize();

    /**
     * Gets the negotiated receive buffer size.
     *
     * @return the receive buffer size
     */
    int getReceiveBufferSize();

    /**

    }

    @Override
    public int count(@Nullable Object o) {
      synchronized (mutex) {
        return delegate().count(o);
      }
    }

    @Override
    public int add(@ParametricNullness E e, int n) {
      synchronized (mutex) {
        return delegate().add(e, n);
      }
    }

    @Override
    public int remove(@Nullable Object o, int n) {
      synchronized (mutex) {