implements ListenableFuture<V> {
  // TODO(cpovirk): explore ways of making ListenableFutureTask final. There are some valid reasons
  // such as BoundedQueueExecutorService to allow extends but it would be nice to make it final to
  // avoid unintended usage.

  // The execution list to hold our listeners.
  private final ExecutionList executionList = new ExecutionList();

  /**

    }

    @Test
    public void test_longQuery() throws Exception {
        StringBuilder longQuery = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            longQuery.append("word").append(i).append(" ");
        }
        String query = longQuery.toString().trim();

        QueryLog queryLog = new QueryLog(query, null);

        assertEquals(query, queryLog.getQueryString());
    }

     *
     * @param id the ID of the scheduled job to start
     * @return JSON response with {@code jobLogId} (nullable) and status
     */
    // PUT /api/admin/scheduler/{id}/start
    @Execute(urlPattern = "{}/@word")
    public JsonResponse<ApiResult> put$start(final String id) {
        final String[] jobLogId = { null };
        scheduledJobService.getScheduledJob(id).ifPresent(entity -> {

   * type. That said, we could *accept* a `@Nullable T[]` (which, given that we treat arrays as
   * covariant, would still permit a plain `T[]`) and return a plain `T[]`. But of course that would
   * require its own suppression, since it is also unsound. toArray(T[]) is just a mess from a
   * nullness perspective. The signature below at least has the virtue of being relatively simple.

    /** The key of the configuration. e.g. 10 */
    String SUGGEST_POPULAR_WORD_SIZE = "suggest.popular.word.size";

    /** The key of the configuration. e.g. 30 */
    String SUGGEST_POPULAR_WORD_WINDOW_SIZE = "suggest.popular.word.window.size";

    /** The key of the configuration. e.g. 10 */
    String SUGGEST_POPULAR_WORD_QUERY_FREQ = "suggest.popular.word.query.freq";

    service.notifyStarted(); // usually this would be invoked by another thread
    assertEquals(State.RUNNING, service.state());
    assertTrue(service.isRunning());

    service.stopAsync();
    assertEquals(State.STOPPING, service.state());
    assertFalse(service.isRunning());
    assertTrue(service.doStopCalled);

    service.notifyStopped(); // usually this would be invoked by another thread

    service.notifyStarted(); // usually this would be invoked by another thread
    assertEquals(State.RUNNING, service.state());
    assertTrue(service.isRunning());

    service.stopAsync();
    assertEquals(State.STOPPING, service.state());
    assertFalse(service.isRunning());
    assertTrue(service.doStopCalled);

    service.notifyStopped(); // usually this would be invoked by another thread

	Checksum *hash.Checksum
	MD5Hex   string
}

// fanOutPutObject takes an input source reader and fans out multiple PUT operations
// based on the incoming fan-out request, a context cancellation by the caller
// would ensure all fan-out operations are canceled.
func fanOutPutObject(ctx context.Context, bucket string, objectAPI ObjectLayer, fanOutEntries []minio.PutObjectFanOutEntry, fanOutBuf []byte, opts fanOutOptions) ([]ObjectInfo, []error) {

      SortedSet<Integer> set = nullCheckedTreeSet(elements);
      if (set.isEmpty()) {
        /*
         * The (tooLow + 1, tooHigh) arguments below would be invalid because tooLow would be
         * greater than tooHigh.
         */
        return ContiguousSet.create(Range.openClosed(0, 1), DiscreteDomain.integers()).subSet(0, 1);
      }
      int tooHigh = set.last() + 1;

   * free slot.
   *
   * The table size is capped because, when there are more threads
   * than CPUs, supposing that each thread were bound to a CPU,
   * there would exist a perfect hash function mapping threads to
   * slots that eliminates collisions. When we reach capacity, we
   * search for this mapping by randomly varying the hash codes of