@Test
 public void forEachWithIndexUsingFromToWithOptimisableList() {
   ArrayList<Integer> optimisableList = Interval.oneTo(105).addAllTo(new ArrayList<Integer>());
   final ArrayList<Integer> expected = Interval.oneTo(105).addAllTo(new ArrayList<Integer>());
   ArrayList<Integer> results = new ArrayList<Integer>();
   ArrayListIterate.forEachWithIndex(
       optimisableList,
       0,
       104,
       ObjectIntProcedures.fromProcedure(CollectionAddProcedure.on(results)));
   Assert.assertEquals(expected, results);
   MutableList<Integer> reverseResults = Lists.mutable.of();
   final ObjectIntProcedure<Integer> objectIntProcedure =
       ObjectIntProcedures.fromProcedure(CollectionAddProcedure.on(reverseResults));
   ArrayListIterate.forEachWithIndex(expected, 104, 0, objectIntProcedure);
   Assert.assertEquals(ListIterate.reverseThis(expected), reverseResults);
   Verify.assertThrows(
       IndexOutOfBoundsException.class,
       new Runnable() {
         public void run() {
           ArrayListIterate.forEachWithIndex(expected, 104, -1, objectIntProcedure);
         }
       });
   Verify.assertThrows(
       IndexOutOfBoundsException.class,
       new Runnable() {
         public void run() {
           ArrayListIterate.forEachWithIndex(expected, -1, 104, objectIntProcedure);
         }
       });
 }
 @Test
 public void forEachUsingFromTo() {
   final ArrayList<Integer> integers = Interval.oneTo(5).addAllTo(new ArrayList<Integer>());
   ArrayList<Integer> results = new ArrayList<Integer>();
   ArrayListIterate.forEach(integers, 0, 4, CollectionAddProcedure.on(results));
   Assert.assertEquals(integers, results);
   MutableList<Integer> reverseResults = Lists.mutable.of();
   final CollectionAddProcedure<Integer> procedure = CollectionAddProcedure.on(reverseResults);
   ArrayListIterate.forEach(integers, 4, 0, procedure);
   Assert.assertEquals(ListIterate.reverseThis(integers), reverseResults);
   Verify.assertThrows(
       IndexOutOfBoundsException.class,
       new Runnable() {
         public void run() {
           ArrayListIterate.forEach(integers, 4, -1, procedure);
         }
       });
   Verify.assertThrows(
       IndexOutOfBoundsException.class,
       new Runnable() {
         public void run() {
           ArrayListIterate.forEach(integers, -1, 4, procedure);
         }
       });
 }
 @Test
 public void forEachWith() {
   MutableList<String> result = Lists.mutable.of();
   MutableSet<String> source = Sets.fixedSize.of("1", "2", "3", "4");
   source.forEachWith(Procedures2.fromProcedure(CollectionAddProcedure.on(result)), null);
   Assert.assertEquals(FastList.newListWith("1", "2", "3", "4"), result);
 }
 @Test
 public void forEachWithIndex() {
   MutableBag<String> result = Bags.mutable.of();
   ImmutableBag<String> strings = this.newBag();
   strings.forEachWithIndex(ObjectIntProcedures.fromProcedure(CollectionAddProcedure.on(result)));
   Assert.assertEquals(strings, result);
 }
 @Test
 public void forEach() {
   MutableBag<String> result = Bags.mutable.of();
   ImmutableBag<String> collection = this.newBag();
   collection.forEach(CollectionAddProcedure.on(result));
   Assert.assertEquals(collection, result);
 }
 @Test
 public void reverseForEach_emptyList() {
   ArrayList<Integer> integers = new ArrayList<Integer>();
   MutableList<Integer> results = Lists.mutable.of();
   ArrayListIterate.reverseForEach(integers, CollectionAddProcedure.on(results));
   Assert.assertEquals(integers, results);
 }
 @Test
 public void reverseForEach() {
   ArrayList<Integer> integers = Interval.oneTo(5).addAllTo(new ArrayList<Integer>());
   MutableList<Integer> reverseResults = Lists.mutable.of();
   ArrayListIterate.reverseForEach(integers, CollectionAddProcedure.on(reverseResults));
   Assert.assertEquals(ListIterate.reverseThis(integers), reverseResults);
 }
 @Test
 public void forEachKey() {
   MutableList<Integer> collection = Lists.mutable.of();
   Multimap<Integer, String> multimap = this.newMultimapWithKeysValues(1, "1", 2, "2", 3, "3");
   multimap.forEachKey(CollectionAddProcedure.on(collection));
   Assert.assertEquals(FastList.newListWith(1, 2, 3), collection);
 }
 @Test
 public void forEachValue() {
   MutableBag<String> collection = Bags.mutable.of();
   Multimap<Integer, String> multimap = this.newMultimapWithKeysValues(1, "1", 2, "2", 3, "3");
   multimap.forEachValue(CollectionAddProcedure.on(collection));
   Assert.assertEquals(HashBag.newBagWith("1", "2", "3"), collection);
 }
 @Test
 public void forEachOver100() {
   ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
   Iterate.sortThis(list);
   FastList<Integer> result = FastList.newList(101);
   ArrayListIterate.forEach(list, CollectionAddProcedure.<Integer>on(result));
   Verify.assertListsEqual(list, result);
 }
 @Test
 public void forEach() {
   ArrayList<Integer> list = this.getIntegerList();
   Iterate.sortThis(list);
   MutableList<Integer> result = Lists.mutable.of();
   ArrayListIterate.forEach(list, CollectionAddProcedure.<Integer>on(result));
   Verify.assertListsEqual(list, result);
 }
 @Test
 public void testForEachWithFromToWithCommandoPatternOptimization() {
   MutableList<Integer> result2 = Lists.mutable.of();
   // Requires list of 100+ elements to engage commando pattern optimization
   ArrayListAdapter.adapt(new ArrayList<>(Interval.oneTo(200)))
       .forEach(99, 199, CollectionAddProcedure.on(result2));
   Verify.assertSize(101, result2);
 }
 @Override
 @Test
 public void forEach() {
   super.forEach();
   MutableList<Integer> list = FastList.newList();
   CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
   iterables.addComposited(Interval.oneTo(5).toList());
   iterables.addComposited(Interval.fromTo(6, 10).toList());
   iterables.forEach(CollectionAddProcedure.on(list));
   Verify.assertSize(10, list);
   Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
 }
Example #14
0
 @Override
 public MutableList<T> toList() {
   FastList<T> result = FastList.newList(this.size());
   this.forEach(CollectionAddProcedure.on(result));
   return result;
 }
Example #15
0
 @Override
 public MutableSet<T> toSet() {
   UnifiedSet<T> result = UnifiedSet.newSet(this.sizeDistinct());
   this.items.forEachKey(CollectionAddProcedure.on(result));
   return result;
 }