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

                Maps.immutableEntry("cat", (Collection<Integer>) Sets.newHashSet(12, 13, 14))));
    new IteratorTester<Entry<String, Collection<Integer>>>(
        6, MODIFIABLE, set, IteratorTester.KnownOrder.KNOWN_ORDER) {
      private @Nullable Multimap<String, Integer> multimap;

      @Override
      protected Iterator<Entry<String, Collection<Integer>>> newTargetIterator() {

  }

  public void testLeastOfIterable_ties() {
    Integer foo = new Integer(Integer.MAX_VALUE - 10);
    Integer bar = new Integer(Integer.MAX_VALUE - 10);

    assertNotSame(foo, bar);
    assertEquals(foo, bar);

    List<Integer> list = Arrays.asList(3, foo, bar, -1);
    List<Integer> result = numberOrdering.leastOf(list, list.size());

  }

  public void testLeastOfIterable_ties() {
    Integer foo = new Integer(Integer.MAX_VALUE - 10);
    Integer bar = new Integer(Integer.MAX_VALUE - 10);

    assertNotSame(foo, bar);
    assertEquals(foo, bar);

    List<Integer> list = Arrays.asList(3, foo, bar, -1);
    List<Integer> result = numberOrdering.leastOf(list, list.size());

      extends TestFilteredMultimapGenerator<SetMultimap<String, Integer>>
      implements TestSetMultimapGenerator<String, Integer> {

    abstract SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap);

    @Override
    public SetMultimap<String, Integer> create(Object... elements) {
      SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
      for (Object o : elements) {

    list1.add(2);
    List<Integer> list3 = newArrayList(3);
    input.add(1, list3);

    assertEquals(asList(1, 2, 3, 4), newArrayList(result));
    assertEquals("[1, 2, 3, 4]", result.toString());
  }

  public void testConcatVarargs() {
    List<Integer> list1 = newArrayList(1);
    List<Integer> list2 = newArrayList(4);
    List<Integer> list3 = newArrayList(7, 8);
    List<Integer> list4 = newArrayList(9);

    ListMultimap<String, Integer> multimap = create();
    multimap.put("foo", 2);
    multimap.put("bar", 3);
    Collection<Entry<String, Integer>> entries = multimap.entries();
    Iterator<Entry<String, Integer>> iterator = entries.iterator();
    Entry<String, Integer> entrya = iterator.next();
    Entry<String, Integer> entryb = iterator.next();

    ImmutableTable.Builder<String, String, Integer> zis =
        ImmutableTable.<String, String, Integer>builder().put("one", "uno", 1).put("two", "dos", 2);
    ImmutableTable.Builder<String, String, Integer> zat =
        ImmutableTable.<String, String, Integer>builder()
            .put("one", "eins", 1)
            .put("two", "twei", 2);
    ImmutableTable<String, String, Integer> table = zis.combine(zat).build();

public class PredicatesTest extends TestCase {
  private static final Predicate<@Nullable Integer> TRUE = Predicates.alwaysTrue();
  private static final Predicate<@Nullable Integer> FALSE = Predicates.alwaysFalse();
  private static final Predicate<@Nullable Integer> NEVER_REACHED =
      new Predicate<@Nullable Integer>() {
        @Override
        public boolean apply(@Nullable Integer i) {

  private static class IterableIterator implements Iterable<Integer>, Iterator<Integer> {
    private static final ImmutableSet<Integer> INTEGERS = ImmutableSet.of(1, 2, 3, 4);
    private final Iterator<Integer> iterator;

    public IterableIterator() {
      this.iterator = iterator();
    }

    @Override
    public Iterator<Integer> iterator() {
      return INTEGERS.iterator();
    }

    @Override