fix #8 Specify edge case for Try, Validation and Future as failures

src/main/java/de/befrish/jqwik/vavr/SingletonShrinkable.java

@@ -0,0 +1,32 @@
+package de.befrish.jqwik.vavr;
+
+import net.jqwik.api.Shrinkable;
+import net.jqwik.api.ShrinkingDistance;
+import net.jqwik.engine.properties.shrinking.AbstractValueShrinkable;
+
+import java.util.stream.Stream;
+
+/**
+ * @author Benno Müller
+ */
+public class SingletonShrinkable<T> extends AbstractValueShrinkable<T> {
+
+    private SingletonShrinkable(final T value) {
+        super(value);
+    }
+
+    public static <T> SingletonShrinkable<T> of(final T value) {
+        return new SingletonShrinkable<>(value);
+    }
+
+    @Override
+    public Stream<Shrinkable<T>> shrink() {
+        return Stream.of(new SingletonShrinkable(value()));
+    }
+
+    @Override
+    public ShrinkingDistance distance() {
+        return ShrinkingDistance.of(Long.MIN_VALUE);
+    }
+
+}

src/main/java/de/befrish/jqwik/vavr/arbitraries/VavrLazyArbitrary.java

@@ -3,6 +3,7 @@
 import de.befrish.jqwik.vavr.arbitraries.base.AbstractSingleValueArbitrary;
 import io.vavr.Lazy;
 import net.jqwik.api.Arbitrary;
+import net.jqwik.api.EdgeCases;
 
 public class VavrLazyArbitrary<T> extends AbstractSingleValueArbitrary<T, Lazy<T>> implements Arbitrary<Lazy<T>> {
 
@@ -15,4 +16,9 @@ protected Lazy<T> mapValue(final T value) {
         return Lazy.of(() -> value);
     }
 
+    @Override
+    protected EdgeCases<Lazy<T>> edgeCases(final Arbitrary<T> innerArbitrary) {
+        return innerArbitrary.edgeCases().map(this::mapValue);
+    }
+
 }

src/main/java/de/befrish/jqwik/vavr/arbitraries/base/AbstractDoubleValueArbitrary.java

@@ -1,9 +1,14 @@
 package de.befrish.jqwik.vavr.arbitraries.base;
 
+import io.vavr.control.Option;
 import net.jqwik.api.Arbitraries;
 import net.jqwik.api.Arbitrary;
 import net.jqwik.api.EdgeCases;
 import net.jqwik.api.RandomGenerator;
+import net.jqwik.engine.properties.arbitraries.EdgeCasesSupport;
+
+import java.util.Arrays;
+import java.util.function.Function;
 
 public abstract class AbstractDoubleValueArbitrary<T1, T2, U> implements Arbitrary<U> {
 
@@ -22,22 +27,20 @@ public AbstractDoubleValueArbitrary(final Arbitrary<T1> firstArbitrary, final Ar
     public RandomGenerator<U> generator(final int genSize) {
         return Arbitraries.of(true, false)
                 .generator(genSize)
-                .flatMap(
-                        firstValue -> firstValue
-                                ? this.firstArbitrary.map(this::mapFirstValue)
-                                : this.secondArbitrary.map(this::mapSecondValue),
-                        genSize
-                );
+                .flatMap(this::getMappedArbitrary, genSize);
+    }
 
+    private Arbitrary<U> getMappedArbitrary(final Boolean firstValue) {
+        return firstValue
+                ? this.firstArbitrary.map(this::mapFirstValue)
+                : this.secondArbitrary.map(this::mapSecondValue);
     }
 
     @Override
     public EdgeCases<U> edgeCases() {
-        return Arbitraries.of(true, false)
-                .edgeCases()
-                .flatMapArbitrary(firstValue -> firstValue
-                        ? this.firstArbitrary.map(this::mapFirstValue)
-                        : this.secondArbitrary.map(this::mapSecondValue));
+        final EdgeCases<U> firstEdgeCases = this.firstArbitrary.edgeCases().map(this::mapFirstValue);
+        final EdgeCases<U> secondEdgeCases = this.secondArbitrary.edgeCases().map(this::mapSecondValue);
+        return EdgeCasesSupport.concat(Arrays.asList(firstEdgeCases, secondEdgeCases));
     }
 
 }

src/main/java/de/befrish/jqwik/vavr/arbitraries/base/AbstractSingleValueArbitrary.java

@@ -14,14 +14,16 @@ public AbstractSingleValueArbitrary(final Arbitrary<T> innerArbitrary) {
 
     protected abstract U mapValue(T value);
 
+    protected abstract EdgeCases<U> edgeCases(final Arbitrary<T> innerArbitrary);
+
     @Override
     public RandomGenerator<U> generator(final int genSize) {
         return this.innerArbitrary.generator(genSize).map(this::mapValue);
     }
 
     @Override
     public EdgeCases<U> edgeCases() {
-        return this.innerArbitrary.edgeCases().map(this::mapValue);
+        return edgeCases(this.innerArbitrary);
     }
 
 }

src/main/java/de/befrish/jqwik/vavr/arbitraries/control/VavrOptionArbitrary.java

@@ -1,8 +1,15 @@
 package de.befrish.jqwik.vavr.arbitraries.control;
 
+import de.befrish.jqwik.vavr.SingletonShrinkable;
 import de.befrish.jqwik.vavr.arbitraries.base.AbstractSingleValueArbitrary;
 import io.vavr.control.Option;
 import net.jqwik.api.Arbitrary;
+import net.jqwik.api.EdgeCases;
+import net.jqwik.engine.properties.arbitraries.EdgeCasesSupport;
+import net.jqwik.engine.properties.shrinking.FixedValueFlatMappedShrinkable;
+import net.jqwik.engine.properties.shrinking.SampleShrinkable;
+
+import java.util.Arrays;
 
 public class VavrOptionArbitrary<T> extends AbstractSingleValueArbitrary<T, Option<T>> implements Arbitrary<Option<T>> {
 
@@ -15,4 +22,11 @@ protected Option<T> mapValue(final T value) {
         return Option.of(value);
     }
 
+    @Override
+    protected EdgeCases<Option<T>> edgeCases(final Arbitrary<T> innerArbitrary) {
+        final EdgeCases<Option<T>> noneOptionEdgeCase = EdgeCases.fromSupplier(() -> SingletonShrinkable.of(Option.none()));
+        final EdgeCases<Option<T>> someOptionEdgeCase = innerArbitrary.edgeCases().map(this::mapValue);
+        return EdgeCasesSupport.concat(Arrays.asList(noneOptionEdgeCase, someOptionEdgeCase));
+    }
+
 }