}

  public void testCreate_empty() {
    assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.closedOpen(1, 1), integers()));
    assertEquals(ImmutableSet.of(), ContiguousSet.closedOpen(1, 1));
    assertEquals(ImmutableSet.of(), ContiguousSet.create(Range.openClosed(5, 5), integers()));
    assertEquals(
        ImmutableSet.of(), ContiguousSet.create(Range.lessThan(Integer.MIN_VALUE), integers()));
    assertEquals(

    @Override
    protected Set<String> create(String[] elements) {
      return ImmutableSet.copyOf(elements);
    }
  }

  public static class ImmutableSetUnsizedBuilderGenerator extends TestStringSetGenerator {
    @Override
    protected Set<String> create(String[] elements) {
      ImmutableSet.Builder<String> builder = ImmutableSet.builder();
      for (String e : elements) {
        builder.add(e);
      }

      return new SampleElements<>(
          mapEntry("one", ImmutableSet.of(10000)),
          mapEntry("two", ImmutableSet.of(-2000)),
          mapEntry("three", ImmutableSet.of(300)),
          mapEntry("four", ImmutableSet.of(-40)),
          mapEntry("five", ImmutableSet.of(5)));
    }

    @Override
    public Map<String, Collection<Integer>> create(Object... elements) {

    // invalidate setToTest
    wrappedSet.remove(1);
    // sanity check on update of wrappedSet
    assertThat(wrappedSet).isNotEqualTo(copyOfWrappedSet);

    ImmutableSet<Integer> copyOfModifiedSet = ImmutableSet.copyOf(wrappedSet); // {2,3}
    // sanity check on construction of copyOfModifiedSet
    assertThat(wrappedSet).isEqualTo(copyOfModifiedSet);

    return new SpliteratorTester<>(
        ImmutableSet.of(
            () -> new GeneralSpliteratorOfObject<>(spliteratorSupplier.get()),
            () -> new GeneralSpliteratorOfPrimitive<>(spliteratorSupplier.get(), c -> c::accept)));
  }

  private final ImmutableSet<Supplier<GeneralSpliterator<E>>> spliteratorSuppliers;

  private SpliteratorTester(ImmutableSet<Supplier<GeneralSpliterator<E>>> spliteratorSuppliers) {

    return new SpliteratorTester<>(
        ImmutableSet.of(
            () -> new GeneralSpliteratorOfObject<>(spliteratorSupplier.get()),
            () -> new GeneralSpliteratorOfPrimitive<>(spliteratorSupplier.get(), c -> c::accept)));
  }

  private final ImmutableSet<Supplier<GeneralSpliterator<E>>> spliteratorSuppliers;

  private SpliteratorTester(ImmutableSet<Supplier<GeneralSpliterator<E>>> spliteratorSuppliers) {

  static final Iterable<Double> ALL_DOUBLE_CANDIDATES;
  static final Iterable<Double> DOUBLE_CANDIDATES_EXCEPT_NAN;

  static {
    ImmutableSet.Builder<Double> integralBuilder = ImmutableSet.builder();
    ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder();
    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL

     */
    public ImmutableSet<@NonNull E> immutableCopy() {
      // Not using ImmutableSet.copyOf() to avoid iterating thrice (isEmpty, size, iterator).
      int maxSize = maxSize();
      if (maxSize == 0) {
        return ImmutableSet.of();
      }
      ImmutableSet.Builder<@NonNull E> builder = ImmutableSet.builderWithExpectedSize(maxSize);
      for (E element : this) {

  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    return (key == null) ? null : Maps.safeGet(delegate, key);
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {
    return ImmutableSet.unsafeDelegate(
        new ForwardingSet<Entry<K, V>>() {
          @Override
          protected Set<Entry<K, V>> delegate() {
            return delegate.entrySet();
          }

  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {
    return ImmutableSet.of(immutableEntry(singleKey, singleValue));
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.of(singleKey);
  }

  private final transient @Nullable ImmutableBiMap<V, K> inverse;