@Override
    public SampleElements<Integer> samples() {
      return new SampleElements<>(1, 4, 3, 2, 5);
    }

    @Override
    public Integer[] createArray(int length) {
      return new Integer[length];
    }

    @Override
    public Iterable<Integer> order(List<Integer> insertionOrder) {

  }

  public void testOfEntriesNull() {
    Entry<@Nullable Integer, Integer> nullKey = entry(null, 23);
    assertThrows(
        NullPointerException.class,
        () -> ImmutableBiMap.ofEntries((Entry<Integer, Integer>) nullKey));
    Entry<Integer, @Nullable Integer> nullValue =
        ImmutableBiMapTest.<@Nullable Integer>entry(23, null);
    assertThrows(
        NullPointerException.class,

    extends AbstractTableReadTest<C> {

  protected void populate(Table<String, Integer, C> table, @Nullable Object... data) {
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      table.put(
          (String) data[i], (Integer) data[i + 1], nullableCellValue((Character) data[i + 2]));
    }
  }

  protected boolean supportsRemove() {
    return true;

  }

  public void testMissingException() {
    List<Integer> emptyList = new ArrayList<>();

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            1, MODIFIABLE, emptyList, IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {
            return new Iterator<Integer>() {
              @Override

    @Override
    protected List<Integer> create(Integer[] elements) {
      return asList(elements);
    }
  }

  public static final class IntsAsListHeadSubListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      Integer[] suffix = {Integer.MIN_VALUE, Integer.MAX_VALUE};
      Integer[] all = concat(elements, suffix);

  public void testEmptyBuilder() {
    ImmutableSortedMap<String, Integer> map =
        ImmutableSortedMap.<String, Integer>naturalOrder().build();
    assertEquals(Collections.<String, Integer>emptyMap(), map);
  }

  public void testSingletonBuilder() {
    ImmutableSortedMap<String, Integer> map =
        ImmutableSortedMap.<String, Integer>naturalOrder().put("one", 1).build();
    assertMapEquals(map, "one", 1);
  }

    CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener();
    IdentityLoader<Integer> loader = identityLoader();

    // Even numbers are free, odd are too expensive
    Weigher<Integer, Integer> evensOnly =
        new Weigher<Integer, Integer>() {
          @Override
          public int weigh(Integer k, Integer v) {
            return k % 2;
          }
        };

    Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector =
        TableCollectors.toTable(
            Cell::getRowKey,
            Cell::getColumnKey,
            Cell::getValue,
            Integer::sum,
            HashBasedTable::create);
    BiPredicate<Table<String, String, Integer>, Table<String, String, Integer>> equivalence =
        pairwiseOnResultOf(Table::cellSet);

    ImmutableListMultimap.Builder<String, Integer> zis =
        ImmutableListMultimap.<String, Integer>builder().put("a", 1).put("b", 2);
    ImmutableListMultimap.Builder<String, Integer> zat =
        ImmutableListMultimap.<String, Integer>builder().put("a", 3).put("c", 4);
    ImmutableListMultimap<String, Integer> multimap = zis.combine(zat).build();

 * supported, nor is the {@link #remove()} method.
 *
 * <p>Example:
 *
 * {@snippet :
 * Iterator<Integer> powersOfTwo =
 *     new AbstractSequentialIterator<Integer>(1) {
 *       protected Integer computeNext(Integer previous) {
 *         return (previous == 1 << 30) ? null : previous * 2;
 *       }
 *     };
 * }
 *
 * @author Chris Povirk