/**
   * Returns an immutable collection of the values in this multimap. Its iterator traverses the
   * values for the first key, the values for the second key, and so on.
   */
  @Override
  public ImmutableCollection<V> values() {
    return (ImmutableCollection<V>) super.values();
  }

  @Override
  ImmutableCollection<V> createValues() {
    return new Values<>(this);
  }

  @Override

    }

    /**
     * Represents a field facet with its name and value counts.
     * Each field facet contains multiple values with their respective document counts.
     */
    public static class Field {
        /**
         * Map containing field values and their document counts.
         * Keys are field values as strings, values are document counts.
         */

                        final String[] values = (String[]) e.getValue();
                        for (final String v : values) {
                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }
                    } else if (e.getValue() instanceof List) {
                        final List<String> values = (List<String>) e.getValue();

public class RequestParamTest {

    // Happy path: values() returns all constants in declaration order
    @Test
    @DisplayName("values() returns all declared constants in order")
    void valuesContainsAllInOrder() {
        RequestParam[] values = RequestParam.values();

        assertNotNull(values, "values() must not return null");
        assertEquals(4, values.length, "There must be exactly 4 constants");

public class StreamUtilTest extends TestCase {

    public void test_ofValues() {
        String[] values = { "value1", "value2" };
        StreamUtil.stream(values[0], values[1]).of(s -> {
            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {

      return if (bit and set != 0) values[INITIAL_WINDOW_SIZE] else DEFAULT_INITIAL_WINDOW_SIZE
    }

  fun clear() {
    set = 0
    values.fill(0)
  }

  operator fun set(
    id: Int,
    value: Int,
  ): Settings {
    if (id < 0 || id >= values.size) {
      return this // Discard unknown settings.
    }

    val bit = 1 shl id
    set = set or bit
    values[id] = value
    return this
  }

      Collection<Object> values = cache.asMap().values();
      assertThat(values.remove(null)).isFalse();
      assertThat(values.remove(6)).isFalse();
      assertThat(values.remove(-6)).isFalse();
      assertThat(values.removeAll(asList(null, 0, 15, 1500))).isFalse();
      assertThat(values.retainAll(asList(null, 0, 15, 1500))).isFalse();
      checkEmpty(values);
      checkEmpty(cache);
    }
  }

    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {
      // Only trust the size of `values` if it is a Set and therefore probably already deduplicated.
      if (values instanceof Set<?>) {
        Set<?> collection = (Set<?>) values;
        return max(defaultExpectedValues, collection.size());
      } else {
        return defaultExpectedValues;
      }

	assignments := make([]Assignment, len(values))
	for idx, value := range values {
		assignments[idx] = Assignment{Column: Column{Name: value}, Value: Column{Table: "excluded", Name: value}}
	}
	return assignments
}

// Assignments implements Assigner for a single Assignment.

import java.util.NoSuchElementException;
import java.util.Set;

/**
 * A sorted set of contiguous values in a given {@link DiscreteDomain}. Example:
 *
 * {@snippet :
 * ContiguousSet.create(Range.closed(5, 42), DiscreteDomain.integers())
 * }
 *
 * <p>Note that because bounded ranges over {@code int} and {@code long} values are so common, this
 * particular example can be written as just:
 *
 * {@snippet :