Double.NEGATIVE_INFINITY,
    -Double.MAX_VALUE,
    (double) Long.MIN_VALUE,
    (double) Integer.MIN_VALUE,
    -Math.PI,
    -1.0,
    -Double.MIN_VALUE,
    -0.0,
    +0.0,
    Double.MIN_VALUE,
    1.0,
    Math.PI,
    (double) Integer.MAX_VALUE,
    (double) Long.MAX_VALUE,
    Double.MAX_VALUE,
    Double.POSITIVE_INFINITY,
    Double.NaN,
    Float.MAX_VALUE,
  };

    Range<C> effectiveRange = range;
    try {
      if (!range.hasLowerBound()) {
        effectiveRange = effectiveRange.intersection(Range.atLeast(domain.minValue()));
      }
      if (!range.hasUpperBound()) {
        effectiveRange = effectiveRange.intersection(Range.atMost(domain.maxValue()));
      }
    } catch (NoSuchElementException e) {
      throw new IllegalArgumentException(e);
    }

    boolean empty;

    }
  }

  public static final class BytesAsListHeadSubListGenerator extends TestByteListGenerator {
    @Override
    protected List<Byte> create(Byte[] elements) {
      Byte[] suffix = {Byte.MIN_VALUE, Byte.MAX_VALUE};
      Byte[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class BytesAsListTailSubListGenerator extends TestByteListGenerator {

    }
  }

  public static final class LongsAsListHeadSubListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
      Long[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class LongsAsListTailSubListGenerator extends TestLongListGenerator {

        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.atLeast(Integer.MIN_VALUE), integers()));
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.atMost(Integer.MAX_VALUE), integers()));
  }

  @GwtIncompatible // SerializableTester
  public void testSerialization() {

    }
  }

  public static final class LongsAsListHeadSubListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
      Long[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class LongsAsListTailSubListGenerator extends TestLongListGenerator {

    }
  }

  public static final class ShortsAsListHeadSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {
      Short[] suffix = {Short.MIN_VALUE, Short.MAX_VALUE};
      Short[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class ShortsAsListTailSubListGenerator extends TestShortListGenerator {

  }

  public static final class CharsAsListHeadSubListGenerator extends TestCharListGenerator {
    @Override
    protected List<Character> create(Character[] elements) {
      Character[] suffix = {Character.MIN_VALUE, Character.MAX_VALUE};
      Character[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

    }
  }

  public static final class ShortsAsListHeadSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {
      Short[] suffix = {Short.MIN_VALUE, Short.MAX_VALUE};
      Short[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class ShortsAsListTailSubListGenerator extends TestShortListGenerator {

    Range<C> effectiveRange = range;
    try {
      if (!range.hasLowerBound()) {
        effectiveRange = effectiveRange.intersection(Range.atLeast(domain.minValue()));
      }
      if (!range.hasUpperBound()) {
        effectiveRange = effectiveRange.intersection(Range.atMost(domain.maxValue()));
      }
    } catch (NoSuchElementException e) {
      throw new IllegalArgumentException(e);
    }

    boolean empty;