*   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an
 *       ordered pair of keys, a row key and column key.
 *   <dt>{@link Multiset}
 *   <dd>An extension of {@link java.util.Collection} that may contain duplicate values like a
 *       {@link java.util.List}, yet has order-independent equality like a {@link java.util.Set}.
 *       One typical use for a multiset is to represent a histogram.

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

    assertEqualIgnoringOrder(asList(expected), asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, asList(actual));
  }

  /**
   * Returns the {@link Method} instance for {@link #testToArray_isPlainObjectArray()} so that tests
   * of {@link Arrays#asList(Object[])} can suppress it with {@code

  /**
   * Creates a {@code LinkedBlockingQueue} with a capacity of {@link Integer#MAX_VALUE}, containing
   * the elements of the specified iterable, in the order they are returned by the iterable's
   * iterator.
   *
   * @param elements the elements that the queue should contain, in order
   * @return a new {@code LinkedBlockingQueue} containing those elements
   */
  @J2ktIncompatible
  @GwtIncompatible // LinkedBlockingQueue

    assertThat(Chars.join(",", '1', '2')).isEqualTo("1,2");
    assertThat(Chars.join("", '1', '2', '3')).isEqualTo("123");
  }

  public void testLexicographicalComparator() {
    List<char[]> ordered =
        Arrays.asList(
            new char[] {},
            new char[] {LEAST},
            new char[] {LEAST, LEAST},
            new char[] {LEAST, (char) 1},
            new char[] {(char) 1},

    assertThat(Doubles.join(",", 1.3, 2.4)).isEqualTo("1.3,2.4");
    assertThat(Doubles.join("", 1.4, 2.5, 3.6)).isEqualTo("1.42.53.6");
  }

  public void testLexicographicalComparator() {
    List<double[]> ordered =
        Arrays.asList(
            new double[] {},
            new double[] {LEAST},
            new double[] {LEAST, LEAST},
            new double[] {LEAST, 1.0},
            new double[] {1.0},

     * This affects which documents are included in search results by default.
     */
    @Size(max = 1000)
    public String defaultLabelValue;

    /**
     * Default sort order for search results.
     * Defines how search results are ordered when no specific sort is requested.
     */
    @Size(max = 1000)
    public String defaultSortValue;

    /**
     * Virtual host configuration for multi-tenant setups.

   * instead.
   *
   * @throws NullPointerException if {@code comparator} is null
   */
  public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
    return new Builder<>(comparator);
  }

  /**
   * Returns a builder that creates immutable sorted multisets whose elements are ordered by the
   * reverse of their natural ordering.
   *

        }
        load();
    }

    /**
     * Retrieves all available related content configurations from the data store.
     * The results are ordered by sort order ascending, then by term ascending.
     * The number of results is limited by the configured maximum fetch size.
     *
     * @return List of RelatedContent entities containing all available related content configurations

   * TestContainerGenerator#order(List)}. Tests should use this method only if they declare
   * requirement {@link com.google.common.collect.testing.features.CollectionFeature#KNOWN_ORDER}.
   */
  protected List<E> getOrderedElements() {
    List<E> list = new ArrayList<>();
    for (E e : getSubjectGenerator().order(new ArrayList<E>(getSampleElements()))) {