tests

fix: IteratorUtils / IntIteratorUtils

assira/pom.xml

@@ -37,8 +37,6 @@
                                 <include>net/ranides/assira/collection/HashFunction*</include>
                                 <include>net/ranides/assira/collection/arrays/ArrayUtils*</include>
                                 <include>net/ranides/assira/collection/arrays/NativeArrayUtils*</include>
-                                <include>net/ranides/assira/collection/iterators/IntIteratorUtils*</include>
-                                <include>net/ranides/assira/collection/iterators/IteratorUtils*</include>
                                 <include>net/ranides/assira/collection/lists/IntRange*</include>
                                 <include>net/ranides/assira/collection/lookups/LookupUtils*</include>
                                 <include>net/ranides/assira/collection/maps/IntMapUtils*</include>

assira/src/main/java/net/ranides/assira/collection/iterators/IntIteratorUtils.java

@@ -9,9 +9,16 @@ package net.ranides.assira.collection.iterators;
 import java.util.Iterator;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
 import java.util.function.IntFunction;
 import java.util.function.IntPredicate;
 import java.util.function.IntUnaryOperator;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 /**
  *
@@ -103,7 +110,59 @@ public final class IntIteratorUtils {
 		}
 		return i;
 	}
+    
+    public static IntIterator reverse(IntListIterator iterator) {
+		return new IntIteratorUtils.ReverseIterator(iterator);
+	}
+    
+    public static IntStream stream(IntIterator iterator) {
+		return StreamSupport.intStream(new IntSpliterator(iterator), false);
+	}
+    
+    private static final class IntSpliterator implements Spliterator.OfInt {
+        
+        private final IntIterator iterator;
+
+        public IntSpliterator(IntIterator iterator) {
+            this.iterator = iterator;
+        }
+
+        @Override
+        public OfInt trySplit() {
+            return null;
+        }
 
+        @Override
+        public boolean tryAdvance(IntConsumer action) {
+            if (iterator.hasNext()) {
+                action.accept(iterator.nextInt());
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super Integer> action) {
+            if (iterator.hasNext()) {
+                action.accept(iterator.next());
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public long estimateSize() {
+            return Long.MAX_VALUE;
+        }
+
+        @Override
+        public int characteristics() {
+            return 0;
+        }
+
+    };
+
+    
     private static final class Adapter<T> implements Iterator<T> {
     
         protected final IntIterator delegate;
@@ -320,7 +379,8 @@ public final class IntIteratorUtils {
 
         @Override
         public void remove() {
-            iterator.remove();
+            // impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
         }
 
     }
@@ -408,19 +468,47 @@ public final class IntIteratorUtils {
 
 		@Override
 		public void remove() {
-			iterator.remove();
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
 		@Override
 		public void set(int e) {
-			iterator.set(e);
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
 		@Override
 		public void add(int e) {
-			iterator.add(e);
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
     }
     
+    private static class ReverseIterator implements IntIterator {
+		
+		private final IntListIterator iterator;
+
+		public ReverseIterator(IntListIterator iterator) {
+			this.iterator = iterator;
+		}
+
+		@Override
+		public void remove() {
+			iterator.remove();
+		}
+
+		@Override
+		public boolean hasNext() {
+			return iterator.hasPrevious();
+		}
+
+		@Override
+		public int nextInt() {
+			return iterator.previous();
+		}
+
+	}
+    
 }

assira/src/main/java/net/ranides/assira/collection/iterators/IteratorUtils.java

@@ -101,7 +101,15 @@ public final class IteratorUtils {
 		return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
 	}
 	
-	public static <T> ListIterator<T> reverse(ListIterator<T> iterator) {
+    /**
+     * Nie da się stworzyć odwróconego ListIterator ponieważ indeksowanie się położy, operacja
+     * #add będzie wstawiać na nieprawidłowej pozycji. Operacja #set w zasadzie ma szanse działać. 
+     * Ale to za mało, żeby zwracać interfejs, którego kontraktu w 90% nie dotrzymujemy.
+     * @param <T>
+     * @param iterator
+     * @return 
+     */
+	public static <T> Iterator<T> reverse(ListIterator<T> iterator) {
 		return new ReverseIterator<>(iterator);
 	}
 	
@@ -243,7 +251,8 @@ public final class IteratorUtils {
 
         @Override
         public void remove() {
-            iterator.remove();
+            // impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
         }
 
     }
@@ -331,22 +340,25 @@ public final class IteratorUtils {
 
 		@Override
 		public void remove() {
-			iterator.remove();
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
 		@Override
 		public void set(T e) {
-			iterator.set(e);
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
 		@Override
 		public void add(T e) {
-			iterator.add(e);
+			// impossible to implement both "hasNext" & "mutable methods" reliably
+            throw new UnsupportedOperationException();
 		}
 
     }
     
-	private static class ReverseIterator<T> implements ListIterator<T> {
+	private static class ReverseIterator<T> implements Iterator<T> {
 		
 		private final ListIterator<T> iterator;
 
@@ -359,16 +371,6 @@ public final class IteratorUtils {
 			iterator.remove();
 		}
 
-		@Override
-		public void set(T e) {
-			iterator.set(e);
-		}
-
-		@Override
-		public void add(T e) {
-			iterator.add(e);
-		}
-
 		@Override
 		public boolean hasNext() {
 			return iterator.hasPrevious();
@@ -379,25 +381,5 @@ public final class IteratorUtils {
 			return iterator.previous();
 		}
 
-		@Override
-		public boolean hasPrevious() {
-			return iterator.hasNext();
-		}
-
-		@Override
-		public T previous() {
-			return iterator.previous();
-		}
-
-		@Override
-		public int nextIndex() {
-			return iterator.previousIndex();
-		}
-
-		@Override
-		public int previousIndex() {
-			return iterator.nextIndex();
-		}
-
 	}
 }

assira/src/test/java/net/ranides/assira/collection/iterators/IntIteratorUtilsTest.java

@@ -6,31 +6,198 @@
  */
 package net.ranides.assira.collection.iterators;
 
-import net.ranides.assira.collection.lists.NativeArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import net.ranides.assira.collection.lists.IntArrayList;
+import net.ranides.assira.collection.lists.IntList;
 import net.ranides.assira.collection.suite.IteratorTester;
+import static net.ranides.assira.junit.NewAssert.assertThrows;
+import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import org.junit.Test;
-import static org.junit.Assert.*;
 
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
  */
 public class IntIteratorUtilsTest {
+    
+    @Test
+	public void testFirst() {
+		assertEquals(1, IntIteratorUtils.first(IntList.asList(1,2,3,4).iterator()));
+		assertEquals(1, IntIteratorUtils.first(IntList.asList(1,2).iterator()));
+		assertEquals(1, IntIteratorUtils.first(IntList.asList(1).iterator()));
+		
+		assertNull(IteratorUtils.first(Arrays.asList().iterator()));
+		assertNull(IteratorUtils.first(null));
+	}
 	
 	@Test
-	public void testIntIteratorMap() {
-		IntIterator s = NativeArrayList.wrap(new int[]{1,2,3,4,5}).iterator();
-		IntIterator i = IntIteratorUtils.map(s, (int v)->10*v);
+	public void testLast() {
+		assertEquals(4, IntIteratorUtils.last(IntList.asList(1,2,3,4).iterator()));
+		assertEquals(4, IntIteratorUtils.last(IntList.asList(3,4).iterator()));
+		assertEquals(4, IntIteratorUtils.last(IntList.asList(4).iterator()));
+		
+		assertThrows(NoSuchElementException.class, () -> {
+			IteratorUtils.last(Arrays.asList().iterator());
+		});
+	}
+    
+    @Test
+	public void testFirst_Filter() {
+		assertEquals(7, IntIteratorUtils.first(IntList.asList(1,2,7,0,8,0,3).iterator(), a -> a>5));
 		
-		IteratorTester.basicIterator(i, 0, new Integer[]{10,20,30,40,50});
+		assertThrows(NoSuchElementException.class, () -> {
+			IntIteratorUtils.first(IntList.asList(1,2,3).iterator(), a -> a>5);
+		});
+		assertThrows(NoSuchElementException.class, () -> {
+			IntIteratorUtils.first(IntList.asList().iterator(), a -> a>5);
+		});
 	}
 	
 	@Test
-	public void testIntListIteratorMap() {
-		IntListIterator s = NativeArrayList.wrap(new int[]{1,2,3,4,5}).iterator();
-		IntListIterator i = IntIteratorUtils.map(s, (int v)->10*v);
+	public void testLast_Filter() {
+		assertEquals(8, IntIteratorUtils.last(IntList.asList(1,2,7,0,8,0,3).iterator(), a -> a>5));
+		assertEquals(8, IntIteratorUtils.last(IntList.asList(1,2,7,0,8).iterator(), a -> a>5));
+		assertEquals(8, IntIteratorUtils.last(IntList.asList(1,8).iterator(), a -> a>5));
+		assertEquals(8, IntIteratorUtils.last(IntList.asList(8,1).iterator(), a -> a>5));
 		
-		IteratorTester.listIterator(i, 0, new Integer[]{10,20,30,40,50});
+		assertThrows(NoSuchElementException.class, () -> {
+			IntIteratorUtils.last(IntList.asList(1,2,3).iterator(), a -> a>5);
+		});
+		assertThrows(NoSuchElementException.class, () -> {
+			IntIteratorUtils.last(IntList.asList().iterator(), a -> a>5);
+		});
+	}
+	
+    
+    @Test
+	public void testSize() {
+		assertEquals(4, IntIteratorUtils.size(IntList.asList(1,2,7,8).iterator()));
+		assertEquals(2, IntIteratorUtils.size(IntList.asList(1,2).iterator()));
+		assertEquals(1, IntIteratorUtils.size(IntList.asList(1).iterator()));
+		assertEquals(0, IntIteratorUtils.size(IntList.asList().iterator()));
+		assertEquals(0, IntIteratorUtils.size(null));
 	}
 	
+	
+	@Test
+	public void testMap_Iterator() {
+        IntList list = new IntArrayList(new int[]{1,2,3,4,5});
+        
+		IntIterator a = IntIteratorUtils.map((IntIterator)list.iterator(), (int v)->10*v);
+		IteratorTester.basicIterator(a, 0, new Integer[]{10,20,30,40,50});
+        
+        IntIterator b = IntIteratorUtils.map((IntIterator)list.iterator(), (int v)->10*v);
+        b.next();
+        b.remove();
+        b.next();
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList(2,4,5), list);
+	}
+    
+    @Test
+    public void testMap_IteratorFunction() {
+        IntList list = new IntArrayList(new int[]{1,2,3,4,5});
+		
+        Iterator<String> a = IntIteratorUtils.map((IntIterator)list.iterator(), (int v)->"#"+v);
+		IteratorTester.basicIterator(a, 0, new String[]{"#1","#2","#3","#4","#5"});
+        
+        Iterator<String> b = IntIteratorUtils.map((IntIterator)list.iterator(), (int v)->"#"+v);
+        b.next();
+        b.remove();
+        b.next();
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList(2,4,5), list);
+    }
+	
+	@Test
+	public void testMap_ListIterator() {
+		IntList list = new IntArrayList(new int[]{1,2,3,4,5});
+        
+		IntListIterator a = IntIteratorUtils.map(list.iterator(), (int v)->10*v);
+		IteratorTester.basicIterator(a, 0, new Integer[]{10,20,30,40,50});
+        
+        IntListIterator b = IntIteratorUtils.map(list.iterator(), (int v)->10*v);
+        b.next();
+        b.remove();
+        b.next();
+        assertThrows(UnsupportedOperationException.class, ()->{ b.set(9); });
+        assertThrows(UnsupportedOperationException.class, ()->{ b.add(9); });
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList(2,4,5), list);
+	}
+    
+    @Test
+    public void testMap_ListIteratorFunction() {
+        IntList list = new IntArrayList(new int[]{1,2,3,4,5});
+		
+        ListIterator<String> a = IntIteratorUtils.map(list.iterator(), (int v)->"#"+v);
+		IteratorTester.basicIterator(a, 0, new String[]{"#1","#2","#3","#4","#5"});
+        
+        ListIterator<String> b = IntIteratorUtils.map(list.iterator(), (int v)->"#"+v);
+        b.next();
+        b.remove();
+        b.next();
+        assertThrows(UnsupportedOperationException.class, ()->{ b.set("Q"); });
+        assertThrows(UnsupportedOperationException.class, ()->{ b.add("Q"); });
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList(2,4,5), list);
+    }
+    
+    @Test
+	public void testFilter_Iterator() {
+        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
+        
+		IteratorTester.basicIterator(IntIteratorUtils.filter(IntIterator.wrap(list.iterator()), v -> v%2==0), 0, new Integer[]{2,4,6,8});
+		IteratorTester.basicIterator(IntIteratorUtils.filter(IntIterator.wrap(list.iterator()), v -> v%2==1), 0, new Integer[]{1,3,5,7,9});
+		IteratorTester.basicIterator(IntIteratorUtils.filter(IntIterator.wrap(list.iterator()), v -> v>5), 0, new Integer[]{6,7,8,9});
+	}
+	
+	@Test
+	public void testFilter_ListIterator() {
+		IntList list = IntList.asList(1,2,3,4,5,6,7,8,9);
+
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(), v -> v%2==0), 0, new Integer[]{2,4,6,8});
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(), v -> v%2==1), 0, new Integer[]{1,3,5,7,9});
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(), v -> v>5), 0, new Integer[]{6,7,8,9});
+		
+		
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(2), v -> v%2==0), 0, new Integer[]{4,6,8});
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(2), v -> v%2==1), 0, new Integer[]{3,5,7,9});
+		IteratorTester.listIterator(IntIteratorUtils.filter(list.listIterator(6), v -> v>5), 0, new Integer[]{7,8,9});
+	}
+    
+    @Test
+	public void testReverse() {
+        IntList list = new IntArrayList(new int[]{1,2,3,4,5,6,7,8,9});
+        IntListIterator a = list.listIterator(9);
+        IteratorTester.basicIterator(IntIteratorUtils.reverse(a), 0, new Integer[]{9,8,7,6,5,4,3,2,1});
+        
+        IntIterator b = IntIteratorUtils.reverse(list.listIterator(9));
+        IteratorUtils.next(b, 1);
+        b.remove();
+        IteratorUtils.next(b, 2);
+        b.remove();
+        IteratorUtils.next(b, 3);
+        b.remove();
+        assertEquals(new IntArrayList(new int[]{1,2,3,5,6,8}),list);
+    }
+	
+    @Test
+    public void testStream() {
+        IntList exp = IntList.asList(1,2,3,4,5,6,7,8,9);
+        IntList out = new IntArrayList();
+        IntIteratorUtils.stream( exp.listIterator() ).forEach(v -> out.add(v));
+        assertEquals(exp, out);
+    }
+	
 }

assira/src/test/java/net/ranides/assira/collection/iterators/IteratorUtilsTest.java

@@ -6,11 +6,13 @@
  */
 package net.ranides.assira.collection.iterators;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
+import net.ranides.assira.collection.lists.IntArrayList;
 import net.ranides.assira.collection.suite.IteratorTester;
 import org.junit.Test;
 import static net.ranides.assira.junit.NewAssert.*;
@@ -80,23 +82,41 @@ public class IteratorUtilsTest {
 	}
 	
 	@Test
-	public void testIteratorMap() {
-		Iterator<String> s = Arrays.asList("a", "b", "c", "d").iterator();
-		Iterator<String> i = IteratorUtils.map(s, String::toUpperCase);
+	public void testMap_Iterator() {
+        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
 		
-		IteratorTester.basicIterator(i, 0, new String[]{"A", "B", "C", "D"});
+        Iterator<String> a = IteratorUtils.map(list.iterator(), String::toUpperCase);
+		IteratorTester.basicIterator(a, 0, new String[]{"A", "B", "C", "D"});
+        
+        Iterator<String> b = IteratorUtils.map(list.iterator(), String::toUpperCase);
+        b.next();
+        b.remove();
+        b.next();
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList("b","d"), list);
 	}
 	
 	@Test
-	public void testListIteratorMap() {
-		ListIterator<String> s = Arrays.asList("a", "b", "c", "d").listIterator();
-		ListIterator<String> i = IteratorUtils.map(s, String::toUpperCase);
+	public void testMap_ListIterator() {
+        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
 		
-		IteratorTester.listIterator(i, 0, new String[]{"A", "B", "C", "D"});
+        ListIterator<String> a = IteratorUtils.map(list.listIterator(), String::toUpperCase);
+		IteratorTester.listIterator(a, 0, new String[]{"A", "B", "C", "D"});
+        
+        ListIterator<String> b = IteratorUtils.map(list.listIterator(), String::toUpperCase);
+        b.next();
+        b.remove();
+        b.next();
+        assertThrows(UnsupportedOperationException.class, ()->{ b.set("Q"); });
+        assertThrows(UnsupportedOperationException.class, ()->{ b.add("Q"); });
+        b.next();
+        b.remove();
+        assertEquals(Arrays.asList("b","d"), list);
 	}
 	
 	@Test
-	public void testFilterIterator() {
+	public void testFilter_Iterator() {
 		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
 
 		IteratorTester.basicIterator(IteratorUtils.filter(list.iterator(), v -> v%2==0), 0, new Integer[]{2,4,6,8});
@@ -105,7 +125,7 @@ public class IteratorUtilsTest {
 	}
 	
 	@Test
-	public void testFilterListIterator() {
+	public void testFilter_ListIterator() {
 		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
 
 		IteratorTester.listIterator(IteratorUtils.filter(list.listIterator(), v -> v%2==0), 0, new Integer[]{2,4,6,8});
@@ -113,16 +133,33 @@ public class IteratorUtilsTest {
 		IteratorTester.listIterator(IteratorUtils.filter(list.listIterator(), v -> v>5), 0, new Integer[]{6,7,8,9});
 		
 		
-		IteratorTester.listIterator(IteratorUtils.filter(forward(list.listIterator(),2), v -> v%2==0), 0, new Integer[]{4,6,8});
-		IteratorTester.listIterator(IteratorUtils.filter(forward(list.listIterator(),2), v -> v%2==1), 0, new Integer[]{3,5,7,9});
-		IteratorTester.listIterator(IteratorUtils.filter(forward(list.listIterator(),6), v -> v>5), 0, new Integer[]{7,8,9});
-	}
-	
-	private <T> ListIterator<T> forward(ListIterator<T> iterator, int count) {
-		for(int i=0; i<count; i++) {
-			iterator.next();
-		}
-		return iterator;
+		IteratorTester.listIterator(IteratorUtils.filter(list.listIterator(2), v -> v%2==0), 0, new Integer[]{4,6,8});
+		IteratorTester.listIterator(IteratorUtils.filter(list.listIterator(2), v -> v%2==1), 0, new Integer[]{3,5,7,9});
+		IteratorTester.listIterator(IteratorUtils.filter(list.listIterator(6), v -> v>5), 0, new Integer[]{7,8,9});
 	}
+    
+    @Test
+	public void testReverse() {
+        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
+        ListIterator<Integer> i = list.listIterator(9);
+        IteratorTester.basicIterator(IteratorUtils.reverse(i), 0, new Integer[]{9,8,7,6,5,4,3,2,1});
+        
+        Iterator<Integer> b = IteratorUtils.reverse(list.listIterator(9));
+        IteratorUtils.next(b, 1);
+        b.remove();
+        IteratorUtils.next(b, 2);
+        b.remove();
+        IteratorUtils.next(b, 3);
+        b.remove();
+        assertEquals(new IntArrayList(new int[]{1,2,3,5,6,8}),list);
+    }
+    
+    @Test
+    public void testStream() {
+        List<Integer> exp = Arrays.asList(1,2,3,4,5,6,7,8,9);
+        List<Integer> out = new ArrayList<>();
+        IteratorUtils.stream( exp.listIterator() ).forEach(v -> out.add(v));
+        assertEquals(exp, out);
+    }
 	
 }