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

10 files changed, 833 insertions, 0 deletions

diff --git a/src/main/java/au/id/zancanaro/javacheck/Generator.java b/src/main/java/au/id/zancanaro/javacheck/Generator.java
new file mode 100644
index 0000000..66ebf1b
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/Generator.java
@@ -0,0 +1,36 @@
+package au.id.zancanaro.javacheck;
+
+import java.util.List;
+import java.util.Random;
+import java.util.function.Function;
+
+public interface Generator<T> {
+    RoseTree<T> generate(Random random, int size);
+
+    static <T> Generator<T> pure(T value) {
+        return (random, size) -> RoseTree.pure(value);
+    }
+
+    @SafeVarargs
+    static <T> Generator<List<T>> tuple(Generator<T>... generators) {
+        return (random, size) -> {
+            @SuppressWarnings("unchecked")
+            RoseTree<T>[] result = (RoseTree<T>[]) new RoseTree[generators.length];
+            int index = 0;
+            for (Generator<T> generator : generators) {
+                result[index++] = generator.generate(random, size);
+            }
+            return RoseTree.zip(Function.identity(), result);
+        };
+    }
+
+    default <R> Generator<R> fmap(Function<T, R> f) {
+        return (random, size) -> this.generate(random, size).fmap(f);
+    }
+
+    default <R> Generator<R> flatMap(Function<T, Generator<R>> action) {
+        return (random, size) -> {
+            return RoseTree.join(this.generate(random, size).fmap(action).fmap(g -> g.generate(random, size)));
+        };
+    }
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/Generators.java b/src/main/java/au/id/zancanaro/javacheck/Generators.java
new file mode 100644
index 0000000..ec6a329
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/Generators.java
@@ -0,0 +1,135 @@
+package au.id.zancanaro.javacheck;
+
+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 final class Generators {
+    private 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 <T> Generator<T> elements(T[] elements) {
+        return elements(Arrays.asList(elements));
+    }
+
+    public static <T> Generator<T> elements(List<T> elements) {
+        return integer(0, elements.size()).fmap(elements::get);
+    }
+
+    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 sized(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(Collections::unmodifiableList);
+    }
+
+    public static Generator<Character> character() {
+        return integer(0, 256).fmap(i -> (char) i.intValue());
+    }
+
+    public static Generator<Character> asciiCharacter() {
+        return integer(32, 127).fmap(i -> (char) i.intValue());
+    }
+
+    public static Generator<Character> alphaNumericCharacter() {
+        return oneOf(
+                integer(48, 58),
+                integer(65, 91),
+                integer(97, 123)).fmap(i -> (char) i.intValue());
+    }
+
+    public static Generator<Character> alphaCharacter() {
+        return oneOf(
+                integer(65, 91),
+                integer(97, 123)).fmap(i -> (char) i.intValue());
+    }
+
+    private static String makeString(Character[] arr) {
+        StringBuilder builder = new StringBuilder(arr.length);
+        for (Character c : arr) {
+            builder.append(c);
+        }
+        return builder.toString();
+    }
+
+    public static Generator<String> string() {
+        return stringOf(character());
+    }
+
+    public static Generator<String> stringOf(Generator<Character> charGen) {
+        return Generators.listOf(charGen).fmap(list -> {
+            StringBuilder builder = new StringBuilder(list.size());
+            for (Object c : list) {
+                builder.append(c);
+            }
+            return builder.toString();
+        });
+    }
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/Iterators.java b/src/main/java/au/id/zancanaro/javacheck/Iterators.java
new file mode 100644
index 0000000..347a927
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/Iterators.java
@@ -0,0 +1,177 @@
+package au.id.zancanaro.javacheck;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public final class Iterators {
+    private Iterators() {
+    }
+
+    public static <T> RangeIterator<T> rangeIterator(int countTo, Function<Integer,T> fn) {
+        return new RangeIterator<T>(countTo, fn);
+    }
+
+    private static class RangeIterator<T> implements Iterator<T> {
+        private final Function<Integer, T> action;
+        private final int countTo;
+        private int index = 0;
+
+        public RangeIterator(int countTo, Function<Integer, T> action) {
+            this.countTo = countTo;
+            this.action = action;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return index < countTo;
+        }
+
+        @Override
+        public T next() {
+            return action.apply(index++);
+        }
+    }
+
+    public static <T> FlattenIterator<T> flatten(Iterator<Iterator<T>> iterators) {
+        return new FlattenIterator<>(iterators);
+    }
+    public static class FlattenIterator<T> implements Iterator<T> {
+        private Iterator<T> current;
+
+        private Iterator<Iterator<T>> iterators;
+
+        public FlattenIterator(Iterator<Iterator<T>> iterators) {
+            this.current = Iterators.emptyIterator();
+            this.iterators = iterators;
+        }
+
+        private Iterator<T> getCurrent() {
+            while (!current.hasNext() && iterators.hasNext()) {
+                current = iterators.next();
+            }
+            return current;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return getCurrent().hasNext();
+        }
+        @Override
+        public T next() {
+            return getCurrent().next();
+        }
+
+    }
+
+    public static <T> ConcatIterator<T> concat(Iterator<T> left, Iterator<T> right) {
+        return new ConcatIterator<>(left, right);
+    }
+    public static class ConcatIterator<T> implements Iterator<T> {
+        private final Iterator<T> left;
+
+        private final Iterator<T> right;
+
+        public ConcatIterator(Iterator<T> left, Iterator<T> right) {
+            this.left = left;
+            this.right = right;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return left.hasNext() || right.hasNext();
+        }
+        @Override
+        public T next() {
+            if (left.hasNext()) {
+                return left.next();
+            } else {
+                return right.next();
+            }
+        }
+
+    }
+
+    public static <T> EmptyIterator<T> emptyIterator() {
+        return new EmptyIterator<>();
+    }
+    public static class EmptyIterator<T> implements Iterator<T> {
+
+        @Override
+        public boolean hasNext() {
+            return false;
+        }
+        @Override
+        public T next() {
+            return null;
+        }
+
+    }
+
+    public static <T,R> MappingIterator<T,R> mappingIterator(Function<T,R> f, Iterator<T> iterator) {
+        return new MappingIterator<>(f, iterator);
+    }
+    private static class MappingIterator<T, R> implements Iterator<R> {
+        private final Function<T, R> mapping;
+
+        private final Iterator<T> iterator;
+
+        public MappingIterator(Function<T, R> mapping, Iterator<T> iterator) {
+            this.mapping = mapping;
+            this.iterator = iterator;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return iterator.hasNext();
+        }
+        @Override
+        public R next() {
+            return mapping.apply(iterator.next());
+        }
+
+    }
+
+    public static <T> FilteringIterator<T> filteringIterator(Predicate<T> pred, Iterator<T> iterator) {
+        return new FilteringIterator<>(pred, iterator);
+    }
+
+    private static class FilteringIterator<T> implements Iterator<T> {
+        private final Predicate<T> predicate;
+        private final Iterator<T> iterator;
+        private List<T> nextValue;
+
+        public FilteringIterator(Predicate<T> pred, Iterator<T> iterator) {
+            this.predicate = pred;
+            this.iterator = iterator;
+            this.nextValue = null;
+        }
+
+        private void populateNext() {
+            while (nextValue == null && iterator.hasNext()) {
+                T value = iterator.next();
+                if (predicate.test(value)) {
+                    nextValue = Collections.singletonList(value);
+                } else {
+                    nextValue = null;
+                }
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            populateNext();
+            return nextValue != null;
+        }
+
+        @Override
+        public T next() {
+            populateNext();
+            T result = nextValue.get(0);
+            nextValue = null;
+            return result;
+        }
+    }
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/RoseTree.java b/src/main/java/au/id/zancanaro/javacheck/RoseTree.java
new file mode 100644
index 0000000..d9fb508
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/RoseTree.java
@@ -0,0 +1,105 @@
+package au.id.zancanaro.javacheck;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class RoseTree<T> {
+    private final T value;
+    private final Iterable<RoseTree<T>> children;
+
+    public RoseTree(T value, Iterable<RoseTree<T>> children) {
+        this.value = value;
+        this.children = children;
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public Iterator<RoseTree<T>> getChildren() {
+        return children.iterator();
+    }
+
+    public static <T> RoseTree<T> pure(T value) {
+        return new RoseTree<>(value, Collections.emptyList());
+    }
+
+    public static <T> RoseTree<T> join(RoseTree<RoseTree<T>> tree) {
+        return new RoseTree<>(
+                tree.getValue().getValue(),
+                () -> Iterators.concat(
+                        Iterators.mappingIterator(RoseTree::join, tree.children.iterator()),
+                        tree.getValue().children.iterator()));
+    }
+
+    public static <T> Iterator<RoseTree<T>[]> permutations(RoseTree<T>[] trees) {
+        return Iterators.flatten(Iterators.rangeIterator(trees.length, index ->
+                        Iterators.mappingIterator(child -> {
+                            @SuppressWarnings("unchecked")
+                            RoseTree<T>[] result = (RoseTree<T>[]) new RoseTree[trees.length];
+                            for (int i = 0; i < trees.length; ++i) {
+                                result[i] = (i == index ? child : trees[i]);
+                            }
+                            return result;
+                        }, trees[index].getChildren())
+        ));
+    }
+
+    public static <T, R> RoseTree<R> zip(Function<List<T>, R> fn, RoseTree<T>[] trees) {
+        @SuppressWarnings("unchecked")
+        List<T> heads = new ArrayList(trees.length);
+        for (int i = 0; i < trees.length; ++i) {
+            heads.add(trees[i].getValue());
+        }
+        return new RoseTree<>(
+                fn.apply(heads),
+                () -> Iterators.mappingIterator(
+                        roses -> RoseTree.zip(fn, roses),
+                        RoseTree.permutations(trees)));
+    }
+
+    public <R> RoseTree<R> fmap(Function<T, R> f) {
+        return new RoseTree<>(
+                f.apply(this.value),
+                () -> Iterators.mappingIterator(tree -> tree.fmap(f), this.children.iterator()));
+    }
+
+    public <R> RoseTree<R> flatmap(Function<T, RoseTree<R>> f) {
+        return RoseTree.join(this.fmap(f));
+    }
+
+    public RoseTree<T> filter(Predicate<T> predicate) {
+        if (predicate.test(this.getValue())) {
+            return new RoseTree<>(
+                    this.getValue(),
+                    () -> Iterators.mappingIterator(tree -> tree.filter(predicate),
+                            Iterators.filteringIterator(
+                                    tree -> predicate.test(tree.getValue()),
+                                    this.getChildren())));
+        } else {
+            throw new IllegalArgumentException("Current value doesn't match predicate: whoops!");
+        }
+    }
+
+    @SuppressWarnings("unused")
+    public void print(Writer output) throws IOException {
+        print(output, Object::toString);
+    }
+
+    @SuppressWarnings("unused")
+    public void print(Writer output, Function<T, String> toString) throws IOException {
+        output.write(toString.apply(this.getValue()));
+        output.write('[');
+        for (RoseTree<T> child : children) {
+            child.print(output, toString);
+        }
+        output.write(']');
+        output.flush();
+    }
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/ShrinkResult.java b/src/main/java/au/id/zancanaro/javacheck/ShrinkResult.java
new file mode 100644
index 0000000..e1463f0
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/ShrinkResult.java
@@ -0,0 +1,11 @@
+package au.id.zancanaro.javacheck;
+
+public class ShrinkResult {
+    public final Object[] args;
+    public final Throwable thrown;
+
+    public ShrinkResult(Object[] args, Throwable thrown) {
+        this.args = args;
+        this.thrown = thrown;
+    }
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/annotations/DataSource.java b/src/main/java/au/id/zancanaro/javacheck/annotations/DataSource.java
new file mode 100644
index 0000000..a954c1b
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/annotations/DataSource.java
@@ -0,0 +1,11 @@
+package au.id.zancanaro.javacheck.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DataSource {
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/annotations/Property.java b/src/main/java/au/id/zancanaro/javacheck/annotations/Property.java
new file mode 100644
index 0000000..aae4ccd
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/annotations/Property.java
@@ -0,0 +1,13 @@
+package au.id.zancanaro.javacheck.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Property {
+    int maxSize() default 100;
+    int runs() default 100;
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/annotations/Seed.java b/src/main/java/au/id/zancanaro/javacheck/annotations/Seed.java
new file mode 100644
index 0000000..ee8c739
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/annotations/Seed.java
@@ -0,0 +1,12 @@
+package au.id.zancanaro.javacheck.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Seed {
+    long value();
+}
diff --git a/src/main/java/au/id/zancanaro/javacheck/junit/Properties.java b/src/main/java/au/id/zancanaro/javacheck/junit/Properties.java
new file mode 100644
index 0000000..271e763
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/junit/Properties.java
@@ -0,0 +1,282 @@
+package au.id.zancanaro.javacheck.junit;
+
+import au.id.zancanaro.javacheck.Generator;
+import au.id.zancanaro.javacheck.RoseTree;
+import au.id.zancanaro.javacheck.ShrinkResult;
+import au.id.zancanaro.javacheck.annotations.DataSource;
+import au.id.zancanaro.javacheck.annotations.Property;
+import au.id.zancanaro.javacheck.annotations.Seed;
+import org.junit.AssumptionViolatedException;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+import java.lang.reflect.*;
+import java.util.*;
+
+
+public class Properties extends BlockJUnit4ClassRunner {
+    private final Map<Type, Generator<?>> generators = new HashMap<>();
+
+    public Properties(Class<?> klass) throws InitializationError {
+        super(klass);
+    }
+
+    @Override
+    protected void collectInitializationErrors(List<Throwable> errors) {
+        super.collectInitializationErrors(errors);
+        Set<Type> generated = validateGeneratorFields(errors);
+        validateTestMethodParameters(errors, generated);
+    }
+
+    private Set<Type> validateGeneratorFields(List<Throwable> errors) {
+        Set<Type> result = new HashSet<>();
+        Field[] fields = getTestClass().getJavaClass().getDeclaredFields();
+
+        for (Field field : fields) {
+            if (!field.isAnnotationPresent(DataSource.class)) {
+                continue;
+            }
+            Type type = field.getGenericType();
+            if (!(type instanceof ParameterizedType)) {
+                continue;
+            }
+            ParameterizedType ptype = (ParameterizedType) type;
+            if (!(ptype.getRawType() instanceof Class)) {
+                continue;
+            }
+            Class<?> c = (Class) ptype.getRawType();
+            if (c != Generator.class) {
+                continue;
+            }
+            boolean error = false;
+            if (!Modifier.isStatic(field.getModifiers())) {
+                errors.add(new Error("Generator field " + field.getName() + " must be static"));
+                error = true;
+            }
+            if (!Modifier.isPublic(field.getModifiers())) {
+                errors.add(new Error("Generator field " + field.getName() + " must be public"));
+                error = true;
+            }
+            if (!error) {
+                result.add(ptype.getActualTypeArguments()[0]);
+            }
+        }
+        return result;
+    }
+
+    private void validateTestMethodParameters(List<Throwable> errors, Set<Type> generated) {
+        for (FrameworkMethod each : computeTestMethods()) {
+            for (Type type : each.getMethod().getGenericParameterTypes()) {
+                if (!generated.contains(type)) {
+                    errors.add(new Error("No @DataSource for type: " + type));
+                    generated.add(type); // ignore future errors on this type
+                }
+            }
+        }
+    }
+
+    private static final Map<Type, Type> rawTypes;
+
+    static {
+        Map<Type, Type> types = new HashMap<>();
+        types.put(Double.class, Double.TYPE);
+        types.put(Float.class, Float.TYPE);
+        types.put(Long.class, Long.TYPE);
+        types.put(Integer.class, Integer.TYPE);
+        types.put(Short.class, Short.TYPE);
+        types.put(Byte.class, Byte.TYPE);
+        types.put(Character.class, Character.TYPE);
+        types.put(Boolean.class, Boolean.TYPE);
+        rawTypes = Collections.unmodifiableMap(types);
+    }
+
+    private Map<Type, Generator<?>> computeGenerators() {
+        if (generators.isEmpty()) {
+            Field[] fields = getTestClass().getJavaClass().getDeclaredFields();
+
+            for (Field field : fields) {
+                if (!field.isAnnotationPresent(DataSource.class)) {
+                    continue;
+                }
+                Type type = field.getGenericType();
+                if (!(type instanceof ParameterizedType)) {
+                    continue;
+                }
+                ParameterizedType ptype = (ParameterizedType) type;
+                if (!(ptype.getRawType() instanceof Class)) {
+                    continue;
+                }
+                Class<?> c = (Class) ptype.getRawType();
+                if (c != Generator.class) {
+                    continue;
+                }
+                try {
+                    Type target = ptype.getActualTypeArguments()[0];
+                    @SuppressWarnings("unchecked")
+                    Generator<Object> generator = (Generator<Object>) field.get(null);
+                    generators.put(target, generator);
+                    if (rawTypes.containsKey(target)) {
+                        generators.put(rawTypes.get(target), generator);
+                    }
+                } catch (IllegalAccessException ex) {
+
+                }
+            }
+        }
+        return generators;
+    }
+
+    @Override
+    protected void validateConstructor(List<Throwable> errors) {
+        validateOnlyOneConstructor(errors);
+    }
+
+    @Override
+    protected void validateTestMethods(List<Throwable> errors) {
+        for (FrameworkMethod each : computeTestMethods()) {
+            if (each.getAnnotation(Property.class) != null) {
+                each.validatePublicVoid(false, errors);
+                each.validateNoTypeParametersOnArgs(errors);
+            } else {
+                each.validatePublicVoidNoArg(false, errors);
+            }
+        }
+    }
+
+    @Override
+    protected List<FrameworkMethod> computeTestMethods() {
+        List<FrameworkMethod> testMethods = new ArrayList<>(super.computeTestMethods());
+        List<FrameworkMethod> theoryMethods = getTestClass().getAnnotatedMethods(Property.class);
+        testMethods.removeAll(theoryMethods);
+        testMethods.addAll(theoryMethods);
+        return testMethods;
+    }
+
+    @Override
+    public Statement methodBlock(final FrameworkMethod method) {
+        return new GenerativeTester(method, getTestClass(), computeGenerators());
+    }
+
+    public static class GenerativeTester extends Statement {
+        private final FrameworkMethod testMethod;
+        private final TestClass testClass;
+        private final Map<Type, Generator<?>> generators;
+
+        public GenerativeTester(FrameworkMethod testMethod, TestClass testClass, Map<Type, Generator<?>> generators) {
+            this.testMethod = testMethod;
+            this.testClass = testClass;
+            this.generators = generators;
+        }
+
+        private long getSeed(Method method) {
+            Seed seed = method.getAnnotation(Seed.class);
+            if (seed == null) {
+                return System.currentTimeMillis();
+            } else {
+                return seed.value();
+            }
+        }
+
+        @Override
+        public void evaluate() throws Throwable {
+            Method method = testMethod.getMethod();
+            if (method.getParameterCount() == 0) {
+                runTest(new Object[0]);
+            } else {
+                @SuppressWarnings("unchecked")
+                Generator<?>[] generators = (Generator<?>[]) new Generator[method.getParameterCount()];
+                int index = 0;
+                for (Type type : method.getGenericParameterTypes()) {
+                    // TODO: validate ahead of time that this generator will exist (ideally in the constructor validation time)
+                    generators[index++] = this.generators.get(type);
+                }
+                @SuppressWarnings("unchecked")
+                Generator<Object[]> generator = Generator.tuple((Generator<Object>[]) generators).fmap(List::toArray);
+
+                long seed = getSeed(method);
+                Random random = new Random(seed);
+
+                Property property = testMethod.getAnnotation(Property.class);
+                int assumptionsViolated = 0;
+                int maxSize = property.maxSize();
+                int numTests = property.runs();
+                for (int i = 0; i < numTests; ++i) {
+                    int size = Math.min(i + 1, maxSize);
+                    RoseTree<Object[]> tree = generator.generate(random, size);
+                    try {
+                        runTest(tree.getValue());
+                        assumptionsViolated = 0;
+                    } catch (AssumptionViolatedException ex) {
+                        numTests++;
+                        if (assumptionsViolated++ == 50) {
+                            throw new Error("Violated 50 assumptions in a row: failing test");
+                        }
+                        ;
+                    } catch (Throwable ex) {
+//                        tree.print(new OutputStreamWriter(System.out), Arrays::toString);
+                        throw new PropertyError(method.getName(), seed, shrink(tree, ex));
+                    }
+                }
+            }
+        }
+
+        private ShrinkResult shrink(RoseTree<Object[]> failed, Throwable originalEx) {
+            ShrinkResult smallest = new ShrinkResult(failed.getValue(), originalEx);
+            Iterator<RoseTree<Object[]>> trees = failed.getChildren();
+            Set<List<Object>> seenArgs = new HashSet<>();
+            while (trees.hasNext()) {
+                RoseTree<Object[]> tree = trees.next();
+                if (seenArgs.add(Arrays.asList(tree.getValue()))) {
+                    try {
+                        runTest(tree.getValue());
+                    } catch (AssumptionViolatedException ex) {
+                        // ignore, because it's not useful
+                    } catch (Throwable ex) {
+                        smallest = new ShrinkResult(tree.getValue(), ex);
+                        Iterator<RoseTree<Object[]>> children = tree.getChildren();
+                        if (children.hasNext()) {
+                            trees = children;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+            return smallest;
+        }
+
+        public void runTest(final Object[] args) throws Throwable {
+            new BlockJUnit4ClassRunner(testClass.getJavaClass()) {
+                @Override
+                protected void collectInitializationErrors(
+                        List<Throwable> errors) {
+                    // do nothing
+                }
+
+                @Override
+                public Statement methodBlock(FrameworkMethod method) {
+                    return super.methodBlock(method);
+                }
+
+                @Override
+                protected Statement methodInvoker(FrameworkMethod method, Object test) {
+                    return new Statement() {
+                        @Override
+                        public void evaluate() throws Throwable {
+                            method.invokeExplosively(test, args);
+                        }
+                    };
+                }
+
+                @Override
+                public Object createTest() throws Exception {
+                    return getTestClass().getOnlyConstructor().newInstance();
+                }
+            }.methodBlock(testMethod).evaluate();
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/au/id/zancanaro/javacheck/junit/PropertyError.java b/src/main/java/au/id/zancanaro/javacheck/junit/PropertyError.java
new file mode 100644
index 0000000..138c47f
--- /dev/null
+++ b/src/main/java/au/id/zancanaro/javacheck/junit/PropertyError.java
@@ -0,0 +1,51 @@
+package au.id.zancanaro.javacheck.junit;
+
+import au.id.zancanaro.javacheck.ShrinkResult;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class PropertyError extends AssertionError {
+    public PropertyError(String methodName, long seed, ShrinkResult shrunk) {
+        super(shrunk.thrown.getMessage() == null ?
+                String.format("%s(%s)\n\tSeed: %s",
+                        methodName, join(", ", shrunk.args),
+                        seed):
+                String.format("%s(%s)\n\tSeed: %s\n%s",
+                        methodName, join(", ", shrunk.args),
+                        seed,
+                        shrunk.thrown.getMessage()));
+        initCause(shrunk.thrown);
+    }
+
+
+    public static String join(String delimiter, Object... params) {
+        return join(delimiter, Arrays.asList(params));
+    }
+
+    public static String join(String delimiter, Collection<Object> values) {
+        StringBuilder sb = new StringBuilder();
+        Iterator<Object> iter = values.iterator();
+        while (iter.hasNext()) {
+            Object next = iter.next();
+            sb.append(stringValueOf(next));
+            if (iter.hasNext()) {
+                sb.append(delimiter);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String stringValueOf(Object next) {
+        if (next instanceof String) {
+            return '"' + ((String) next).replace("\"", "\\\"") + '"';
+        } else {
+            try {
+                return String.valueOf(next);
+            } catch (Throwable e) {
+                return "[toString failed]";
+            }
+        }
+    }
+}