Move packages, make lists shrink in size, generate lists instead of arrays as the 'primitive' operation (issues with generics)

1 files changed, 0 insertions, 80 deletions

diff --git a/src/main/java/au/id/zancanaro/Generators.java b/src/main/java/au/id/zancanaro/Generators.java
deleted file mode 100644
index 01ab64a..0000000
--- a/src/main/java/au/id/zancanaro/Generators.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package au.id.zancanaro;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-public class Generators {
-    public static <T> Generator<T> sized(Function<Integer, Generator<T>> makeGenerator) {
-        return (random, size) -> makeGenerator.apply(size).generate(random, size);
-    }
-
-    public static <T> Generator<T> suchThat(Generator<T> gen, Predicate<T> pred) {
-        return (random, size) -> {
-            RoseTree<T> result = gen.generate(random, size);
-            if (pred.test(result.getValue())) {
-                return result.filter(pred);
-            } else {
-                return suchThat(gen, pred).generate(random, size);
-            }
-        };
-    }
-
-    @SafeVarargs
-    public static <T> Generator<T> oneOf(Generator<T>... gens) {
-        return integer(0, gens.length).flatMap(index -> gens[index]);
-    }
-
-    public static Generator<Boolean> bool() {
-        return (random, size) ->
-                random.nextBoolean() ?
-                        new RoseTree<>(true, Collections.singletonList(new RoseTree<>(false, Collections.emptyList()))) :
-                        new RoseTree<>(false, Collections.emptyList());
-    }
-
-    public static Generator<Integer> integer(int lower, int upper) {
-        return (random, size) -> {
-            int value = lower + random.nextInt(upper - lower);
-            int bound = lower > 0 ? lower : (upper < 0 ? upper : 0);
-            return new RoseTree<>(value, intShrinkingIterable(value, bound));
-        };
-    }
-
-    public static Generator<Integer> integer() {
-        return sized(size -> integer(-size, size));
-    }
-
-    public static Generator<Integer> natural() {
-        return sized(size -> integer(0, size));
-    }
-
-    private static Iterable<RoseTree<Integer>> intShrinkingIterable(final int value, final int bound) {
-        return () -> new Iterator<RoseTree<Integer>>() {
-            int curr = value - bound;
-
-            @Override
-            public boolean hasNext() {
-                return curr != 0;
-            }
-
-            @Override
-            public RoseTree<Integer> next() {
-                int prevCurr = curr;
-                curr = curr / 2;
-                return new RoseTree<>(value - prevCurr, intShrinkingIterable(value - prevCurr, bound));
-            }
-        };
-    }
-
-    public static <T> Generator<List<T>> listOf(Generator<T> gen) {
-        return (Generator<List<T>>) sized(size -> {
-            @SuppressWarnings("unchecked")
-            Generator<T>[] gens = (Generator<T>[]) new Generator[size];
-            Arrays.fill(gens, gen);
-            return Generator.tuple(gens).fmap(Arrays::asList).fmap(Collections::unmodifiableList);
-        });
-    }
-}