TreeSet<E> set = Sets.newTreeSet();
    set.add(freshElement);
    return set;
  }

  @Generates
  static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(
      E freshElement) {
    return ImmutableSortedSet.of(freshElement);
  }

  @Generates
  static <E> Multiset<E> generateMultiset(@Nullable E freshElement) {
    return generateHashMultiset(freshElement);
  }

 *       how the collection was created. Typically this is insertion order unless an explicit
 *       ordering is otherwise specified (e.g. {@link ImmutableSortedSet#naturalOrder}). See the
 *       appropriate factory method for details. View collections such as {@link
 *       ImmutableMultiset#elementSet} iterate in the same order as the parent, except as noted.

  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1) {
    RegularImmutableSortedSet<E> elementSet =
        (RegularImmutableSortedSet<E>) ImmutableSortedSet.of(e1);
    long[] cumulativeCounts = {0, 1};
    return new RegularImmutableSortedMultiset<>(elementSet, cumulativeCounts, 0, 1);
  }

  /**

  public void testGet_emptyList() {
    testGetOnEmpty(Collections.<String>emptyList());
  }

  public void testGet_sortedSet() {
    testGetOnAbc(ImmutableSortedSet.of("b", "c", "a"));
  }

  public void testGet_emptySortedSet() {
    testGetOnEmpty(ImmutableSortedSet.<String>of());
  }

  public void testGet_iterable() {
    testGetOnAbc(ImmutableSet.of("a", "b", "c"));
  }

 *       how the collection was created. Typically this is insertion order unless an explicit
 *       ordering is otherwise specified (e.g. {@link ImmutableSortedSet#naturalOrder}). See the
 *       appropriate factory method for details. View collections such as {@link
 *       ImmutableMultiset#elementSet} iterate in the same order as the parent, except as noted.

                        mapEntry("a", (Collection<String>) ImmutableSortedSet.of("alex")),
                        mapEntry("b", (Collection<String>) ImmutableSortedSet.of("bob", "bagel")),
                        mapEntry("c", (Collection<String>) ImmutableSortedSet.of("carl", "carol")),
                        mapEntry("d", (Collection<String>) ImmutableSortedSet.of("david", "dead")),
                        mapEntry(

  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1) {
    RegularImmutableSortedSet<E> elementSet =
        (RegularImmutableSortedSet<E>) ImmutableSortedSet.of(e1);
    long[] cumulativeCounts = {0, 1};
    return new RegularImmutableSortedMultiset<>(elementSet, cumulativeCounts, 0, 1);
  }

  /**

                        mapEntry("a", (Collection<String>) ImmutableSortedSet.of("alex")),
                        mapEntry("b", (Collection<String>) ImmutableSortedSet.of("bob", "bagel")),
                        mapEntry("c", (Collection<String>) ImmutableSortedSet.of("carl", "carol")),
                        mapEntry("d", (Collection<String>) ImmutableSortedSet.of("david", "dead")),
                        mapEntry(

  // TreeSet

  /**
   * Creates a <i>mutable</i>, empty {@code TreeSet} instance sorted by the natural sort ordering of
   * its elements.
   *
   * <p><b>Note:</b> if mutability is not required, use {@link ImmutableSortedSet#of()} instead.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated. Instead,
   * use the {@code TreeSet} constructor directly, taking advantage of <a

  // TreeSet

  /**
   * Creates a <i>mutable</i>, empty {@code TreeSet} instance sorted by the natural sort ordering of
   * its elements.
   *
   * <p><b>Note:</b> if mutability is not required, use {@link ImmutableSortedSet#of()} instead.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated. Instead,
   * use the {@code TreeSet} constructor directly, taking advantage of <a