@Override
 public boolean contains(Object obj) {
   return Comparators.nullSafeEquals(obj, this.element1)
       || Comparators.nullSafeEquals(obj, this.element2)
       || Comparators.nullSafeEquals(obj, this.element3)
       || Comparators.nullSafeEquals(obj, this.element4);
 }
 @Test
 public void toSortedSetWithComparator() {
   ImmutableCollection<Integer> integers = this.classUnderTest();
   MutableSortedSet<Integer> set =
       integers.toSortedSet(Comparators.<Integer>reverseNaturalOrder());
   Assert.assertEquals(integers.toSet(), set);
   Assert.assertEquals(
       integers.toSortedList(Comparators.<Integer>reverseNaturalOrder()), set.toList());
 }
 @Test
 public void valuesCollection_toArray_withLargeTarget() {
   MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two");
   String[] target = new String[3];
   target[2] = "yow!";
   String[] values = map.values().toArray(target);
   ArrayIterate.sort(
       values, values.length, Comparators.safeNullsHigh(Comparators.<String>naturalOrder()));
   Assert.assertArrayEquals(new String[] {"One", "Two", null}, values);
 }
 @Test
 public void keySet_ToArray_withLargeTarget() {
   MutableMap<Integer, String> map =
       this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four");
   Integer[] target = new Integer[6]; // deliberately large to force the extra to be set to null
   target[4] = 42;
   target[5] = 42;
   Integer[] result = map.keySet().toArray(target);
   ArrayIterate.sort(
       result, result.length, Comparators.safeNullsHigh(Comparators.<Integer>naturalOrder()));
   Assert.assertArrayEquals(new Integer[] {1, 2, 3, 4, 42, null}, result);
 }
 public V get(Object key) {
   if (Comparators.nullSafeEquals(this.key3, key)) {
     return this.value3;
   }
   if (Comparators.nullSafeEquals(this.key2, key)) {
     return this.value2;
   }
   if (Comparators.nullSafeEquals(this.key1, key)) {
     return this.value1;
   }
   return null;
 }
 public MutableSet<T> without(T element) {
   if (Comparators.nullSafeEquals(element, this.element1)) {
     return new DoubletonSet<T>(this.element2, this.element3);
   }
   if (Comparators.nullSafeEquals(element, this.element2)) {
     return new DoubletonSet<T>(this.element1, this.element3);
   }
   if (Comparators.nullSafeEquals(element, this.element3)) {
     return new DoubletonSet<T>(this.element1, this.element2);
   }
   return this;
 }
 @Override
 @Test
 public void toSortedMap_with_comparator() {
   MutableSortedMap<String, String> map =
       this.newBag()
           .toSortedMap(
               Comparators.<String>reverseNaturalOrder(),
               Functions.getStringPassThru(),
               Functions.getStringPassThru());
   Verify.assertEmpty(map);
   Verify.assertInstanceOf(TreeSortedMap.class, map);
   Assert.assertEquals(Comparators.<String>reverseNaturalOrder(), map.comparator());
 }
 @Test
 public void toSortedMap_with_comparator() {
   LazyIterable<Integer> integers = this.newWith(1, 2, 3);
   MutableSortedMap<Integer, String> map =
       integers.toSortedMap(
           Comparators.<Integer>reverseNaturalOrder(),
           Functions.getIntegerPassThru(),
           Functions.getToString());
   Verify.assertMapsEqual(
       TreeSortedMap.newMapWith(
           Comparators.<Integer>reverseNaturalOrder(), 1, "1", 2, "2", 3, "3"),
       map);
   Verify.assertListsEqual(FastList.newListWith(3, 2, 1), map.keySet().toList());
 }
  @Test
  public void toSortedBag_empty() {
    ImmutableBag<String> immutableBag = Bags.immutable.of();

    MutableSortedBag<String> sortedBag =
        immutableBag.toSortedBag(Comparators.reverseNaturalOrder());
    sortedBag.addOccurrences("apple", 3);
    sortedBag.addOccurrences("orange", 2);

    Verify.assertSortedBagsEqual(
        TreeBag.newBagWith(
            Comparators.reverseNaturalOrder(), "orange", "orange", "apple", "apple", "apple"),
        sortedBag);
  }
 public static <
         T,
         V1 extends Comparable<? super V1>,
         V2 extends Comparable<? super V2>,
         V3 extends Comparable<? super V3>>
     SerializableComparator<T> fromFunctions(
         Function<? super T, ? extends V1> one,
         Function<? super T, ? extends V2> two,
         Function<? super T, ? extends V3> three) {
   return Comparators.chain(
       Comparators.<T, V1>byFunction(one),
       Comparators.<T, V2>byFunction(two),
       Comparators.<T, V3>byFunction(three));
 }
  public <K, V> ImmutableMap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3) {
    if (Comparators.nullSafeEquals(key1, key2) && Comparators.nullSafeEquals(key2, key3)) {
      return this.of(key1, value3);
    }
    if (Comparators.nullSafeEquals(key1, key2)) {
      return this.of(key1, value2, key3, value3);
    }
    if (Comparators.nullSafeEquals(key1, key3)) {
      return this.of(key2, value2, key1, value3);
    }
    if (Comparators.nullSafeEquals(key2, key3)) {
      return this.of(key1, value1, key2, value3);
    }

    return new ImmutableTripletonMap<K, V>(key1, value1, key2, value2, key3, value3);
  }
 @Test
 public void sortingWitoutAccessToInternalArray() {
   ThisIsNotAnArrayList<Integer> arrayListThatIsnt =
       new ThisIsNotAnArrayList<Integer>(FastList.newListWith(5, 3, 4, 1, 2));
   Verify.assertStartsWith(
       ArrayListIterate.sortThis(arrayListThatIsnt, Comparators.naturalOrder()), 1, 2, 3, 4, 5);
 }
 @Override
 public ImmutableSet<T> newWithout(T element) {
   if (this.contains(element)) {
     if (Comparators.nullSafeEquals(element, this.element1)) {
       return Sets.immutable.of(this.element2, this.element3, this.element4);
     }
     if (Comparators.nullSafeEquals(element, this.element2)) {
       return Sets.immutable.of(this.element1, this.element3, this.element4);
     }
     if (Comparators.nullSafeEquals(element, this.element3)) {
       return Sets.immutable.of(this.element1, this.element2, this.element4);
     }
     return Sets.immutable.of(this.element1, this.element2, this.element3);
   }
   return this;
 }
 @Test
 public void containsKey() {
   ImmutableSortedMap<Integer, String> map = this.classUnderTest();
   ImmutableSortedMap<Integer, String> revMap =
       this.classUnderTest(Comparators.<Integer>reverseNaturalOrder());
   Assert.assertFalse(map.containsKey(0));
   Assert.assertFalse(revMap.containsKey(1));
 }
  @Override
  @Test
  public void toSortedBagBy() {
    ImmutableBag<String> immutableBag = this.newBag();
    MutableSortedBag<String> sortedBag = immutableBag.toSortedBagBy(String::valueOf);
    TreeBag<Object> expectedBag = TreeBag.newBag(Comparators.byFunction(String::valueOf));

    Verify.assertSortedBagsEqual(expectedBag, sortedBag);
  }
  @Test
  public void keySet_copyKeys() {
    // a map with a null key
    MutableMap<Integer, Integer> map1 = this.newMapWithKeyValue(null, 0);
    Assert.assertArrayEquals(new Object[] {null}, map1.keySet().toArray());

    // a map with a chain containing empty slots
    MutableMap<Integer, Integer> map2 = this.mapWithCollisionsOfSize(5);
    Assert.assertArrayEquals(new Object[] {0, 17, 34, 51, 68}, map2.keySet().toArray());

    // a map with a chain containing empty slots and null key
    MutableMap<Integer, Integer> map3 = this.mapWithCollisionsOfSize(5);
    map3.put(null, 42);
    Integer[] array = map3.keySet().toArray(new Integer[map3.size()]);
    ArrayIterate.sort(
        array, array.length, Comparators.safeNullsHigh(Comparators.<Integer>naturalOrder()));
    Assert.assertArrayEquals(new Object[] {0, 17, 34, 51, 68, null}, array);
  }
 @Override
 public void equalsAndHashCode() {
   super.equalsAndHashCode();
   Verify.assertInstanceOf(
       UnmodifiableSortedBag.class,
       SerializeTestHelper.serializeDeserialize(
           this.newWith(Comparators.reverseNaturalOrder(), 1, 2, 3)));
   Verify.assertInstanceOf(
       UnmodifiableSortedBag.class,
       SerializeTestHelper.serializeDeserialize(this.newWith(1, 2, 3)));
 }
 @Benchmark
 public void parallel_eager_forkjoin_gsc() {
   MutableMultimap<Alphagram, String> groupBy = FJIterate.groupBy(this.gscWords, Alphagram::new);
   groupBy
       .multiValuesView()
       .select(iterable -> iterable.size() >= SIZE_THRESHOLD)
       .toSortedList(Comparators.<RichIterable<String>>byIntFunction(RichIterable::size))
       .asReversed()
       .collect(iterable -> iterable.size() + ": " + iterable)
       .forEach(Procedures.cast(e -> Assert.assertFalse(e.isEmpty())));
 }
  @Test
  public void toSortedBagBy_empty() {
    ImmutableBag<Integer> immutableBag = Bags.immutable.of();

    Function<Integer, Integer> function = object -> object * -1;
    MutableSortedBag<Integer> sortedBag = immutableBag.toSortedBagBy(function);
    sortedBag.addOccurrences(1, 3);
    sortedBag.addOccurrences(10, 2);

    Verify.assertSortedBagsEqual(
        TreeBag.newBagWith(Comparators.byFunction(function), 10, 10, 1, 1, 1), sortedBag);
  }
 public static <T, V extends Comparable<? super V>> SerializableComparator<T> byFunction(
     Function<? super T, ? extends V> function) {
   if (function instanceof IntFunction) {
     return Functions.toIntComparator((IntFunction<T>) function);
   }
   if (function instanceof DoubleFunction) {
     return Functions.toDoubleComparator((DoubleFunction<T>) function);
   }
   if (function instanceof LongFunction) {
     return Functions.toLongComparator((LongFunction<T>) function);
   }
   return Comparators.byFunction(function, naturalOrder());
 }
  @Test
  public void toSortedMap_with_comparator() {
    MutableSortedMap<Integer, String> map =
        this.newBag()
            .toSortedMap(
                Comparators.<Integer>reverseNaturalOrder(),
                Integer::valueOf,
                Functions.<String>getPassThru());

    Verify.assertMapsEqual(
        this.newBag().toMap(Integer::valueOf, Functions.<String>getPassThru()), map);
    Verify.assertListsEqual(Interval.fromTo(this.numKeys(), 1), map.keySet().toList());
  }
 @Benchmark
 public void parallel_lazy_gsc() {
   ParallelUnsortedBag<String> parallelUnsortedBag =
       this.gscWords.asParallel(this.executorService, BATCH_SIZE);
   UnsortedBagMultimap<Alphagram, String> groupBy = parallelUnsortedBag.groupBy(Alphagram::new);
   groupBy
       .multiValuesView()
       .select(iterable -> iterable.size() >= SIZE_THRESHOLD)
       .toSortedList(Comparators.<RichIterable<String>>byIntFunction(RichIterable::size))
       .asReversed()
       .collect(iterable -> iterable.size() + ": " + iterable)
       .forEach(Procedures.cast(e -> Assert.assertFalse(e.isEmpty())));
 }
  @Override
  @Test
  public void toArray() {
    super.toArray();

    int size = COLLISIONS.size();
    for (int i = 1; i < size; i++) {
      MutableSet<Integer> set =
          UnifiedSetWithHashingStrategy.newSet(INTEGER_HASHING_STRATEGY, SIZE)
              .withAll(COLLISIONS.subList(0, i));
      Object[] objects = set.toArray();
      Assert.assertEquals(set, UnifiedSet.newSetWith(objects));
    }

    MutableSet<Integer> deepChain =
        UnifiedSetWithHashingStrategy.newSetWith(
            INTEGER_HASHING_STRATEGY,
            COLLISION_1,
            COLLISION_2,
            COLLISION_3,
            COLLISION_4,
            COLLISION_5,
            COLLISION_6);
    Assert.assertArrayEquals(
        new Integer[] {
          COLLISION_1, COLLISION_2, COLLISION_3, COLLISION_4, COLLISION_5, COLLISION_6
        },
        deepChain.toArray());

    MutableSet<Integer> minimumChain =
        UnifiedSetWithHashingStrategy.newSetWith(
            INTEGER_HASHING_STRATEGY, COLLISION_1, COLLISION_2);
    minimumChain.remove(COLLISION_2);
    Assert.assertArrayEquals(new Integer[] {COLLISION_1}, minimumChain.toArray());

    MutableSet<Integer> set =
        UnifiedSetWithHashingStrategy.newSetWith(
            INTEGER_HASHING_STRATEGY, COLLISION_1, COLLISION_2, COLLISION_3, COLLISION_4);
    Integer[] target = {
      Integer.valueOf(1),
      Integer.valueOf(1),
      Integer.valueOf(1),
      Integer.valueOf(1),
      Integer.valueOf(1),
      Integer.valueOf(1)
    };
    Integer[] actual = set.toArray(target);
    ArrayIterate.sort(actual, actual.length, Comparators.safeNullsHigh(Integer::compareTo));
    Assert.assertArrayEquals(
        new Integer[] {COLLISION_1, 1, COLLISION_2, COLLISION_3, COLLISION_4, null}, actual);
  }
  @Override
  @Test
  public void iterator() {
    MutableSortedBag<Integer> bag = this.newWith(-1, 0, 1, 1, 2);
    Iterator<Integer> iterator = bag.iterator();
    Assert.assertTrue(iterator.hasNext());
    Assert.assertEquals(Integer.valueOf(-1), iterator.next());
    Assert.assertTrue(iterator.hasNext());
    Assert.assertEquals(Integer.valueOf(0), iterator.next());
    Assert.assertTrue(iterator.hasNext());
    Assert.assertEquals(Integer.valueOf(1), iterator.next());
    Assert.assertTrue(iterator.hasNext());
    Assert.assertEquals(Integer.valueOf(1), iterator.next());
    Assert.assertTrue(iterator.hasNext());
    Assert.assertEquals(Integer.valueOf(2), iterator.next());
    Assert.assertFalse(iterator.hasNext());

    MutableSortedBag<Integer> revBag =
        this.newWith(Comparators.reverseNaturalOrder(), -1, 0, 1, 1, 2);
    Iterator<Integer> revIterator = revBag.iterator();
    Assert.assertTrue(revIterator.hasNext());
    Assert.assertEquals(Integer.valueOf(2), revIterator.next());
    Assert.assertTrue(revIterator.hasNext());
    Assert.assertEquals(Integer.valueOf(1), revIterator.next());
    Assert.assertTrue(revIterator.hasNext());
    Assert.assertEquals(Integer.valueOf(1), revIterator.next());
    Assert.assertTrue(revIterator.hasNext());
    Assert.assertEquals(Integer.valueOf(0), revIterator.next());
    Assert.assertTrue(revIterator.hasNext());
    Assert.assertEquals(Integer.valueOf(-1), revIterator.next());
    Assert.assertFalse(revIterator.hasNext());

    Iterator<Integer> iterator3 =
        this.newWith(Comparators.reverseNaturalOrder(), 2, 1, 1, 0, -1).iterator();
    Verify.assertThrows(UnsupportedOperationException.class, iterator3::remove);
    Assert.assertEquals(Integer.valueOf(2), iterator3.next());
    Verify.assertThrows(UnsupportedOperationException.class, iterator3::remove);
  }
 @Warmup(iterations = 20)
 @Measurement(iterations = 10)
 @Benchmark
 public void serial_eager_gsc() {
   MutableListMultimap<Alphagram, String> groupBy =
       this.gscWords.groupBy(Alphagram::new, FastListMultimap.newMultimap());
   groupBy
       .multiValuesView()
       .select(iterable -> iterable.size() >= SIZE_THRESHOLD)
       .toSortedList(Comparators.<RichIterable<String>>byIntFunction(RichIterable::size))
       .asReversed()
       .collect(iterable -> iterable.size() + ": " + iterable)
       .forEach(Procedures.cast(e -> Assert.assertFalse(e.isEmpty())));
 }
  @Override
  @Test
  public void rejectMap() {
    ImmutableSortedMap<Integer, String> map = this.classUnderTest();
    ImmutableSortedMap<Integer, String> actual = map.reject(Predicates2.alwaysFalse());
    Verify.assertInstanceOf(ImmutableEmptySortedMap.class, actual);
    Assert.assertSame(ImmutableEmptySortedMap.INSTANCE, actual);

    ImmutableSortedMap<Integer, String> revMap =
        this.classUnderTest(Comparators.<Integer>reverseNaturalOrder());
    ImmutableSortedMap<Integer, String> revActual = revMap.reject(Predicates2.alwaysTrue());
    Verify.assertInstanceOf(ImmutableEmptySortedMap.class, revActual);
    Assert.assertSame(revMap.comparator(), revActual.comparator());
  }
  @Override
  @Test
  public void collectMap() {
    ImmutableSortedMap<Integer, String> map = this.classUnderTest();
    ImmutableSortedMap<Integer, String> revMap =
        this.classUnderTest(Comparators.<Integer>reverseNaturalOrder());

    Function2<Integer, String, Pair<Integer, String>> alwaysTrueFunction = Tuples::pair;
    ImmutableMap<Integer, String> collect = map.collect(alwaysTrueFunction);
    ImmutableMap<Integer, String> revCollect = revMap.collect(alwaysTrueFunction);

    Verify.assertEmpty(collect);
    Assert.assertSame(collect, revCollect);
  }
 @Override
 protected boolean randomAccessListEquals(List<?> otherList) {
   if (this.size() != otherList.size()) {
     return false;
   }
   for (int i = 0; i < this.size(); i++) {
     T one = this.items[i];
     Object two = otherList.get(i);
     if (!Comparators.nullSafeEquals(one, two)) {
       return false;
     }
   }
   return true;
 }
  @Test
  public void serialization() {
    ImmutableSortedMap<Integer, String> map = this.classUnderTest();
    ImmutableSortedMap<Integer, String> deserialized =
        SerializeTestHelper.serializeDeserialize(map);
    Assert.assertSame(ImmutableEmptySortedMap.INSTANCE, map);
    Assert.assertSame(map, deserialized);

    ImmutableSortedMap<Integer, String> revMap =
        this.classUnderTest(Comparators.<Integer>reverseNaturalOrder());
    ImmutableSortedMap<Integer, String> revDeserialized =
        SerializeTestHelper.serializeDeserialize(revMap);
    Verify.assertInstanceOf(ImmutableSortedMap.class, revDeserialized);
    Assert.assertNotNull(revDeserialized.comparator());
  }
 @Override
 protected boolean regularListEquals(List<?> otherList) {
   Iterator<?> iterator = otherList.iterator();
   for (int i = 0; i < this.size(); i++) {
     T one = this.items[i];
     if (!iterator.hasNext()) {
       return false;
     }
     Object two = iterator.next();
     if (!Comparators.nullSafeEquals(one, two)) {
       return false;
     }
   }
   return !iterator.hasNext();
 }