From a4b5a5f904fe9f21697cd8fc8998c7e6e86306af Mon Sep 17 00:00:00 2001
From: Carlo Zancanaro <carlo@zancanaro.id.au>
Date: Sun, 31 May 2015 23:47:38 +1000
Subject: Lots more updates

+ add a list generator, and some more number generators.
+ bugfix the assumption checking stuff: if it failed once it would pretty
  likely continue to fail!
+ write some simple actualy properties:
  - reverse . reverse = id
  - sort . sort = sort
---
 src/main/java/au/id/zancanaro/Generators.java | 37 ++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 6 deletions(-)

(limited to 'src/main/java/au/id/zancanaro/Generators.java')

diff --git a/src/main/java/au/id/zancanaro/Generators.java b/src/main/java/au/id/zancanaro/Generators.java
index 5b025fa..852a290 100644
--- a/src/main/java/au/id/zancanaro/Generators.java
+++ b/src/main/java/au/id/zancanaro/Generators.java
@@ -1,6 +1,8 @@
 package au.id.zancanaro;
 
+import java.util.Arrays;
 import java.util.Iterator;
+import java.util.List;
 import java.util.function.Predicate;
 
 public class Generators {
@@ -15,28 +17,51 @@ public class Generators {
         };
     }
 
+    @SafeVarargs
+    public static <T> Generator<T> oneOf(Generator<T>... gens) {
+        return integer(0, gens.length).flatMap(index -> gens[index]);
+    }
+
     public static Generator<Integer> integer() {
+        return (random, size) -> integer(-size, size).generate(random, size);
+    }
+
+    public static Generator<Integer> natural() {
+        return (random, size) -> integer(0, size).generate(random, size);
+    }
+
+    public static Generator<Integer> integer(int lower, int upper) {
         return (random, size) -> {
-            int value = random.nextInt(size);
-            return new RoseTree<>(value, intShrinkingIterable(value));
+            int value = lower + random.nextInt(upper - lower);
+            int bound = lower > 0 ? lower : (upper < 0 ? upper : 0);
+            return new RoseTree<>(value, intShrinkingIterable(value, bound));
         };
     }
 
-    private static Iterable<RoseTree<Integer>> intShrinkingIterable(final int value) {
+    private static Iterable<RoseTree<Integer>> intShrinkingIterable(final int value, final int bound) {
         return () -> new Iterator<RoseTree<Integer>>() {
-            int curr = value;
+            int curr = value - bound;
 
             @Override
             public boolean hasNext() {
-                return curr > 0;
+                return curr != 0;
             }
 
             @Override
             public RoseTree<Integer> next() {
                 int prevCurr = curr;
                 curr = curr / 2;
-                return new RoseTree<>(value - prevCurr, intShrinkingIterable(value - prevCurr));
+                return new RoseTree<>(value - prevCurr, intShrinkingIterable(value - prevCurr, bound));
             }
         };
     }
+
+    public static <T> Generator<List<T>> listOf(Generator<T> gen) {
+        return (random, size) -> integer(0, size).flatMap(count -> {
+            @SuppressWarnings("unchecked")
+            Generator<T>[] gens = (Generator<T>[]) new Generator[count];
+            Arrays.fill(gens, gen);
+            return Generator.tuple(gens).fmap(Arrays::asList);
+        }).generate(random, size);
+    }
 }
-- 
cgit v1.2.3