final long requestInterval) {
        final Deferred<SuggestIndexResponse> deferred = new Deferred<>();
        threadPool.execute(() -> {
            final long start = System.currentTimeMillis();
            int numberOfSuggestDocs = 0;
            int numberOfInputDocs = 0;
            final List<Throwable> errors = new ArrayList<>();

     * @throws IOException if an I/O error occurs during handle creation
     */
    public SamrAliasHandle(final DcerpcHandle handle, final SamrDomainHandle domainHandle, final int access, final int rid)
            throws IOException {
        this.handle = handle;
        final MsrpcSamrOpenAlias rpc = new MsrpcSamrOpenAlias(domainHandle, access, rid, this);
        handle.sendrecv(rpc);

        return new TcpRdmaConnection(remote, local);
    }

    @Override
    public RdmaConnection connect(String hostname, int port) throws IOException {
        InetSocketAddress remoteAddress = new InetSocketAddress(hostname, port);
        RdmaConnection connection = createConnection(remoteAddress, null);
        connection.connect();

type s3Error struct {
	code       string
	message    string
	statusCode int
	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

func (err *s3Error) ErrorMessage() string {
	return err.message
}

func (err *s3Error) HTTPStatusCode() int {
	return err.statusCode
}

func (err *s3Error) Error() string {

}

var src = rand.NewSource(time.Now().UnixNano())

func randString(n int) string {
	b := make([]byte, n)
	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i--

    void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        // When
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {

     *
     * @param inputBuf
     * @param offset
     * @param len
     * @return response token
     */
    @Override
    public byte[] initSecContext(final byte[] inputBuf, final int offset, final int len) throws CIFSException {
        SpnegoToken resp;
        if (this.completed) {
            throw new CIFSException("Already complete");
        }
        if (len == 0) {

      extends ForwardingList<E> {
    final List<E> delegate;
    final int delta;

    MisleadingSizeList(List<E> delegate, int delta) {
      this.delegate = delegate;
      this.delta = delta;
    }

    @Override
    protected List<E> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      return delegate.size() + delta;
    }
  }

          host: InetAddress,
          port: Int,
        ): Socket? = null

        override fun createSocket(
          address: InetAddress,
          port: Int,
          localAddress: InetAddress,
          localPort: Int,
        ): Socket? = null

        override fun createSocket(
          host: String,
          port: Int,
        ): Socket? = null

            if (!kerberosOid.getId().equals(KerberosConstants.KERBEROS_OID)) {
                throw new PACDecodingException("Not a kerberos token");
            }

            int readLow = stream.read() & 0xff;
            int readHigh = stream.read() & 0xff;
            int read = (readHigh << 8) + readLow;
            if (read != 0x01) {
                throw new PACDecodingException("Malformed kerberos token");
            }