Channels act as first-in-first-out queues.
For example, if one goroutine sends values on a channel
and a second goroutine receives them, the values are
received in the order sent.
</p>

<h2 id="Properties_of_types_and_values">Properties of types and values</h2>

<h3 id="Representation_of_values">Representation of values</h3>

<p>
Values of predeclared types (see below for the interfaces <code>any</code>

    @Test
    public void testScrollSearch_customAccumulator() {
        createTestIndex();
        indexDocuments(5);
        runner.refresh();

        // Use custom accumulator to sum values
        List<Integer> values = new ArrayList<>();
        List<Integer> results = ScrollOperationHelper.scrollSearch(client, suggester.settings(), INDEX_NAME, QueryBuilders.matchAllQuery(),
                10, (hit, accumulator) -> {

   *     {@code ((SortedMap<C, V>) table.rowMap().values().iterator().next()).comparator();}.
   */
  @Deprecated
  public Comparator<? super C> columnComparator() {
    return columnComparator;
  }

  // TODO(lowasser): make column return a SortedMap

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code TreeBasedTable} has unique sorted values for a given row, this method

     *
     * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
     * undirected.
     *
     * <p>Values do not have to be unique. However, values must be non-null.
     *
     * <p>If {@code nodeU} and {@code nodeV} are not already present in this graph, this method will

    do {
      int entryIndex = next - 1;
      int entry = entries[entryIndex];
      if (getHashPrefix(entry, mask) == hashPrefix
          && Objects.equals(key, keys[entryIndex])
          && (values == null || Objects.equals(value, values[entryIndex]))) {
        int newNext = getNext(entry, mask);
        if (lastEntryIndex == -1) {
          // we need to update the root link from table[]
          tableSet(table, tableIndex, newNext);

  public SortedSet<V> removeAll(@Nullable Object key) {
    return delegate().removeAll(key);
  }

  @Override
  public SortedSet<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {
    return delegate().replaceValues(key, values);
  }

  @Override
  public @Nullable Comparator<? super V> valueComparator() {
    return delegate().valueComparator();
  }

    return delegate().removeAll(key);
  }

  @CanIgnoreReturnValue
  @Override
  public Set<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {
    return delegate().replaceValues(key, values);
  }

  /**
   * Returns a collection that simulates concurrent modification by having its size method return
   * incorrect values. This is useful for testing methods that must treat the return value from
   * size() as a hint only.
   *
   * @param delta the difference between the true size of the collection and the values returned by
   *     the size method
   */

    }

    @Test
    void testWitnessEventTypes() {
        assertEquals(7, WitnessEventType.values().length);

        WitnessEventType[] events = WitnessEventType.values();

        // Verify all expected event types with correct values
        assertEquals(1, WitnessEventType.RESOURCE_CHANGE.getValue());
        assertEquals(2, WitnessEventType.CLIENT_MOVE.getValue());

  }

  @Override
  final Spliterator<Cell<R, C, V>> cellSpliterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  public ImmutableCollection<V> values() {
    return (ImmutableCollection<V>) super.values();
  }

  @Override
  abstract ImmutableCollection<V> createValues();

  @Override
  final Iterator<V> valuesIterator() {