*/
@GwtCompatible
@NullUnmarked
public class TrustedInputFutureTest extends AbstractAbstractFutureTest {
  @Override
  AbstractFuture<@Nullable Integer> newDelegate() {
    AbstractFuture<@Nullable Integer> future = new TrustedFuture<@Nullable Integer>() {};
    assertTrue(future instanceof TrustedFuture); // sanity check
    return future;
  }

 */
@GwtCompatible
@NullUnmarked
public class UntrustedInputFutureTest extends AbstractAbstractFutureTest {
  @Override
  AbstractFuture<@Nullable Integer> newDelegate() {
    AbstractFuture<@Nullable Integer> future = new AbstractFuture<@Nullable Integer>() {};
    assertFalse(future instanceof TrustedFuture); // sanity check
    return future;
  }

public class ImmutableTableTest extends AbstractTableReadTest<Character> {
  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    ImmutableTable.Builder<String, Integer, Character> builder = ImmutableTable.builder();
    for (int i = 0; i < data.length; i = i + 3) {
      builder.put((String) data[i], (Integer) data[i + 1], (Character) data[i + 2]);
    }
    return builder.buildOrThrow();
  }

    ValueGraph<String, Integer> graph1 =
        ImmutableValueGraph.copyOf(ValueGraphBuilder.directed().<String, Integer>build());
    ValueGraph<String, Integer> graph2 = ImmutableValueGraph.copyOf(graph1);

    assertThat(graph2).isSameInstanceAs(graph1);
  }

  @Test
  public void incidentEdgeOrder_stable() {
    ImmutableValueGraph<String, Integer> immutableValueGraph =

    Cut<Integer> b = Range.atLeast(0).lowerBound;
    Cut<Integer> c = Range.greaterThan(0).lowerBound;
    Cut<Integer> d = Range.atLeast(1).lowerBound;
    Cut<Integer> e = Range.greaterThan(1).lowerBound;
    Cut<Integer> f = Range.greaterThan(1).upperBound;

    testCompareToAndEquals(ImmutableList.of(a, b, c, d, e, f));
  }

  @SuppressWarnings("DistinctVarargsChecker")

  public void testAsSetIteration() {
    Set<Entry<String, Collection<Integer>>> set =
        new LinkedHashSet<>(
            asList(
                immutableEntry("foo", (Collection<Integer>) newHashSet(2, 3, 6)),
                immutableEntry("bar", (Collection<Integer>) newHashSet(4, 5, 10, 11)),
                immutableEntry("baz", (Collection<Integer>) newHashSet(7, 8)),

 */
@GwtCompatible
@NullMarked
public class GeneralRangeTest extends TestCase {
  private static final Ordering<@Nullable Integer> ORDERING =
      Ordering.<Integer>natural().<Integer>nullsFirst();

  private static final List<@Nullable Integer> IN_ORDER_VALUES =
      unmodifiableList(Arrays.<@Nullable Integer>asList(null, 1, 2, 3, 4, 5));

  public void testCreateEmptyRangeFails() {
    for (BoundType lboundType : BoundType.values()) {

   */
  public void testMinMaxWithSupertypeComparator() {
    Comparator<Number> numberComparator = comparing(Number::intValue);
    Integer comparand1 = 1;
    Integer comparand2 = 2;

    Integer min = min(comparand1, comparand2, numberComparator);
    Integer max = max(comparand1, comparand2, numberComparator);

    assertThat(min).isEqualTo(1);
    assertThat(max).isEqualTo(2);
  }

      } else {
        return first.compareTo(second);
      }
    }
  }

  /** Decreasing integer values. A {@code null} comes before any non-null value. */
  private static final Comparator<@Nullable Integer> DECREASING_INT_COMPARATOR =
      Ordering.<Integer>natural().reverse().<Integer>nullsFirst();

  private SetMultimap<String, Integer> create() {
    return TreeMultimap.create(StringLength.COMPARATOR, DECREASING_INT_COMPARATOR);
  }

    // This sample AbstractIterator returns 0 on the first call, 1 on the
    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

          @Override
          public @Nullable Integer computeNext() {
            switch (rep++) {
              case 0:
                return 0;
              case 1:
                return 1;