jetCheck support.

Author: SimY4

README.md

@@ -11,11 +11,14 @@ A handy utility for generating strings that match given regular expression crite
 # Supported generators
 
 - [functionaljava-quickcheck](https://github.com/functionaljava/functionaljava) 
+- [hedgehog](https://hedgehogqa.github.io/scala-hedgehog/)
+- [jetCheck](https://hedgehogqa.github.io/scala-hedgehog/)
 - [Jqwik](https://jqwik.net/) 
 - [JUnit Quickcheck](https://pholser.github.io/junit-quickcheck)
 - [Kotest](https://kotest.io/)
 - [scalacheck](https://scalacheck.org/)
 - [vavr-test](https://github.com/vavr-io/vavr-test)
+- [zio-test](https://zio.dev/reference/test/)
 
 # Usage
 
@@ -59,6 +62,40 @@ public class MyTest {
 }
 ```
 
+## hedgehog-scala
+Include the following dependency into your project:
+
+```scala
+libraryDependencies ++= Seq("com.github.simy4.coregex" %% "coregex-hedgehog" % Test)
+```
+
+Use the provided `CoregexGen` class to generate a string that would match the regular expression predicate:
+
+```scala
+object MySpec extends Properties {
+  def tests: List[Test] = List(
+    property("my property", myProperty),
+  )
+
+  def myProperty: Property = for {
+    str <- CoregexGen.fromRegex("[a-zA-Z]{3}".r).forAll
+  } yield Result.assert(str.length ==== 3)
+}
+```
+
+## jetCheck
+Include the following dependency into your project:
+
+```groovy
+testImplementation "com.github.simy4.coregex:coregex-jetCheck"
+```
+
+Use the provided `CoregexGenerator` class to generate a string that would match the regular expression predicate:
+
+```java
+PropertyChecker.forAll(CoregexGenerator.of("[a-zA-Z]{3}"), str -> 3 == str.length());
+```
+
 ## Jqwik
 Include the following dependency into your project:
 
@@ -96,27 +133,6 @@ public class MyTest {
 }
 ```
 
-## hedgehog-scala
-Include the following dependency into your project:
-
-```scala
-libraryDependencies ++= Seq("com.github.simy4.coregex" %% "coregex-hedgehog" % Test)
-```
-
-Use the provided `CoregexGen` class to generate a string that would match the regular expression predicate:
-
-```scala
-object MySpec extends Properties {
-  def tests: List[Test] = List(
-    property("my property", myProperty),
-  )
-
-  def myProperty: Property = for {
-    uuid <- CoregexGen.fromRegex("[a-zA-Z]{3}".r).forAll
-  } yield Result.assert(str.length ==== 3)
-}
-```
-
 ## Kotest
 Include the following dependency into your project:
 
@@ -165,22 +181,17 @@ testImplementation "com.github.simy4.coregex:coregex-vavr-test"
 Use the provided `CoregexArbirary` class to generate a string that would match the regular expression predicate:
 
 ```java
-class MyTest {
-  @Test
-  void myProperty() {
-    Property.def("my property")
-        .forAll(CoregexArbitrary.of("[a-zA-Z]{3}"))
-        .suchThat(str -> 3 == str.length())
-        .check();
-  }
-}
+Property.def("my property")
+    .forAll(CoregexArbitrary.of("[a-zA-Z]{3}"))
+    .suchThat(str -> 3 == str.length())
+    .check();
 ```
 
 ## ZIO test
 Include the following dependency into your project:
 
-```groovy
-testImplementation "com.github.simy4.coregex:coregex-zio-test"
+```scala
+libraryDependencies ++= Seq("com.github.simy4.coregex" %% "coregex-zio-test" % Test)
 ```
 
 Use the provided `CoregexGen` class to generate a string that would match the regular expression predicate:

build.sbt

@@ -25,7 +25,7 @@ inThisBuild(
 )
 
 lazy val scala212               = "2.12.20"
-lazy val scala213               = "2.13.17"
+lazy val scala213               = "2.13.18"
 lazy val scala3                 = "3.3.7"
 lazy val supportedScalaVersions = List(scala212, scala213, scala3)
 
@@ -56,7 +56,18 @@ lazy val root = (project in file("."))
     name           := "coregex-parent",
     publish / skip := true
   )
-  .aggregate(core, functionaljavaQuickcheck, jqwik, junitQuickcheck, kotest, scalacheck, vavrTest, zioTest)
+  .aggregate(
+    core,
+    functionaljavaQuickcheck,
+    hedgehog,
+    jetCheck,
+    jqwik,
+    junitQuickcheck,
+    kotest,
+    scalacheck,
+    vavrTest,
+    zioTest
+  )
 
 lazy val core = (project in file("core"))
   .settings(
@@ -104,6 +115,22 @@ lazy val hedgehog = (project in file("hedgehog"))
   .settings(jacocoSettings)
   .dependsOn(core)
 
+lazy val jetCheck = (project in file("jetCheck"))
+  .settings(
+    name          := "jetCheck",
+    moduleName    := "coregex-jetCheck",
+    description   := "jetCheck bindings for coregex library.",
+    headerEndYear := Some(2025),
+    libraryDependencies ++= Seq(
+      "org.jetbrains"        % "jetCheck"          % "0.2.3"                          % Provided,
+      "com.github.sbt.junit" % "jupiter-interface" % JupiterKeys.jupiterVersion.value % Test
+    ),
+    testOptions += Tests.Argument(jupiterTestFramework, "-q", "-v")
+  )
+  .settings(javaLibSettings(8))
+  .settings(jacocoSettings)
+  .dependsOn(core)
+
 lazy val jqwik = (project in file("jqwik"))
   .settings(
     name          := "jqwik",

jetCheck/src/main/java/com/github/simy4/coregex/jetCheck/CoregexGenerator.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2021-2025 Alex Simkin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.simy4.coregex.jetCheck;
+
+import com.github.simy4.coregex.core.Coregex;
+import java.util.regex.Pattern;
+import org.jetbrains.jetCheck.Generator;
+
+public class CoregexGenerator {
+  public static Generator<String> of(String regex) {
+    return of(Pattern.compile(regex));
+  }
+
+  public static Generator<String> of(String regex, int flags) {
+    return of(Pattern.compile(regex, flags));
+  }
+
+  public static Generator<String> of(Pattern pattern) {
+    Coregex coregex = Coregex.from(pattern);
+    return Generator.from(
+        generationEnvironment ->
+            coregex.generate(generationEnvironment.generate(Generator.integers())));
+  }
+}

jetCheck/src/test/java/com/github/simy4/coregex/jetCheck/CoregexGeneratorTest.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021-2025 Alex Simkin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.simy4.coregex.jetCheck;
+
+import java.io.UncheckedIOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.time.format.DateTimeFormatter;
+import java.util.UUID;
+import java.util.stream.IntStream;
+import org.jetbrains.jetCheck.Generator;
+import org.jetbrains.jetCheck.PropertyChecker;
+import org.junit.jupiter.api.Test;
+
+class CoregexGeneratorTest {
+  @Test
+  void shouldGenerateMatchingUUIDString() {
+    PropertyChecker.forAll(
+        CoregexGenerator.of(
+            "[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}"),
+        uuid -> uuid.equals(UUID.fromString(uuid).toString()));
+  }
+
+  @Test
+  void shouldGenerateMatchingIPv4String() {
+    PropertyChecker.forAll(
+        CoregexGenerator.of(
+            "((25[0-5]|(2[0-4]|1?[0-9])?[0-9])\\.){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])"),
+        ipv4 -> {
+          try {
+            String[] expected = ipv4.split("\\.");
+            String[] actual = InetAddress.getByName(ipv4).getHostAddress().split("\\.");
+            return expected.length == actual.length
+                && IntStream.range(0, expected.length)
+                    .allMatch(i -> Integer.parseInt(expected[i]) == Integer.parseInt(actual[i]));
+          } catch (UnknownHostException ex) {
+            throw new UncheckedIOException(ex);
+          }
+        });
+  }
+
+  @Test
+  void shouldGenerateMatchingIsoDateString() {
+    DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT;
+    PropertyChecker.forAll(
+        CoregexGenerator.of(
+            "[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 -> iso8601Date.equals(formatter.format(formatter.parse(iso8601Date))));
+  }
+
+  @Test
+  void shouldGenerateUniqueStrings() {
+    PropertyChecker.forAll(
+        Generator.listsOf(CoregexGenerator.of("[a-zA-Z0-9]{32,}")),
+        strings ->
+            strings.stream()
+                .allMatch(s -> s.length() >= 32 && s.chars().allMatch(Character::isLetterOrDigit)));
+  }
+}