final Terms terms = response.getAggregations().get(fessConfig.getIndexFieldSegment());
                for (final Bucket bucket : terms.getBuckets()) {
                    final Map<String, String> map = new HashMap<>(2);
                    map.put(fessConfig.getIndexFieldSegment(), bucket.getKey().toString());
                    map.put(FACET_COUNT_KEY, Long.toString(bucket.getDocCount()));
                    sessionIdList.add(map);

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {
      a = entries.get(0);
      if (entries.size() >= 3) {
        b = entries.get(1);
        c = entries.get(2);
      }
    }
  }

  /** Resets the contents of navigableMap to have entries a, c, for the navigation tests. */
  @SuppressWarnings("unchecked") // Needed to stop Eclipse whining
  private void resetWithHole() {

 * might run on the {@code directExecutor()} or be otherwise re-entrant (call back into your
 * object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision
 * to run a particular event is made during the state change, but the decision to actually invoke

        extractParameters(methodDeclaration, methodMetaData);

        Matcher matcher = GETTER_METHOD_NAME.matcher(name);
        if (matcher.matches()) {
            int startName = matcher.start(2);
            String propName = name.substring(startName, startName + 1).toLowerCase(Locale.ROOT) + name.substring(startName + 1);

      successor(this, right, succ());
      height = max(2, height);
      distinctElements++;
      totalCount += count;
      return this;
    }

    private AvlNode<E> addLeftChild(@ParametricNullness E e, int count) {
      left = new AvlNode<>(e, count);
      successor(pred(), left, this);
      height = max(2, height);
      distinctElements++;
      totalCount += count;
      return this;

  void joinPool(ExecutorService exec) throws InterruptedException {
    try {
      exec.shutdown();
      assertTrue(
          "ExecutorService did not terminate in a timely manner",
          exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
    } catch (SecurityException ok) {
      // Allowed in case test doesn't have privs
    }
  }

  /**

    - [Source Code](#source-code-2)
    - [Client Binaries](#client-binaries-2)
    - [Server Binaries](#server-binaries-2)
    - [Node Binaries](#node-binaries-2)
    - [Container Images](#container-images-2)
  - [Changelog since v1.28.12](#changelog-since-v12812)
  - [Changes by Kind](#changes-by-kind-2)
    - [API Change](#api-change)
    - [Bug or Regression](#bug-or-regression-2)
  - [Dependencies](#dependencies-2)

    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()));

    Set<Entry<K, Collection<V>>> asMapEntrySet = multimap().asMap().entrySet();
    assertTrue(multimap().put(k1(), v4()));
    assertEquals(2, asMapEntrySet.size());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testAsMapEntrySetRemovePropagatesToMultimap() {

      }
    }

    for (i in FLAGS.indices) { // Fill in holes with binary representation.
      if (FLAGS[i] == null) FLAGS[i] = BINARY[i]
    }
  }

  /**
   * Returns a human-readable representation of HTTP/2 frame headers.
   *
   * The format is:
   *
   * ```
   * direction streamID length type flags
   * ```
   *
   * Where direction is `<<` for inbound and `>>` for outbound.
   *

            ticker.advance(1L);
            Thread.sleep(10);
            ticker.advance(1L);
            return null;
          }
        });

    assertEquals(numberOfThreads * 2, ticker.read());
  }

  @GwtIncompatible // concurrency

  public void testConcurrentAutoIncrementStep() throws Exception {
    int incrementByNanos = 3;