Added mockunit that can cycle through an Iterable for obtaining values.

Author: nomemory

examples/net/andreinc/mockneat/github/GenerateShufflers.java

@@ -0,0 +1,23 @@
+package net.andreinc.mockneat.github;
+
+import net.andreinc.mockneat.MockNeat;
+
+import java.util.Arrays;
+
+/**
+ * Created by andreinicolinciobanu on 11/05/17.
+ */
+public class GenerateShufflers {
+    public static void main(String[] args) {
+
+        MockNeat mockNeat = MockNeat.threadLocal();
+
+        int[] x = { 1, 2, 3, 4, 5, 6 };
+        mockNeat.shufflers()
+                .arrayInt(x)
+                .stream().val()
+                .limit(5)
+                .forEach(arr -> System.out.println(Arrays.toString(arr)));
+
+    }
+}

examples/net/andreinc/mockneat/github/HrSchema.java

@@ -0,0 +1,34 @@
+package net.andreinc.mockneat.github;
+
+import net.andreinc.mockneat.MockNeat;
+
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+import static net.andreinc.mockneat.MockNeat.threadLocal;
+
+/**
+ * Created by andreinicolinciobanu on 11/05/17.
+ */
+public class HrSchema {
+
+    private static final int REG_START = 0;
+    private static final int REG_END = 5;
+    public static final int COUNTRY_NUM = 100;
+
+    public static void main(String[] args) {
+
+    }
+
+    public List<String> generateCountries() {
+        MockNeat mockNeat = threadLocal();
+
+        return mockNeat.fmt("INSERT INTO countries VALUES ('#{code}', '#{name}', #{id}, #{region_id});")
+                        .param("code", mockNeat.countries().iso2())
+                        .param("name", mockNeat.countries().names())
+                        .param("id", mockNeat.longSeq())
+                        .param("region_id", mockNeat.ints().range(REG_START, REG_END))
+                        .set(COUNTRY_NUM).val().stream()
+                        .collect(toList());
+    }
+}

src/main/java/net/andreinc/mockneat/MockNeat.java

@@ -32,6 +32,7 @@
 import net.andreinc.mockneat.unit.regex.Regex;
 import net.andreinc.mockneat.unit.seq.IntSeq;
 import net.andreinc.mockneat.unit.seq.LongSeq;
+import net.andreinc.mockneat.unit.seq.Seq;
 import net.andreinc.mockneat.unit.text.*;
 import net.andreinc.mockneat.unit.time.Days;
 import net.andreinc.mockneat.unit.time.LocalDates;
@@ -230,6 +231,8 @@ public <T, FT> Factory<T, FT> factory(Class<T> targetCls, Class<FT> factoryCls)
 
     public <T> Reflect<T> reflect(Class<T> cls) { return new Reflect<>(this, cls);}
 
+    public <T> Seq<T> seq(Iterable<T> iterable) { return new Seq(this, iterable); }
+
     public Shufflers shufflers() { return rShufflers; }
 
     public Strings strings() { return new Strings(this); }

src/main/java/net/andreinc/mockneat/unit/seq/Seq.java

@@ -0,0 +1,78 @@
+package net.andreinc.mockneat.unit.seq;
+
+/**
+ * Copyright 2017, Andrei N. Ciobanu
+
+ Permission is hereby granted, free of charge, to any user obtaining a copy of this software and associated
+ documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, FREE_TEXT OF OR PARAM CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS PARAM THE SOFTWARE.
+ */
+
+import net.andreinc.mockneat.MockNeat;
+import net.andreinc.mockneat.interfaces.MockUnit;
+
+import java.util.Iterator;
+import java.util.function.Supplier;
+
+import static net.andreinc.mockneat.utils.ValidationUtils.IMPOSSIBLE_TO_SEQ_OVER_EMPTY_COLLECTION;
+import static net.andreinc.mockneat.utils.ValidationUtils.isTrue;
+import static net.andreinc.mockneat.utils.ValidationUtils.notNull;
+
+
+// TODO - documentation
+public class  Seq<T> implements MockUnit<T> {
+
+    private final MockNeat mockNeat;
+
+    private final Iterable<T> iterable;
+    private Iterator<T> iterator;
+
+    private boolean cycle = false;
+    private T after = null;
+
+    public Seq(MockNeat mockNeat, Iterable<T> iterable) {
+
+        notNull(mockNeat, "mockNeat");
+        notNull(iterable, "iterable");
+
+        this.mockNeat = mockNeat;
+        this.iterable = iterable;
+        this.iterator = iterable.iterator();
+
+        isTrue(iterator.hasNext(), IMPOSSIBLE_TO_SEQ_OVER_EMPTY_COLLECTION);
+    }
+
+    public Seq<T> cycle(boolean value) {
+        this.cycle = value;
+        return this;
+    }
+
+    public Seq<T> after(T after) {
+        this.after = after;
+        return this;
+    }
+
+    @Override
+    public Supplier<T> supplier() {
+        return () -> {
+            if (iterator.hasNext())
+                return (T) iterator.next();
+            else
+                if (cycle) {
+                    this.iterator = iterable.iterator();
+                    return (T) iterator.next();
+                }
+                else
+                    return(T) after;
+        };
+    }
+}

src/main/java/net/andreinc/mockneat/utils/ValidationUtils.java

@@ -68,6 +68,7 @@ public class ValidationUtils {
     public static final String INVALID_REGEX_PATTERN = "Invalid regex pattern ('#{pattern}'): ";
     public static final String OBJECT_NOT_SERIALIZABLE = "Object is not serializable. Does the object's class extends 'java.io.Serializable' ?";
     public static final String PROBABILITY_NOT_NEGATIVE = "Probability '#{prob}' should be bigger than '0.0'.";
+    public static final String IMPOSSIBLE_TO_SEQ_OVER_EMPTY_COLLECTION = "Impossible to create a Seq from an empty Iterable<T>.";
 
     private ValidationUtils() {}
 

src/test/java/net/andreinc/mockneat/unit/seq/SeqTest.java

@@ -0,0 +1,89 @@
+package net.andreinc.mockneat.unit.seq;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.stream.IntStream.range;
+import static net.andreinc.mockneat.Constants.M;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Copyright 2017, Andrei N. Ciobanu
+
+ Permission is hereby granted, free of charge, to any user obtaining a copy of this software and associated
+ documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, FREE_TEXT OF OR PARAM CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS PARAM THE SOFTWARE.
+ */
+
+public class SeqTest {
+
+    @Test(expected = NullPointerException.class)
+    public void testSeqNullList() throws Exception {
+        M.seq(null).list(100).val();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testEmptyList() throws Exception {
+        M.seq(new ArrayList<String>()).list(100).val();
+    }
+
+    @Test
+    public void testSeq() throws Exception {
+        List<Integer> arr = M.intSeq().max(100).cycle(false).list(100).val();
+        List<Integer> seq = M.seq(arr).cycle(false).list(10).val();
+
+        seq.forEach(i -> assertTrue(seq.get(i) == i));
+    }
+
+    @Test
+    public void testTwoElementsCycle() throws Exception {
+        List<Integer> twoElements = new ArrayList<>();
+
+        twoElements.add(1);
+        twoElements.add(2);
+
+        List<Integer> seq = M.seq(twoElements).cycle(true).list(100).val();
+
+        range(0, seq.size()).forEach(i -> {
+            if (i%2==0)
+                assertTrue(seq.get(i) == 1);
+            else
+                assertTrue(seq.get(i) == 2);
+        });
+    }
+
+    @Test
+    public void testOneElementNoCycle() throws  Exception {
+        List<Integer> oneElement = new ArrayList<>();
+
+        oneElement.add(2);
+
+        List<Integer> seq = M.seq(oneElement).list(10).val();
+
+        assertTrue(seq.get(0) == 2);
+        assertTrue(seq.get(1) == null);
+    }
+
+    @Test
+    public void testOneElementNoCycleAfterNonNull() throws Exception {
+        List<Integer> oneElement = new ArrayList<>();
+
+        oneElement.add(2);
+
+        List<Integer> seq = M.seq(oneElement).after(4).list(10).val();
+
+        assertTrue(seq.get(0) == 2);
+        assertTrue(seq.get(1) == 4);
+    }
+}