return suite;
  }

  @SuppressWarnings("DoNotCall")
  public void testEmptyIterator() {
    Iterator<String> iterator = emptyIterator();
    assertFalse(iterator.hasNext());
    assertThrows(NoSuchElementException.class, () -> iterator.next());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
  }

  @SuppressWarnings("DoNotCall")
  public void testEmptyListIterator() {

    assertThrows(
        IllegalArgumentException.class,
        () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
  }

  // BiMap-specific tests

  @SuppressWarnings("DoNotCall")
  public void testForcePut() {
    BiMap<String, Integer> bimap = ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2));
    assertThrows(UnsupportedOperationException.class, () -> bimap.forcePut("three", 3));
  }

            CollectionFeature.ALLOWS_NULL_QUERIES)
        .createTestSuite();
  }

  private enum SomeEnum {
    A,
    B,
    C,
    D
  }

  @SuppressWarnings("DoNotCall")
  public void testImmutableEnumSet() {
    Set<SomeEnum> units = Sets.immutableEnumSet(SomeEnum.D, SomeEnum.B);

    assertThat(units).containsExactly(SomeEnum.B, SomeEnum.D).inOrder();

    ImmutableSortedSet<LegacyComparable> set = builder.build();
    assertTrue(elementsEqual(LegacyComparable.VALUES_BACKWARD, set));
  }

  @SuppressWarnings({"deprecation", "static-access", "DoNotCall"})
  public void testBuilderMethod() {
    assertThrows(UnsupportedOperationException.class, () -> ImmutableSortedSet.builder());
  }

  public void testAsList() {