public void testContentEquals() throws IOException {
    assertTrue(
        source.contentEquals(
            new ByteSource() {
              @Override
              public InputStream openStream() throws IOException {
                return new RandomAmountInputStream(
                    new ByteArrayInputStream(expected), new Random());
              }
            }));
  }

    Cache cache = new Cache(cacheDirectory, 1024 * 1024);
    cache.evictAll();

    client = new OkHttpClient.Builder()
        .cache(cache)
        .build();
  }

  public void run() throws Exception {
    for (int i = 0; i < 5; i++) {
      System.out.println("    Request: " + i);

      Request request = new Request.Builder()

                return new BigDecimal(new SimpleDateFormat(pattern).format(o));
            }
            return new BigDecimal(Long.toString(((java.util.Date) o).getTime()));
        } else if (o instanceof String) {
            final String s = (String) o;
            if (StringUtil.isEmpty(s)) {
                return null;
            }
            return normalize(new BigDecimal(s));
        } else {

      @Override
      public Checksum get() {
        return new CRC32();
      }
    },
    ADLER_32("Hashing.adler32()") {
      @Override
      public Checksum get() {
        return new Adler32();
      }
    };

    public final HashFunction hashFunction;

    ChecksumType(String toString) {
      this.hashFunction = new ChecksumHashFunction(this, 32, toString);
    }
  }

  /**

    }

    /**
     * Gets the delay time in milliseconds for waiting for new URLs.
     *
     * @return the delay time in milliseconds for waiting for new URLs
     */
    public long getDelayMillisForWaitingNewUrl() {
        return delayMillisForWaitingNewUrl;
    }

    /**
     * Sets the delay time in milliseconds for waiting for new URLs.
     *

        assertArgumentNotNull("statement", statement);
        assertArgumentNotEmpty("sql", sql);

        try {
            return statement.execute(sql);
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Sets the fetch size.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @param fetchSize

        PathMappingCQ cq = new PathMappingCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            PathMappingCA ca = new PathMappingCA();
            aggsLambda.callback(ca);

        // Setup: job with logging enabled
        final AtomicReference<LaunchNowOption> capturedOption = new AtomicReference<>();
        final ScheduledJob scheduledJob = createScheduledJob("job-1", "Test Job", true, true);

        registerMockJobManager("job-1", opCall -> {
            final LaunchNowOption option = new LaunchNowOption();
            opCall.callback(option);
            capturedOption.set(option);

        final String testKey = "domain.title";
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final String[] results = new String[threadCount];

        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                results[index] = fessConfig.get(testKey);
            });
        }

    @Test
    public void test_constructor() {
        FessIntervalController controller = new FessIntervalController();
        assertNotNull(controller);
    }

    /**
     * Test getter and setter for delayMillisAfterProcessing
     */
    @Test
    public void test_delayMillisAfterProcessing() {
        FessIntervalController controller = new FessIntervalController();

        controller.setDelayMillisAfterProcessing(1000L);