@Benchmark
 public void gsc() {
   MutableList<Integer> result = FastList.newList();
   for (int i = 0; i < 1000; i++) {
     result.addAll(this.integersGSC);
   }
 }
  @Test
  public void keySet_retainAll() {
    // a map with a null key
    MutableMap<Integer, Integer> map = this.newMapWithKeyValue(null, 0);

    MutableList<Object> retained = Lists.mutable.of();
    retained.add(null);
    Assert.assertFalse(map.keySet().retainAll(retained));
    Verify.assertContains(null, map.keySet());

    // a map with a chain containing empty slots
    MutableMap<Integer, Integer> map2 = this.mapWithCollisionsOfSize(5);
    Assert.assertFalse(map2.keySet().retainAll(FastList.<Integer>newListWith(0, 17, 34, 51, 68)));
    Verify.assertContainsAll(map2.keySet(), 0, 17, 34, 51, 68);

    // a map with no chaining, nothing retained
    MutableMap<Integer, String> map3 = this.newMapWithKeyValue(1, "One");
    Assert.assertTrue(map3.keySet().retainAll(FastList.<Integer>newListWith(9)));
    Verify.assertEmpty(map3);

    Set<Integer> keys =
        this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four").keySet();
    Assert.assertTrue(keys.retainAll(FastList.<Integer>newListWith(1, 2, 3)));
    Verify.assertContainsAll(keys, 1, 2, 3);
  }
 @Test
 public void testContainsAll() {
   MutableList<String> list = new CompositeFastList<String>();
   list.addAll(FastList.newListWith("1", "2", "3", "4"));
   list.addAll(FastList.newListWith("3", "B", "3", "B"));
   Assert.assertTrue(list.containsAll(FastList.newList().with("2", "B")));
 }
  private static void runUnifiedSetRetainAllFromList(int shift) {
    MultiReaderUnifiedSet<CollidingInt> set = MultiReaderUnifiedSet.newSet();

    MutableList<CollidingInt> toRetain = Lists.mutable.of();

    int size = 100000;
    for (int i = 0; i < size; i++) {
      set.add(new CollidingInt(i, shift));
      if (i % 2 == 0) {
        toRetain.add(new CollidingInt(i, shift));
      }
    }
    Verify.assertSize(size, set);
    Assert.assertTrue(set.containsAll(toRetain));

    Assert.assertTrue(set.retainAll(toRetain));
    Assert.assertTrue(set.containsAll(toRetain));

    Assert.assertFalse(set.retainAll(toRetain)); // a second call should not modify the set

    Verify.assertSize(size / 2, set);

    for (int i = 0; i < size; i += 2) {
      Verify.assertContains(new CollidingInt(i, shift), set);
    }
  }
 private void executeParallelIterate(int level, ExecutorService executorService) {
   MutableList<Integer> items = Lists.mutable.of();
   for (int i = 0; i < 20000; i++) {
     items.add(i % 1000 == 0 ? level : 0);
   }
   ParallelIterate.forEach(items, new RecursiveProcedure(), executorService);
 }
 @Test
 public void testDefaultConstructor() {
   MutableList<String> list = new CompositeFastList<String>();
   list.add("1");
   list.add("2");
   Verify.assertSize(2, list);
   Verify.assertContains("1", list);
 }
 @Test
 public void toArray() {
   ImmutableCollection<Integer> integers = this.classUnderTest();
   MutableList<Integer> copy = FastList.newList(integers);
   Assert.assertArrayEquals(integers.toArray(), copy.toArray());
   Assert.assertArrayEquals(
       integers.toArray(new Integer[integers.size()]), copy.toArray(new Integer[integers.size()]));
 }
 public <V> MutableList<V> collect(BooleanToObjectFunction<? extends V> function) {
   MutableList<V> results = FastList.newList(BooleanArrayList.this.size);
   BooleanIterator iterator = this.booleanIterator();
   while (iterator.hasNext()) {
     results.add(function.valueOf(iterator.next()));
   }
   return results;
 }
  @Override
  @Test
  public void newListWithSize() {
    super.newListWithSize();

    MutableList<Integer> objects = ArrayListAdapter.<Integer>newList(4).with(1, 2, 3);
    Assert.assertEquals(1, objects.indexOf(2));
  }
 @Test
 public void toSortedList() {
   ImmutableBag<String> strings = this.newBag();
   MutableList<String> copy = FastList.newList(strings);
   MutableList<String> list = strings.toSortedList(Collections.<String>reverseOrder());
   Assert.assertEquals(copy.sortThis(Collections.<String>reverseOrder()), list);
   MutableList<String> list2 = strings.toSortedList();
   Assert.assertEquals(copy.sortThis(), list2);
 }
 @Test
 public void toSortedList() {
   ImmutableCollection<Integer> integers = this.classUnderTest();
   MutableList<Integer> copy = FastList.newList(integers);
   MutableList<Integer> list = integers.toSortedList(Collections.<Integer>reverseOrder());
   Assert.assertEquals(copy.sortThis(Collections.<Integer>reverseOrder()), list);
   MutableList<Integer> list2 = integers.toSortedList();
   Assert.assertEquals(copy.sortThis(), list2);
 }
  @Override
  @Test
  public void testClone() {
    super.testClone();

    MutableList<Integer> list = this.newWith(1, 2, 3);
    MutableList<Integer> list2 = list.clone();
    Verify.assertListsEqual(list, list2);
  }
 @Override
 @Test
 public void retainAll() {
   super.retainAll();
   MutableList<String> list = new CompositeFastList<String>();
   list.addAll(FastList.newListWith("1", "2", "3", "4"));
   list.addAll(FastList.newListWith("3", "B", "3", "B"));
   list.retainAll(FastList.newList().with("2", "B"));
   Verify.assertSize(3, list);
 }
 protected static MutableList<String> generateCollisions() {
   MutableList<String> collisions = FastList.newList();
   ObjectBooleanHashMap<String> hashMap = new ObjectBooleanHashMap<String>();
   for (int each = 3; collisions.size() <= 10; each++) {
     if (hashMap.index(String.valueOf(each)) == hashMap.index(String.valueOf(3))) {
       collisions.add(String.valueOf(each));
     }
   }
   return collisions;
 }
  @Override
  @Test
  public void removeIf() {
    super.removeIf();

    MutableList<Integer> objects = this.newWith(1, 2, 3, null);
    objects.removeIf(Predicates.isNull());
    Verify.assertSize(3, objects);
    Verify.assertContainsAll(objects, 1, 2, 3);
  }
  @Test
  @Override
  public void subList() {
    // Not serializable

    MutableList<String> list = this.newWith("A", "B", "C", "D");
    MutableList<String> sublist = list.subList(1, 3);
    Verify.assertSize(2, sublist);
    Verify.assertContainsAll(sublist, "B", "C");
    sublist.add("X");
    Verify.assertSize(3, sublist);
    Verify.assertContainsAll(sublist, "B", "C", "X");
    Verify.assertSize(5, list);
    Verify.assertContainsAll(list, "A", "B", "C", "X", "D");
    sublist.remove("X");
    Verify.assertContainsAll(sublist, "B", "C");
    Verify.assertContainsAll(list, "A", "B", "C", "D");
    Assert.assertEquals("C", sublist.set(1, "R"));
    Verify.assertContainsAll(sublist, "B", "R");
    Verify.assertContainsAll(list, "A", "B", "R", "D");
    sublist.addAll(Arrays.asList("W", "G"));
    Verify.assertContainsAll(sublist, "B", "R", "W", "G");
    Verify.assertContainsAll(list, "A", "B", "R", "W", "G", "D");
    sublist.clear();
    Verify.assertEmpty(sublist);
    Assert.assertFalse(sublist.remove("X"));
    Verify.assertEmpty(sublist);
    Verify.assertContainsAll(list, "A", "D");
  }
  // find element in sorted list
  private static void testBinarySearch() {
    List<String> list = Lists.newArrayList("2", "4", "13", "31", "43");
    MutableList<String> mutableList = FastList.newListWith("2", "4", "13", "31", "43");

    // find element in sorted list
    int jdk = Collections.binarySearch(list, "13");
    int guava = Ordering.natural().binarySearch(list, "13");
    int gs = mutableList.binarySearch("13");

    System.out.println("find = " + jdk + ":" + guava + ":" + gs); // print find = 2:2:2
  }
  @Test
  public void flatten_value() {
    MutableMap<String, String> map = this.newMapWithKeysValues("1", "One", "2", "Two");

    Function<String, Iterable<Character>> function =
        object -> {
          MutableList<Character> result = Lists.mutable.of();
          if (object != null) {
            char[] chars = object.toCharArray();
            for (char aChar : chars) {
              result.add(Character.valueOf(aChar));
            }
          }
          return result;
        };

    RichIterable<Character> blob = map.flatCollect(function);
    RichIterable<Character> blobFromTarget =
        map.flatCollect(function, FastList.<Character>newList());

    switch (map.size()) {
      case 1:
        Assert.assertTrue(
            blob.containsAllArguments(
                Character.valueOf('O'), Character.valueOf('n'), Character.valueOf('e')));
        Assert.assertTrue(
            blobFromTarget.containsAllArguments(
                Character.valueOf('O'), Character.valueOf('n'), Character.valueOf('e')));
        break;
      case 2:
      case 3:
        Assert.assertTrue(
            blob.containsAllArguments(
                Character.valueOf('O'),
                Character.valueOf('n'),
                Character.valueOf('e'),
                Character.valueOf('T'),
                Character.valueOf('w'),
                Character.valueOf('o')));
        Assert.assertTrue(
            blobFromTarget.containsAllArguments(
                Character.valueOf('O'),
                Character.valueOf('n'),
                Character.valueOf('e'),
                Character.valueOf('T'),
                Character.valueOf('w'),
                Character.valueOf('o')));
        break;
      default:
        Assert.assertEquals(0, blob.size());
        Assert.assertEquals(0, blobFromTarget.size());
        break;
    }
  }
 @Test
 public void remove() {
   for (int i = 1; i < COLLISIONS.size(); i++) {
     MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
     Assert.assertNull(map.put(null, null));
     Assert.assertNull(map.remove(null));
     Assert.assertNull(map.remove(COLLISION_10));
     Integer biggestValue = COLLISIONS.get(i - 1);
     Assert.assertEquals(biggestValue, map.remove(biggestValue));
   }
 }
 @Override
 @Test
 public void lastIndexOf() {
   super.lastIndexOf();
   MutableList<String> list = new CompositeFastList<String>();
   list.addAll(FastList.newListWith("1", "2", "3", "4"));
   list.addAll(FastList.newListWith("3", "B", "3", "B"));
   Assert.assertEquals(6, list.lastIndexOf("3"));
   Assert.assertEquals(3, list.lastIndexOf("4"));
   Assert.assertEquals(-1, list.lastIndexOf("missing"));
 }
 @Override
 @Test
 public void clear() {
   super.clear();
   MutableList<String> list = new CompositeFastList<String>();
   list.addAll(FastList.newListWith("1", "2", "3", "4"));
   list.addAll(FastList.newListWith("3", "B", "3", "B"));
   list.clear();
   Assert.assertTrue(list.isEmpty());
   Assert.assertEquals(0, list.size());
 }
 @Test
 public void forEachWithIndex() {
   int[] indexSum = new int[1];
   MutableList<String> result = Lists.mutable.of();
   MutableSet<String> source = Sets.fixedSize.of("1", "2", "3", "4");
   source.forEachWithIndex(
       (each, index) -> {
         result.add(each);
         indexSum[0] += index;
       });
   Assert.assertEquals(FastList.newListWith("1", "2", "3", "4"), result);
   Assert.assertEquals(6, indexSum[0]);
 }
 @Override
 @Test
 public void forEachWithIndex() {
   super.forEachWithIndex();
   MutableList<Integer> list = FastList.newList();
   CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
   iterables.addComposited(Interval.fromTo(6, 10).toList());
   iterables.addComposited(Interval.oneTo(5).toList());
   iterables.forEachWithIndex((each, index) -> list.add(index, each));
   Verify.assertSize(10, list);
   Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
   Verify.assertStartsWith(list, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5);
 }
 @Override
 @Test
 public void forEachWith() {
   super.forEachWith();
   MutableList<Integer> list = FastList.newList();
   CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
   iterables.addComposited(Interval.fromTo(6, 10).toList());
   iterables.addComposited(Interval.oneTo(5).toList());
   iterables.forEachWith((each, parameter) -> list.add(parameter.intValue(), each), 0);
   Verify.assertSize(10, list);
   Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
   Verify.assertStartsWith(list, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6);
 }
  // find element in unsorted collection
  private static void testSearch() {
    Collection<String> collection = Lists.newArrayList("2", "14", "3", "13", "43");
    MutableList<String> mutableList = FastList.newListWith("2", "14", "3", "13", "43");
    Iterable<String> iterable = collection;

    // find element in unsorted collection
    String jdk = collection.stream().filter("13"::equals).findFirst().get();
    String guava = Iterables.find(iterable, "13"::equals);
    String apache = CollectionUtils.find(iterable, "13"::equals);
    String gs = mutableList.select("13"::equals).get(0);

    System.out.println(
        "find = " + jdk + ":" + guava + ":" + apache + ":" + gs); // print find = 13:13:13:13
  }
  @Override
  @Test
  public void retainAllFromEntrySet() {
    super.retainAllFromEntrySet();

    for (int i = 1; i < COLLISIONS.size(); i++) {
      MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);

      Assert.assertFalse(
          map.entrySet()
              .retainAll(
                  FastList.newList(map.entrySet())
                      .with(ImmutableEntry.of(COLLISION_10, COLLISION_10))));

      Assert.assertTrue(map.entrySet().retainAll(this.mapWithCollisionsOfSize(i - 1).entrySet()));
      Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);
    }

    // simple map, collection to retain contains non-entry element
    MutableMap<Integer, String> map4 = this.newMapWithKeysValues(1, "One", 2, "Two");
    FastList<Object> toRetain =
        FastList.<Object>newListWith(
            ImmutableEntry.of(1, "One"), "explosion!", ImmutableEntry.of(2, "Two"));
    Assert.assertFalse(map4.entrySet().retainAll(toRetain));
  }
  @Test
  public void contains_key_and_value() {
    for (int i = 1; i < COLLISIONS.size(); i++) {
      MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);

      Assert.assertTrue(map.containsKey(COLLISIONS.get(i - 1)));
      Assert.assertTrue(map.containsValue(COLLISIONS.get(i - 1)));
      Assert.assertFalse(map.containsKey(COLLISION_10));
      Assert.assertFalse(map.containsValue(COLLISION_10));
      Assert.assertFalse(map.containsKey(null));
      Assert.assertFalse(map.containsValue(null));

      map.put(null, null);
      Assert.assertTrue(map.containsKey(null));
      Assert.assertTrue(map.containsValue(null));
    }
  }
  @Override
  @Test
  public void removeFromEntrySet() {
    super.removeFromEntrySet();

    for (int i = 1; i < COLLISIONS.size(); i++) {
      MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);

      Integer biggestValue = COLLISIONS.get(i - 1);

      Assert.assertTrue(map.entrySet().remove(ImmutableEntry.of(biggestValue, biggestValue)));
      Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);

      Assert.assertFalse(map.entrySet().remove(ImmutableEntry.of(COLLISION_10, COLLISION_10)));
      Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);

      Assert.assertFalse(map.entrySet().remove(null));
    }
  }
 @Test
 public void testAddWithIndex() {
   MutableList<String> list = new CompositeFastList<String>();
   list.addAll(FastList.newListWith("1", "2", "3", "4"));
   list.addAll(FastList.newListWith("A", "B", "C", "B"));
   list.add(3, "NEW");
   Verify.assertSize(9, list);
   Assert.assertEquals("NEW", list.get(3));
   Assert.assertEquals("4", list.get(4));
   list.add(0, "START");
   Verify.assertSize(10, list);
   Assert.assertEquals("START", list.getFirst());
   list.add(10, "END");
   Verify.assertSize(11, list);
   Assert.assertEquals("END", list.getLast());
 }
  private static void assertUnifiedSetForEachWith(int shift) {
    MultiReaderUnifiedSet<CollidingInt> set = MultiReaderUnifiedSet.newSet();

    int size = 100000;
    for (int i = 0; i < size; i++) {
      Assert.assertTrue(set.add(new CollidingInt(i, shift)));
    }
    MutableList<CollidingInt> keys = FastList.newList(size);
    set.forEachWith(
        (key, s) -> {
          Assert.assertEquals("foo", s);
          keys.add(key);
        },
        "foo");
    Verify.assertSize(size, keys);
    Collections.sort(keys);

    for (int i = 0; i < size; i++) {
      Verify.assertItemAtIndex(new CollidingInt(i, shift), i, keys);
    }
  }