return boolQuery;
            }
            return null;
        }).filter(q -> q != null).toArray(n -> new QueryBuilder[n]);

        if (queryBuilders.length == 1) {
            builder = queryBuilders[0];
        } else if (queryBuilders.length > 1) {
            final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            StreamUtil.stream(queryBuilders).of(stream -> stream.forEach(boolQuery::must));

   * The pointer to a key is stored in hashTable[Hashing.smear(key.hashCode()) % table.length],
   * save that if that location is already full, we try the next index, and the next, until we
   * find an empty table position.  Since the table has a power-of-two size, we use
   * & (table.length - 1) instead of % table.length, though.
   */

  private final transient @Nullable Object hashTable;

            String reqPath = "\\\\server\\share\\path";
            // Use valid consumed value within string bounds (reqPath.length() = 19)
            int consumed = Math.min(19, reqPath.length());

            data1 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);

    return generator.samples();
  }

  @Override
  public T create(Object... elements) {
    return generator.create(elements);
  }

  @Override
  public E[] createArray(int length) {
    return generator.createArray(length);
  }

  @Override
  public T createTestSubject() {
    Collection<E> elements = getSampleElements(getCollectionSize().getNumElements());
    return generator.create(elements.toArray());
  }

    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        final int start = bufferIndex;
        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("invalid session request wire format");
        }
        bufferIndex += calledName.readWireFormat(buffer, bufferIndex);

        super(domain, username, (String) null, AuthenticationType.USER);
        if (passwordHash == null || passwordHash.length != 16) {
            throw new IllegalArgumentException("Password hash must be provided, expected length 16 byte");
        }
        this.ntHash = passwordHash;
    }

    /**
     * Create username/password credentials with specified domain
     *

    int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        if (extendedSecurity) {
            System.arraycopy(buffer, bufferIndex, blob, 0, blob.length);
            bufferIndex += blob.length;
        }
        nativeOs = readString(buffer, bufferIndex);
        bufferIndex += stringWireLength(nativeOs, bufferIndex);

            };
          }
        };
    Reader joinedReader = CharSource.concat(reader, reader, reader).openStream();
    String result = CharStreams.toString(joinedReader);
    assertEquals(testString.length() * 3, result.length());
  }

  public void testReady() throws Exception {
    CharSource source = newCharSource("a");
    Iterable<? extends CharSource> list = ImmutableList.of(source, source);

            final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM);
            try {
                if (values.length > 0) {
                    cb.query().setRequestedAt_GreaterEqual(parseDateTime(values[0], formatter));
                }
                if (values.length > 1) {
                    cb.query().setRequestedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }

                final byte[] bytes = new byte[4096];
                int length = bis.read(bytes);
                while (length != -1) {
                    if (length != 0) {
                        final int len = length;
                        logger.fine(() -> {
                            try {