@Test
 public void collectOnFromToInterval() {
   Interval interval = Interval.oneTo(5);
   LazyIterable<String> result = interval.collect(String::valueOf);
   Verify.assertIterableSize(5, result);
   Verify.assertContainsAll(result, "1", "5");
 }
 @Test
 public void removeUsingPredicate() {
   MutableList<Integer> objects = MultiReaderFastList.newListWith(1, 2, 3, null);
   Assert.assertTrue(objects.removeIf(Predicates.isNull()));
   Verify.assertSize(3, objects);
   Verify.assertContainsAll(objects, 1, 2, 3);
 }
 @Test
 public void addingAllToOtherList() {
   MutableList<String> newList = FastList.newList(this.list);
   newList.add("2");
   Verify.assertItemAtIndex("1", 0, newList);
   Verify.assertItemAtIndex("2", 1, newList);
 }
 @Override
 @Test
 public void isEmpty() {
   Verify.assertEmpty(MultiReaderFastList.newList());
   Verify.assertNotEmpty(MultiReaderFastList.newListWith(1, 2));
   Assert.assertTrue(MultiReaderFastList.newListWith(1, 2).notEmpty());
 }
 @Test
 public void selectWith() {
   Verify.assertContainsAll(
       SingletonListTest.newWith(1).selectWith(Predicates2.<Integer>lessThan(), 3), 1);
   Verify.assertEmpty(
       SingletonListTest.newWith(1).selectWith(Predicates2.<Integer>greaterThan(), 3));
 }
 @Override
 @Test
 public void reject() {
   Verify.assertContainsAll(this.newWith(1, 2, 3, 4).reject(Predicates.lessThan(3)), 3, 4);
   Verify.assertContainsAll(
       this.newWith(1, 2, 3, 4).reject(Predicates.lessThan(3), UnifiedSet.newSet()), 3, 4);
 }
  @Test
  public void drop() {
    Assert.assertEquals(FastList.newListWith(3, 4), Interval.fromTo(1, 4).drop(2));
    Verify.assertIterableEmpty(Interval.fromTo(1, 2).drop(3));

    Verify.assertThrows(IllegalArgumentException.class, () -> Interval.fromTo(1, 3).drop(-1));
  }
 @Test
 public void iterator() {
   Interval zero = Interval.zero();
   Iterator<Integer> zeroIterator = zero.iterator();
   Assert.assertTrue(zeroIterator.hasNext());
   Assert.assertEquals(Integer.valueOf(0), zeroIterator.next());
   Assert.assertFalse(zeroIterator.hasNext());
   Interval oneToFive = Interval.oneTo(5);
   Iterator<Integer> oneToFiveIterator = oneToFive.iterator();
   for (int i = 1; i < 6; i++) {
     Assert.assertTrue(oneToFiveIterator.hasNext());
     Assert.assertEquals(Integer.valueOf(i), oneToFiveIterator.next());
   }
   Verify.assertThrows(NoSuchElementException.class, (Runnable) oneToFiveIterator::next);
   Interval threeToNegativeThree = Interval.fromTo(3, -3);
   Iterator<Integer> threeToNegativeThreeIterator = threeToNegativeThree.iterator();
   for (int i = 3; i > -4; i--) {
     Assert.assertTrue(threeToNegativeThreeIterator.hasNext());
     Assert.assertEquals(Integer.valueOf(i), threeToNegativeThreeIterator.next());
   }
   Verify.assertThrows(
       NoSuchElementException.class, (Runnable) threeToNegativeThreeIterator::next);
   Verify.assertThrows(
       UnsupportedOperationException.class, () -> Interval.zeroTo(10).iterator().remove());
 }
 @Test
 public void toSet() {
   Interval interval = Interval.evensFromTo(0, 10);
   MutableSet<Integer> set = interval.toSet();
   Verify.assertContainsAll(set, 0, 2, 4, 6, 8, 10);
   Verify.assertSize(6, set);
 }
 @Test
 public void toFastList() {
   Interval interval = Interval.evensFromTo(0, 10);
   FastList<Integer> toList = (FastList<Integer>) interval.toList();
   Verify.assertStartsWith(toList, 0, 2, 4, 6, 8, 10);
   Verify.assertSize(6, toList);
 }
 @Test
 public void selectAndRejectWith() {
   MutableList<Integer> objects = SingletonListTest.newWith(1);
   Twin<MutableList<Integer>> result = objects.selectAndRejectWith(Object::equals, 1);
   Verify.assertSize(1, result.getOne());
   Verify.assertEmpty(result.getTwo());
 }
 @Test
 public void toArray() {
   MutableList<Integer> objects = SingletonListTest.newWith(1);
   Object[] array = objects.toArray();
   Verify.assertSize(1, array);
   Integer[] array2 = objects.toArray(new Integer[1]);
   Verify.assertSize(1, array2);
 }
 @Test
 public void rejectWith() {
   Verify.assertEmpty(SingletonListTest.newWith(1).rejectWith(Predicates2.<Integer>lessThan(), 3));
   Verify.assertContainsAll(
       SingletonListTest.newWith(1)
           .rejectWith(Predicates2.<Integer>greaterThan(), 3, UnifiedSet.<Integer>newSet()),
       1);
 }
 @Test
 public void toMap() {
   MutableList<Integer> integers = SingletonListTest.newWith(1);
   MutableMap<Integer, Integer> map =
       integers.toMap(Functions.getIntegerPassThru(), Functions.getIntegerPassThru());
   Verify.assertContainsAll(map.keySet(), 1);
   Verify.assertContainsAll(map.values(), 1);
 }
 @Override
 @Test
 public void clear() {
   MutableList<Integer> integers = this.newWith(1, 2, 3, 4);
   Verify.assertNotEmpty(integers);
   integers.clear();
   Verify.assertEmpty(integers);
 }
 @Test
 public void without() {
   MutableList<Integer> list = new SingletonList<>(2);
   Assert.assertSame(list, list.without(9));
   list = list.without(2);
   Verify.assertListsEqual(Lists.mutable.of(), list);
   Verify.assertInstanceOf(EmptyList.class, list);
 }
 @Override
 @Test
 public void removeIfWith() {
   MutableList<Integer> objects = MultiReaderFastList.newListWith(1, 2, 3, null);
   Assert.assertTrue(objects.removeIfWith((each, ignored) -> each == null, null));
   Verify.assertSize(3, objects);
   Verify.assertContainsAll(objects, 1, 2, 3);
 }
 @Test
 public void serializationOfSublist() {
   MutableList<Integer> collection = this.newWith(1, 2, 3, 4, 5);
   MutableList<Integer> deserializedCollection =
       SerializeTestHelper.serializeDeserialize(collection.subList(0, 2));
   Verify.assertSize(2, deserializedCollection);
   Verify.assertStartsWith(deserializedCollection, 1, 2);
   Assert.assertEquals(collection.subList(0, 2), deserializedCollection);
 }
 @Test
 public void fromAndToAndBy() {
   Interval interval = Interval.from(1);
   Interval interval2 = interval.to(10);
   Interval interval3 = interval2.by(2);
   Verify.assertEqualsAndHashCode(interval, Interval.fromTo(1, 1));
   Verify.assertEqualsAndHashCode(interval2, Interval.fromTo(1, 10));
   Verify.assertEqualsAndHashCode(interval3, Interval.fromToBy(1, 10, 2));
 }
 @Test
 public void collectIf() {
   Verify.assertContainsAll(
       SingletonListTest.newWith(1).collectIf(Integer.class::isInstance, String::valueOf), "1");
   Verify.assertContainsAll(
       SingletonListTest.newWith(1)
           .collectIf(Integer.class::isInstance, String::valueOf, FastList.<String>newList()),
       "1");
 }
 @Override
 @Test
 public void selectAndRejectWith() {
   MutableList<Integer> list = this.getIntegerList();
   Twin<MutableList<Integer>> result =
       list.selectAndRejectWith(Predicates2.in(), Lists.fixedSize.of(1));
   Verify.assertSize(1, result.getOne());
   Verify.assertSize(4, result.getTwo());
 }
 @Override
 @Test
 public void addAllAtIndex() {
   MutableList<Integer> integers = this.newWith(5);
   integers.addAll(0, Lists.fixedSize.of(1, 2, 3, 4));
   Verify.assertStartsWith(integers, 1, 2, 3, 4, 5);
   integers.addAll(0, this.newWith(-3, -2, -1, 0));
   Verify.assertStartsWith(integers, -3, -2, -1, 0, 1, 2, 3, 4, 5);
 }
 @Override
 @Test
 public void serialization() {
   MutableList<Integer> collection = this.newWith(1, 2, 3, 4, 5);
   MutableList<Integer> deserializedCollection =
       SerializeTestHelper.serializeDeserialize(collection);
   Verify.assertSize(5, deserializedCollection);
   Verify.assertStartsWith(deserializedCollection, 1, 2, 3, 4, 5);
   Assert.assertEquals(collection, deserializedCollection);
 }
 @Test
 public void flatCollect() {
   Function<Integer, MutableSet<String>> function =
       object -> UnifiedSet.newSetWith(object.toString());
   Verify.assertListsEqual(
       FastList.newListWith("1"), SingletonListTest.newWith(1).flatCollect(function));
   Verify.assertSetsEqual(
       UnifiedSet.newSetWith("1"),
       SingletonListTest.newWith(1).flatCollect(function, UnifiedSet.<String>newSet()));
 }
 @Test
 public void toSortedList() {
   MutableList<Integer> integers = SingletonListTest.newWith(1);
   MutableList<Integer> list = integers.toSortedList(Collections.<Integer>reverseOrder());
   Verify.assertStartsWith(list, 1);
   Assert.assertNotSame(integers, list);
   MutableList<Integer> list2 = integers.toSortedList();
   Verify.assertStartsWith(list2, 1);
   Assert.assertNotSame(integers, list2);
 }
 @Test
 public void copySet() {
   Verify.assertInstanceOf(ImmutableSet.class, Sets.immutable.ofAll(Sets.fixedSize.of()));
   MutableSet<Integer> set = Sets.fixedSize.of(1);
   ImmutableSet<Integer> immutableSet = set.toImmutable();
   Verify.assertInstanceOf(ImmutableSet.class, Sets.immutable.ofAll(set));
   Verify.assertInstanceOf(
       ImmutableSet.class, Sets.immutable.ofAll(UnifiedSet.newSetWith(1, 2, 3, 4, 5)));
   Assert.assertSame(Sets.immutable.ofAll(immutableSet.castToSet()), immutableSet);
 }
 @Test
 public void forEachOnFromToByInterval2() {
   List<Integer> result = new ArrayList<>();
   Interval interval = Interval.fromToBy(5, 1, -2);
   interval.forEach(CollectionAddProcedure.on(result));
   Verify.assertSize(3, result);
   Verify.assertContains(1, result);
   Verify.assertNotContains(2, result);
   Verify.assertContains(5, result);
 }
 @Test
 public void sortThisOnListWithMoreThan9Elements() {
   MutableList<Integer> integers = this.newWith(2, 3, 4, 1, 5, 7, 6, 8, 10, 9);
   Verify.assertStartsWith(integers.sortThis(), 1, 2, 3, 4);
   MutableList<Integer> integers2 = this.newWith(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   Verify.assertStartsWith(
       integers2.sortThis(Collections.reverseOrder()), 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
   MutableList<Integer> integers3 = this.newWith(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   Verify.assertStartsWith(integers3.sortThis(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 }
 @Test
 public void sortThisOnListWithLessThan10Elements() {
   MutableList<Integer> integers = this.newWith(2, 3, 4, 1, 7, 9, 6, 8, 5);
   Verify.assertStartsWith(integers.sortThis(), 1, 2, 3, 4, 5, 6, 7, 8, 9);
   MutableList<Integer> integers2 = this.newWith(1, 2, 3, 4, 5, 6, 7, 8, 9);
   Verify.assertStartsWith(
       integers2.sortThis(Collections.reverseOrder()), 9, 8, 7, 6, 5, 4, 3, 2, 1);
   MutableList<Integer> integers3 = this.newWith(1, 2, 3, 4, 5, 6, 7, 8, 9);
   Verify.assertStartsWith(integers3.sortThis(), 1, 2, 3, 4, 5, 6, 7, 8, 9);
   Verify.assertInstanceOf(MultiReaderFastList.class, integers3.sortThis());
 }
 @Test
 public void addAllEmpty() {
   MutableList<Integer> integers = MultiReaderFastList.newList();
   integers.addAll(Lists.fixedSize.of());
   Verify.assertEmpty(integers);
   integers.addAll(Sets.fixedSize.of());
   Verify.assertEmpty(integers);
   integers.addAll(FastList.newList());
   Verify.assertEmpty(integers);
   integers.addAll(ArrayAdapter.newArray());
   Verify.assertEmpty(integers);
 }