More API changes to function java extension - support for providing both Gen and Shrink as a pair.

Author: SimY4

README.md

@@ -30,8 +30,10 @@ Use the provided `CoregexArbirary` class to generate a string that would match t
 ```java
 @RunWith(PropertyTestRunner.class)
 public class MyTest {
+  private static final Pattern PATTERN = Pattern.compile("[a-zA-Z]{3}");
+
   public Property myProperty() {
-    return property(CoregexArbitrary.of("[a-zA-Z]{3}"), str -> prop(3 == str.length()));
+    return property(CoregexArbitrary.gen(PATTERN), CoregexArbitrary.shrink(PATTERN), str -> prop(3 == str.length()));
   }
 }
 ```

functionaljava-quickcheck/src/main/java/com/github/simy4/coregex/functionaljava/quickcheck/CoregexArbitrary.java

@@ -17,6 +17,8 @@
 package com.github.simy4.coregex.functionaljava.quickcheck;
 
 import com.github.simy4.coregex.core.Coregex;
+import fj.P;
+import fj.P2;
 import fj.data.Option;
 import fj.data.Stream;
 import fj.test.Gen;
@@ -26,25 +28,21 @@
 
 public final class CoregexArbitrary {
 
-  public static Gen<String> gen(String regex) {
-    return gen(regex, 0);
+  public static P2<Gen<String>, Shrink<String>> arbitrary(Pattern pattern) {
+    return P.p(gen(pattern), shrink(pattern));
   }
 
-  public static Gen<String> gen(String regex, int flags) {
-    Coregex coregex = Coregex.from(Pattern.compile(regex, flags));
-    return Gen.gen(size -> rand -> coregex.generate(rand.choose(Long.MIN_VALUE, Long.MAX_VALUE)));
+  public static Gen<String> gen(Pattern pattern) {
+    Coregex coregex = Coregex.from(pattern);
+    return Gen.gen(__ -> rand -> coregex.generate(rand.choose(Long.MIN_VALUE, Long.MAX_VALUE)));
   }
 
-  public static Shrink<String> shrink(String regex) {
-    return shrink(regex, 0);
-  }
-
-  public static Shrink<String> shrink(String regex, int flags) {
+  public static Shrink<String> shrink(Pattern pattern) {
     Option<Stream<Coregex>> shrinks =
         Stream.sequenceOption(
             Stream.iterate(
                     opt -> opt.bind(coregex -> fromOptional(coregex.shrink())),
-                    fromOptional(Coregex.from(Pattern.compile(regex, flags)).shrink()))
+                    fromOptional(Coregex.from(pattern).shrink()))
                 .takeWhile(Option::isSome));
     return Shrink.shrink(
         str -> shrinks.orSome(Stream.nil()).map(coregex -> coregex.generate(str.length())));

functionaljava-quickcheck/src/test/java/com/github/simy4/coregex/functionaljava/quickcheck/CoregexArbitraryTest.java

@@ -17,35 +17,46 @@
 package com.github.simy4.coregex.functionaljava.quickcheck;
 
 import static fj.test.Property.prop;
-import static fj.test.Property.property;
 
 import fj.Equal;
+import fj.F;
+import fj.Ord;
+import fj.P2;
 import fj.Try;
 import fj.data.List;
 import fj.test.Arbitrary;
+import fj.test.Gen;
 import fj.test.Property;
+import fj.test.Shrink;
 import fj.test.runner.PropertyTestRunner;
 import java.net.InetAddress;
 import java.time.format.DateTimeFormatter;
 import java.util.UUID;
+import java.util.regex.Pattern;
 import org.junit.runner.RunWith;
 
 @RunWith(PropertyTestRunner.class)
 public class CoregexArbitraryTest {
   private static final Equal<String> stringEqual = Equal.stringEqual;
-  private static final Equal<List<String>> listEqual = Equal.listEqual(stringEqual);
+  private static final Ord<Integer> intOrd = Ord.intOrd;
+
+  private static <T> Property property(P2<Gen<T>, Shrink<T>> arbitrary, F<T, Property> property) {
+    return Property.property(arbitrary._1(), arbitrary._2(), property);
+  }
 
   public Property shouldGenerateMatchingUUIDString() {
     return property(
-        CoregexArbitrary.gen(
-            "[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}"),
+        CoregexArbitrary.arbitrary(
+            Pattern.compile(
+                "[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}")),
         uuid -> prop(stringEqual.eq(uuid, UUID.fromString(uuid).toString())));
   }
 
   public Property shouldGenerateMatchingIPv4String() {
     return property(
-        CoregexArbitrary.gen(
-            "((25[0-5]|(2[0-4]|1?[0-9])?[0-9])\\.){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])"),
+        CoregexArbitrary.arbitrary(
+            Pattern.compile(
+                "((25[0-5]|(2[0-4]|1?[0-9])?[0-9])\\.){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])")),
         ipv4 -> {
           String[] expected = ipv4.split("\\.");
           String[] actual =
@@ -67,19 +78,21 @@ public Property shouldGenerateMatchingIPv4String() {
   public Property shouldGenerateMatchingIsoDateString() {
     DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT;
     return property(
-        CoregexArbitrary.gen(
-            "[12]\\d{3}-(?:0[1-9]|1[012])-(?:0[1-9]|1\\d|2[0-8])T(?:1\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d{2}[1-9])?Z"),
+        CoregexArbitrary.arbitrary(
+            Pattern.compile(
+                "[12]\\d{3}-(?:0[1-9]|1[012])-(?:0[1-9]|1\\d|2[0-8])T(?:1\\d|2[0-3]):[0-5]\\d:[0-5]\\d(\\.\\d{2}[1-9])?Z")),
         iso8601Date ->
             prop(stringEqual.eq(iso8601Date, formatter.format(formatter.parse(iso8601Date)))));
   }
 
   public Property shouldGenerateUniqueStrings() {
     return property(
-        Arbitrary.arbList(CoregexArbitrary.gen("[a-zA-Z0-9]{32,}")),
+        CoregexArbitrary.arbitrary(Pattern.compile("[a-zA-Z0-9]{32,}"))
+            .split(Arbitrary::arbList, Shrink::shrinkList),
         strings ->
             strings.foldLeft(
                 (acc, s) ->
-                    acc.and(prop(s.length() >= 32))
+                    acc.and(prop(intOrd.isLessThanOrEqualTo(32, s.length())))
                         .and(prop(s.chars().allMatch(Character::isLetterOrDigit))),
                 prop(true)));
   }

functionaljava-quickcheck/src/test/java/com/github/simy4/coregex/functionaljava/quickcheck/FunctionJavaQuickcheckTest.java

@@ -9,7 +9,6 @@
 import fj.test.Property;
 import fj.test.Rand;
 import fj.test.runner.PropertyTestRunner;
-import java.util.Random;
 import java.util.regex.Pattern;
 import org.junit.runner.RunWith;
 
@@ -20,11 +19,10 @@ public Property shrinkingTest() {
     return property(
         arbitraryRegex(),
         Arbitrary.arbInteger,
-        Arbitrary.arbLong.map(Random::new),
-        (regex, size, random) -> {
-          String sample =
-              CoregexArbitrary.gen(regex.pattern(), regex.flags()).gen(size, Rand.standard);
-          return CoregexArbitrary.shrink(regex.pattern(), regex.flags())
+        Arbitrary.arbLong,
+        (regex, size, seed) -> {
+          String sample = CoregexArbitrary.gen(regex).gen(size, Rand.standard.reseed(seed));
+          return CoregexArbitrary.shrink(regex)
               .shrink(sample)
               .map(shrink -> prop(regex.matcher(shrink).matches()))
               .foldLeft(Property::and, prop(true));