#60 CQuery: test covered

assira.core/src/main/java/net/ranides/assira/collection/query/base/CQArraySupplier.java

@@ -38,9 +38,7 @@ public abstract class CQArraySupplier<T> extends CQueryAbstract<T> {
     @Override
     public abstract Object[] array();
 
-    protected boolean hasFastArray() {
-        return false;
-    }
+    protected abstract boolean hasFastArray();
 
     @Override
     public boolean hasFastEach() {

assira.core/src/main/java/net/ranides/assira/collection/query/base/CQCollectionSupplier.java

@@ -20,19 +20,26 @@ import java.util.stream.Stream;
 public abstract class CQCollectionSupplier<T> extends CQueryAbstract<T> {
 
     public static <T> CQuery<T> from(Supplier<Collection<T>> source) {
+        return from(false, source);
+    }
+
+    public static <T> CQuery<T> from(boolean fast, Supplier<Collection<T>> source) {
         return new CQCollectionSupplier<T>() {
             @Override
             protected Collection<T> collection() {
                 return source.get();
             }
+
+            @Override
+            protected boolean hasFastCollection() {
+                return fast;
+            }
         };
     }
 
     protected abstract Collection<T> collection();
 
-    protected boolean hasFastCollection() {
-        return false;
-    }
+    protected abstract boolean hasFastCollection();
 
     @Override
     public boolean hasFastEach() {

assira.core/src/main/java/net/ranides/assira/collection/query/derived/CQFilterEach.java

@@ -10,6 +10,7 @@ import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 public class CQFilterEach<T> extends CQAbstractFilter<T, T> {
+
     private final Predicates.EachPredicate<? super T> p;
 
     public CQFilterEach(CQuery<T> source, Predicates.EachPredicate<? super T> p) {

assira.core/src/main/java/net/ranides/assira/collection/query/derived/CQLimit.java

@@ -18,6 +18,11 @@ public class CQLimit<T> extends CQAbstractFilter<T, T> {
         this.p = p;
     }
 
+    @Override
+    public boolean hasFastEach() {
+        return source.features().hasFastEach();
+    }
+
     @Override
     public Stream<T> stream() {
         return SpliteratorUtils.limit(source.stream(), p);

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQArraySupplierTest.java

@@ -0,0 +1,19 @@
+package net.ranides.assira.collection.query.base;
+
+import net.ranides.test.CQueryAssert;
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+
+import static org.junit.Assert.*;
+
+public class CQArraySupplierTest {
+
+    @Test
+    public void fast() {
+        Integer[] input = {1, 2, 3, 4, 5};
+        CQuery<Integer> query = CQArraySupplier.from(true, () -> input);
+
+        CQueryAssert.assertEquals(input, query);
+    }
+}

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQArrayTest.java

@@ -1,13 +1,16 @@
 package net.ranides.assira.collection.query.base;
 
 import net.ranides.test.CQueryAssert;
+import org.junit.Assert;
 import org.junit.Test;
 
 import net.ranides.assira.collection.query.CQuery;
 
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.junit.Assert.*;
 
@@ -51,4 +54,25 @@ public class CQArrayTest {
         assertEquals(Arrays.asList("0#7", "1#6", "2#2", "3#3"), out6);
     }
 
+    @Test
+    public void whileEach() {
+        Integer[] input = {7, 6, 2, 3, 4, 9, 2, 5, 1, 6, 7, 8, 4};
+
+        int[] out1 = {0};
+        boolean all = new CQArray<>(input).whileEach(v -> {
+            out1[0]++;
+            return v != 1;
+        });
+        assertFalse(all);
+        assertEquals(9, out1[0]);
+    }
+
+    @Test
+    public void fetch() {
+        CQArray<Integer> query = new CQArray<>(new Integer[]{1, 2, 3, 4, 5});
+
+        Assert.assertSame(query, query.fetch());
+        Assert.assertSame(query, query.prefetch());
+        Assert.assertSame(query, query.cache(Paths.get("abc")));
+    }
 }

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQCollectionSupplierTest.java

@@ -0,0 +1,22 @@
+package net.ranides.assira.collection.query.base;
+
+import net.ranides.test.CQueryAssert;
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class CQCollectionSupplierTest {
+
+    @Test
+    public void fast() {
+        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
+        CQuery<Integer> query = CQCollectionSupplier.from(true, () -> input);
+
+        CQueryAssert.assertEquals(input, query);
+    }
+}

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQCollectionTest.java

@@ -0,0 +1,35 @@
+package net.ranides.assira.collection.query.base;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class CQCollectionTest {
+
+    @Test
+    public void whileEach() {
+        Integer[] input = {7, 6, 2, 3, 4, 9, 2, 5, 1, 6, 7, 8, 4};
+
+        int[] out1 = {0};
+        boolean all = new CQCollection<>(Arrays.asList(input)).whileEach(v -> {
+            out1[0]++;
+            return v != 1;
+        });
+        assertFalse(all);
+        assertEquals(9, out1[0]);
+    }
+
+    @Test
+    public void fetch() {
+        CQCollection<Integer> query = new CQCollection<>(Arrays.asList(1, 2, 3, 4, 5));
+
+        Assert.assertSame(query, query.fetch());
+        Assert.assertSame(query, query.prefetch());
+        Assert.assertSame(query, query.cache(Paths.get("abc")));
+    }
+
+}

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQListTest.java

@@ -0,0 +1,65 @@
+package net.ranides.assira.collection.query.base;
+
+import net.ranides.test.CQueryAssert;
+import org.junit.Assert;
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class CQListTest {
+
+    @Test
+    public void testLimitList() {
+        List<Integer> input = Arrays.asList(7, 6, 2, 3, 4, 9, 2, 5, 1, 6, 7, 8, 4);
+
+        CQueryAssert.assertEquals(Arrays.asList(7,6,2,3), CQuery.from().list(input).limit(4));
+        CQueryAssert.assertEquals(Arrays.asList(2,3,4,9), CQuery.from().list(input).skip(2).limit(4));
+        CQueryAssert.assertEquals(Arrays.asList(2,3), CQuery.from().list(input).limit(4).skip(2));
+
+        CQueryAssert.assertEquals(Arrays.asList(2,3), CQuery.from().list(input).limit(4).slice(2,4));
+        CQueryAssert.assertEquals(Arrays.asList(2,3), CQuery.from().list(input).limit(4).slice(2,6));
+
+        List<Integer> out3 = new ArrayList<>();
+        assertEquals(18, CQuery.from().list(input).skip(2).limit(4).onEach(v -> out3.add(v)).reduce(Integer::sum).intValue());
+        assertEquals(Arrays.asList(2,3,4,9), out3);
+
+        List<String> out4 = new ArrayList<>();
+        assertEquals(64, CQuery.from().list(input)
+            .onEach((i,v) -> out4.add(i+"#"+v))
+            .reduce(Integer::sum).intValue()
+        );
+        assertEquals(Arrays.asList("0#7", "1#6", "2#2", "3#3", "4#4", "5#9", "6#2", "7#5", "8#1", "9#6", "10#7", "11#8", "12#4"), out4);
+
+        List<String> out5 = new ArrayList<>();
+        assertEquals(18, CQuery.from().list(input)
+            .limit(4).onEach((i, v) -> out5.add(i + "#" + v))
+            .reduce(Integer::sum).intValue()
+        );
+        assertEquals(Arrays.asList("0#7", "1#6", "2#2", "3#3"), out5);
+
+        List<String> out6 = new ArrayList<>();
+        assertEquals(18, CQuery.from().list(input)
+            .onEach((i, v) -> out6.add(i + "#" + v)).limit(4)
+            .reduce(Integer::sum).intValue()
+        );
+
+        assertEquals(Arrays.asList("0#7", "1#6", "2#2", "3#3"), out6);
+    }
+
+    @Test
+    public void fetch() {
+        CQList<Integer> query = new CQList<>(Arrays.asList(1, 2, 3, 4, 5));
+
+        Assert.assertSame(query, query.fetch());
+        Assert.assertSame(query, query.prefetch());
+        Assert.assertSame(query, query.cache(Paths.get("abc")));
+    }
+
+}

assira.core/src/test/java/net/ranides/assira/collection/query/base/CQSingleTest.java

@@ -0,0 +1,61 @@
+package net.ranides.assira.collection.query.base;
+
+import net.ranides.test.CQueryAssert;
+import org.junit.Assert;
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+import net.ranides.assira.collection.query.CQueryFeatures;
+
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class CQSingleTest {
+
+    @Test
+    public void value() {
+        CQuery<Integer> query = CQuery.from().value(15);
+        CQueryAssert.assertEquals(Arrays.asList(15), query);
+    }
+
+    @Test
+    public void features() {
+        CQuery<Integer> query = CQuery.from().value(15);
+        assertTrue(query.features().hasFastEach());
+        assertTrue(query.features().hasFastStream());
+        assertTrue(query.features().hasFastIterator());
+        assertTrue(query.features().hasFastLength());
+        assertTrue(query.features().hasFastList());
+    }
+
+    @Test
+    public void limitSkipSlice() {
+        CQuery<Integer> query = CQuery.from().value(15);
+
+        assertSame(query, query.limit(15));
+        assertSame(query, query.skip(0));
+        assertSame(query, query.slice(0,10));
+        assertSame(query, query.slice(0,1));
+
+        CQueryAssert.assertEmpty(query.limit(0));
+        CQueryAssert.assertEmpty(query.skip(1));
+        CQueryAssert.assertEmpty(query.skip(5));
+        CQueryAssert.assertEmpty(query.slice(1,10));
+        CQueryAssert.assertEmpty(query.slice(5,10));
+        CQueryAssert.assertEmpty(query.slice(0,0));
+    }
+
+    @Test
+    public void fetch() {
+        CQSingle<Integer> query = new CQSingle<>(15);
+
+        Assert.assertSame(query, query.fetch());
+        Assert.assertSame(query, query.prefetch());
+        Assert.assertSame(query, query.cache(Paths.get("abc")));
+        Assert.assertSame(query, query.reverse());
+    }
+}

assira.core/src/test/java/net/ranides/assira/collection/query/derived/CQFilterTest.java

@@ -0,0 +1,30 @@
+package net.ranides.assira.collection.query.derived;
+
+import net.ranides.test.CQueryAssert;
+import net.ranides.test.mockup.query.CQueryMockup;
+import org.junit.Assert;
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class CQFilterTest {
+
+    @Test
+    public void size() {
+        CQuery<Integer> query = CQuery.from()
+            .values(1, 2, 3, 4, 5, 6, 7, 8)
+            .filter(v -> v % 2 == 0);
+
+        CQueryAssert.assertEquals(Arrays.asList(2, 4, 6, 8), query);
+
+        CQuery<Integer> query2 =
+            CQueryMockup.of("each1", Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8))
+            .limit(v -> v != 5);
+
+        CQueryAssert.assertEquals(Arrays.asList(1, 2, 3, 4), query2);
+    }
+}

assira.core/src/test/java/net/ranides/assira/collection/query/support/BaseIterableTest.java

@@ -0,0 +1,21 @@
+package net.ranides.assira.collection.query.support;
+
+import org.junit.Test;
+
+import net.ranides.assira.collection.query.CQuery;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class BaseIterableTest {
+
+    @Test
+    public void array() {
+        Integer[] input = {1, 2, 3, 4, 5};
+        CQuery<Integer> query = CQuery.from().array(input);
+        Integer[] out = BaseIterable.array(query, Integer[]::new);
+
+        assertArrayEquals(input, out);
+    }
+}

assira.core/src/test/java/net/ranides/test/CQueryAssert.java

@@ -14,6 +14,7 @@ import net.ranides.assira.text.StringUtils;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -65,6 +66,10 @@ public class CQueryAssert {
         assertSize(expected, query);
     }
 
+    public static <T> void assertEmpty(CQuery<T> query) {
+        assertEquals(Collections.emptyList(), query);
+    }
+
     public static <T> void assertList(List<T> expected, CQuery<T> query) {
         // direct 1st check
         Assert.assertEquals(expected, query.list());
@@ -144,6 +149,7 @@ public class CQueryAssert {
 
     public static <T> void assertSize(List<T> expected, CQuery<T> query) {
         Assert.assertEquals(expected.isEmpty(), query.isEmpty());
+        Assert.assertEquals(expected.size(), query.size());
     }
 
     public static <T> void assertJoin(List<T> items, CQuery<T> query) {