*/
@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()) {

	COR	X10, X11, X12				// ERROR "rd must be the same as rs1"
	COR	X5, X11					// ERROR "expected integer prime register in rs2"
	COR	X10, X5					// ERROR "expected integer prime register in rd"
	CXOR	X10, X11, X12				// ERROR "rd must be the same as rs1"
	CXOR	X5, X11					// ERROR "expected integer prime register in rs2"
	CXOR	X10, X5					// ERROR "expected integer prime register in rd"

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

                .filter(Matcher::matches)
                .map(
                    match -> new Version(
                        Integer.parseInt(match.group(1)),
                        Integer.parseInt(match.group(2)),
                        Integer.parseInt(match.group(3))
                    )
                )
                .collect(Collectors.toCollection(TreeSet::new)),

 */
@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;
  }

    // 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;

    // 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;

          for (Range<Integer> subRange : RANGES) {
            ImmutableRangeMap<Integer, Integer> rangeMap =
                ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build();

            ImmutableRangeMap.Builder<Integer, Integer> expectedBuilder =
                ImmutableRangeMap.builder();
            for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {

      return insertionOrder;
    }

    @Override
    public List<Entry<String, Integer>> create(Object... elements) {
      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
      for (Object o : elements) {
        @SuppressWarnings("unchecked")
        Entry<String, Integer> entry = (Entry<String, Integer>) checkNotNull(o);