}

  @Retention(RetentionPolicy.RUNTIME)
  private @interface Tested {}

  private abstract static class A {
    @Tested private boolean privateField;
    @Tested int packagePrivateField;
    @Tested protected int protectedField;
    @Tested public String publicField;
    @Tested private static Iterable<String> staticField;
    @Tested private final Object finalField;
    private volatile char volatileField;

        final SearchLogBhv searchLogBhv = ComponentUtil.getComponent(SearchLogBhv.class);
        final int batchSize = ComponentUtil.getFessConfig().getSearchlogProcessBatchSizeAsInteger();
        final int totalSize = searchLogList.size();
        for (int i = 0; i < totalSize; i += batchSize) {
            final int end = Math.min(totalSize, i + batchSize);
            if (logger.isDebugEnabled()) {

    }

    /**
     * Returns the default flags for a generic Type-1 message in the
     * current environment.
     * 
     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags() {
        return DEFAULT_FLAGS;
    }

    /**
     * Returns the default domain from the current environment.
     *

    throwIf(OPEN_THROWS);
  }

  public boolean closed() {
    return closed;
  }

  @Override
  public int read() throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);
    return in.read();
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);
    return in.read(b, off, len);
  }

  @Override

    assertThat(Primitives.wrap(int.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(Integer.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(String.class)).isSameInstanceAs(String.class);
  }

  public void testUnwrap() {
    assertThat(Primitives.unwrap(Integer.class)).isSameInstanceAs(int.class);
    assertThat(Primitives.unwrap(int.class)).isSameInstanceAs(int.class);

    public void test_isSuccessful() {
        DefaultResponseProcessor processor = new DefaultResponseProcessor();
        processor.setSuccessfulHttpCodes(new int[] { 200 });
        processor.setNotModifiedHttpCodes(new int[] { 304 });

        ResponseData responseData = new ResponseData();
        responseData.setHttpStatusCode(200);
        assertTrue(processor.isSuccessful(responseData));

      new Murmur3_128HashFunction(Hashing.GOOD_FAST_HASH_SEED);

  // TODO(user): when the shortcuts are implemented, update BloomFilterStrategies
  private final int seed;

  Murmur3_128HashFunction(int seed) {
    this.seed = seed;
  }

  @Override
  public int bits() {
    return 128;
  }

  @Override
  public Hasher newHasher() {
    return new Murmur3_128Hasher(seed);
  }

  @Override

    implements Serializable {
  final Comparator<T> comparator;

  ComparatorOrdering(Comparator<T> comparator) {
    this.comparator = checkNotNull(comparator);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {
    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object == this) {
      return true;

import java.io.IOException;

class SocketOutputStream extends FilterOutputStream {

    SocketOutputStream( OutputStream out ) {
        super( out );
    }

    public synchronized void write( byte[] b, int off, int len ) throws IOException {
        if( len > 0xFFFF ) {
            throw new IOException( "write too large: " + len );
        } else if( off < 4 ) {

    }

    public static void setError(final int statusCode, final String message) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(WEB_API_EXCEPTION, new WebApiException(statusCode, message)));
    }

    public static void setError(final int statusCode, final Exception e) {