parentBuilder) {
    return SetTestSuiteBuilder.using(
            new ElementSetGenerator<E>(parentBuilder.getSubjectGenerator()))
        .named(getName() + ".elementSet")
        .withFeatures(computeElementSetFeatures(parentBuilder.getFeatures()))
        .suppressing(parentBuilder.getSuppressedTests())
        .withSetUp(parentBuilder.getSetUp())

  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetFirst() {
    assertNull(sortedMultiset.firstEntry());
    assertThrows(NoSuchElementException.class, () -> sortedMultiset.elementSet().first());
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetPollFirst() {
    assertNull(sortedMultiset.pollFirstEntry());
  }

        @Override
        Iterator<Entry<E>> entryIterator() {
          return backingMultiset.descendingMultiset().entrySet().iterator();
        }
      };
    }

    @Override
    public NavigableSet<E> elementSet() {
      return new StandardElementSet();
    }

    @Override
    public Entry<E> firstEntry() {
      return standardFirstEntry();
    }

    @Override
    public Entry<E> lastEntry() {

  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);
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by their natural

   *
   * <p>A common use for the element set is to find the number of distinct elements in the multiset:
   * {@code elementSet().size()}.
   *
   * @return a view of the set of distinct elements in this multiset
   */
  Set<E> elementSet();

  /**
   * Returns a view of the contents of this multiset, grouped into {@code Multiset.Entry} instances,

                    }
                    return builder.build().elementSet().asList();
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {
                    return Ordering.natural().sortedCopy(insertionOrder);
                  }
                })
            .named("ImmutableSortedMultiset.elementSet.asList")
            .withFeatures(

  }

  @CheckForNull @LazyInit private transient Reference<Multiset<N>> adjacentNodesReference;

  @Override
  public Set<N> adjacentNodes() {
    return Collections.unmodifiableSet(adjacentNodesMultiset().elementSet());
  }

  private Multiset<N> adjacentNodesMultiset() {
    Multiset<N> adjacentNodes = getReference(adjacentNodesReference);
    if (adjacentNodes == null) {

   *
   * <p>A common use for the element set is to find the number of distinct elements in the multiset:
   * {@code elementSet().size()}.
   *
   * @return a view of the set of distinct elements in this multiset
   */
  Set<E> elementSet();

  /**
   * Returns a view of the contents of this multiset, grouped into {@code Multiset.Entry} instances,

        return delegate().setCount(element, oldCount, newCount);
      }
    }

    @Override
    public Set<E> elementSet() {
      synchronized (mutex) {
        if (elementSet == null) {
          elementSet = typePreservingSet(delegate().elementSet(), mutex);
        }
        return elementSet;
      }
    }

    @Override
    public Set<Multiset.Entry<E>> entrySet() {
      synchronized (mutex) {

        return delegate().setCount(element, oldCount, newCount);
      }
    }

    @Override
    public Set<E> elementSet() {
      synchronized (mutex) {
        if (elementSet == null) {
          elementSet = typePreservingSet(delegate().elementSet(), mutex);
        }
        return elementSet;
      }
    }

    @Override
    public Set<Multiset.Entry<E>> entrySet() {
      synchronized (mutex) {