deps(java): bump gradle-wrapper from 9.2.1 to 9.3.1 (#15623)

* deps(java): bump gradle-wrapper from 9.2.1 to 9.3.0

Bumps gradle-wrapper from 9.2.1 to 9.3.0.

---
updated-dependencies:
- dependency-name: gradle-wrapper
  dependency-version: 9.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update scripts, min. gradle version.

* Upgrade to gradle 9.3.1.

* Use a custom test framework implementation that is dumb. And it's good.

* Add gradle-wrapper.jar.version

* Use gradle wrapper properties to determine version in the wrapper.

* Try switching to https for emoji regeneration url.

* Add user agent to generateEmojiTokenizationTest.pl script. Regenerate.

* Another perl user agent.

* Regenerate.

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Dawid Weiss <dawid.weiss@carrotsearch.com>

Author: dependabot[bot]

build-tools/build-infra/src/main/java/org/apache/lucene/gradle/WrapperDownloader.java

@@ -38,6 +38,7 @@
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
+import java.util.regex.Pattern;
 
 /**
  * Standalone class used to download the {@code gradle-wrapper.jar}.
@@ -122,12 +123,28 @@ public void run(Path destination) throws IOException, NoSuchAlgorithmException {
       }
     }
 
-    Path versionPath =
-        destination.resolveSibling(destination.getFileName().toString() + ".version");
-    if (!Files.exists(versionPath)) {
-      throw new IOException("Wrapper version file not found: " + versionPath);
+    Path wrapperProperties =
+        destination.resolveSibling(
+            destination.getFileName().toString().replace(".jar", ".properties"));
+    if (!Files.exists(wrapperProperties)) {
+      throw new IOException("Wrapper property file not found: " + wrapperProperties);
     }
-    String wrapperVersion = Files.readString(versionPath, StandardCharsets.UTF_8).trim();
+
+    Pattern versionPattern = Pattern.compile("gradle-(?<version>.+?)-bin.zip");
+    String wrapperVersion =
+        Files.readAllLines(wrapperProperties, StandardCharsets.UTF_8).stream()
+            .map(
+                line -> {
+                  var matcher = versionPattern.matcher(line);
+                  if (matcher.find()) {
+                    return matcher.group("version");
+                  } else {
+                    return null;
+                  }
+                })
+            .filter(Objects::nonNull)
+            .findAny()
+            .orElseThrow();
 
     MessageDigest digest = MessageDigest.getInstance("SHA-256");
 

build-tools/build-infra/src/main/java/org/apache/lucene/gradle/plugins/java/TestsAndRandomizationPlugin.java

@@ -20,35 +20,55 @@
 import com.carrotsearch.gradle.buildinfra.buildoptions.BuildOptionsPlugin;
 import com.carrotsearch.randomizedtesting.generators.RandomPicks;
 import java.io.File;
+import java.io.IOException;
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.ClassModel;
 import java.nio.file.Path;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Random;
 import java.util.Set;
+import javax.inject.Inject;
 import org.apache.lucene.gradle.plugins.LuceneGradlePlugin;
 import org.apache.lucene.gradle.plugins.globals.LuceneBuildGlobalsExtension;
 import org.apache.tools.ant.taskdefs.condition.Os;
 import org.apache.tools.ant.types.Commandline;
+import org.gradle.api.Action;
 import org.gradle.api.GradleException;
 import org.gradle.api.JavaVersion;
 import org.gradle.api.Project;
 import org.gradle.api.file.Directory;
 import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.internal.file.RelativeFile;
+import org.gradle.api.internal.tasks.testing.ClassTestDefinition;
+import org.gradle.api.internal.tasks.testing.TestDefinitionProcessor;
+import org.gradle.api.internal.tasks.testing.TestFramework;
+import org.gradle.api.internal.tasks.testing.WorkerTestDefinitionProcessorFactory;
+import org.gradle.api.internal.tasks.testing.detection.TestFrameworkDetector;
+import org.gradle.api.internal.tasks.testing.filter.DefaultTestFilter;
+import org.gradle.api.internal.tasks.testing.junit.JUnitSpec;
+import org.gradle.api.internal.tasks.testing.junit.JUnitTestDefinitionProcessorFactory;
 import org.gradle.api.invocation.Gradle;
+import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.Delete;
 import org.gradle.api.tasks.InputFile;
 import org.gradle.api.tasks.Internal;
+import org.gradle.api.tasks.Nested;
 import org.gradle.api.tasks.PathSensitive;
 import org.gradle.api.tasks.PathSensitivity;
 import org.gradle.api.tasks.TaskContainer;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.api.tasks.testing.Test;
+import org.gradle.api.tasks.testing.TestFilter;
+import org.gradle.api.tasks.testing.junit.JUnitOptions;
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat;
 import org.gradle.api.tasks.testing.logging.TestLogEvent;
+import org.gradle.internal.Factory;
 import org.gradle.process.CommandLineArgumentProvider;
+import org.gradle.process.internal.worker.WorkerProcessBuilder;
 
 /** Sets up gradle's Test task configuration, including all kinds of randomized options */
 public class TestsAndRandomizationPlugin extends LuceneGradlePlugin {
@@ -425,7 +445,18 @@ public void apply(Project project) {
               }
 
               task.setWorkingDir(testsCwd);
-              task.useJUnit();
+
+              // do not use any of the existing gradle frameworks.
+              // see https://github.com/gradle/gradle/issues/36508
+              task.getTestFrameworkProperty()
+                  .set(
+                      project
+                          .getObjects()
+                          .newInstance(
+                              LuceneTestFramework.class,
+                              new Object[] {
+                                task.getFilter(), task.getTemporaryDirFactory(), task.getDryRun()
+                              }));
 
               task.setMinHeapSize(minHeapSizeOption.get());
               task.setMaxHeapSize(heapSizeOption.get());
@@ -601,4 +632,114 @@ private static boolean addVectorizationOptions(
 
     return defaultVectorizationOption.get();
   }
+
+  public abstract static class LuceneTestFramework implements TestFramework {
+    private final DefaultTestFilter filter;
+    private final Factory<File> testTaskTemporaryDir;
+    private final Provider<Boolean> dryRun;
+    private TestFrameworkDetector detector =
+        new TestFrameworkDetector() {
+          private TestDefinitionProcessor<? super ClassTestDefinition> testDefinitionProcessor;
+
+          @Override
+          public void startDetection(
+              TestDefinitionProcessor<? super ClassTestDefinition> testDefinitionProcessor) {
+            this.testDefinitionProcessor = testDefinitionProcessor;
+          }
+
+          @Override
+          public boolean processTestClass(RelativeFile testClassFile) {
+            var cc =
+                ClassFile.of(
+                    ClassFile.ConstantPoolSharingOption.NEW_POOL,
+                    ClassFile.DebugElementsOption.DROP_DEBUG,
+                    ClassFile.LineNumbersOption.DROP_LINE_NUMBERS,
+                    ClassFile.StackMapsOption.DROP_STACK_MAPS);
+
+            try {
+              ClassModel parsed = cc.parse(testClassFile.getFile().toPath());
+              String internalName = parsed.thisClass().asInternalName().replace('/', '.');
+              testDefinitionProcessor.processTestDefinition(new ClassTestDefinition(internalName));
+            } catch (Exception e) {
+              throw new RuntimeException(e);
+            }
+
+            return true;
+          }
+
+          @Override
+          public void setTestClasses(List<File> testClasses) {}
+
+          @Override
+          public void setTestClasspath(List<File> classpath) {}
+        };
+
+    @Inject
+    public LuceneTestFramework(
+        DefaultTestFilter filter, Factory<File> testTaskTemporaryDir, Provider<Boolean> dryRun) {
+      this.filter = filter;
+      this.testTaskTemporaryDir = testTaskTemporaryDir;
+      this.dryRun = dryRun;
+    }
+
+    @Inject
+    protected abstract ObjectFactory getObjectFactory();
+
+    @Override
+    public TestFramework copyWithFilters(TestFilter newTestFilters) {
+      var newTestFramework =
+          this.getObjectFactory()
+              .newInstance(
+                  LuceneTestFramework.class,
+                  new Object[] {newTestFilters, this.testTaskTemporaryDir, this.dryRun});
+      newTestFramework.getOptions().copyFrom(this.getOptions());
+      return newTestFramework;
+    }
+
+    @Override
+    public WorkerTestDefinitionProcessorFactory<?> getProcessorFactory() {
+      this.validateOptions();
+      return new JUnitTestDefinitionProcessorFactory(
+          new JUnitSpec(
+              this.filter.toSpec(),
+              this.getOptions().getIncludeCategories(),
+              this.getOptions().getExcludeCategories(),
+              this.dryRun.get()));
+    }
+
+    @Override
+    public Action<WorkerProcessBuilder> getWorkerConfigurationAction() {
+      return (workerProcessBuilder) -> {
+        workerProcessBuilder.sharedPackages(new String[] {"junit.framework"});
+        workerProcessBuilder.sharedPackages(new String[] {"junit.extensions"});
+        workerProcessBuilder.sharedPackages(new String[] {"org.junit"});
+      };
+    }
+
+    @Override
+    @Nested
+    public abstract JUnitOptions getOptions();
+
+    @Override
+    public TestFrameworkDetector getDetector() {
+      return detector;
+    }
+
+    @Override
+    public void close() throws IOException {
+      this.detector = null;
+    }
+
+    private void validateOptions() {
+      if (!this.getOptions().getIncludeCategories().isEmpty()
+          || !this.getOptions().getExcludeCategories().isEmpty()) {
+        throw new RuntimeException("Include and exclude categories are not supported in Lucene.");
+      }
+    }
+
+    @Override
+    public String getDisplayName() {
+      return "JUnit";
+    }
+  }
 }

gradle/libs.versions.toml

@@ -35,7 +35,7 @@ jts = "1.20.0"
 # unit tests
 junit = "4.13.2"
 # @keep Minimum gradle version to run the build
-minGradle = "9.2.1"
+minGradle = "9.3.1"
 # @keep This is the minimum required Java version.
 minJava = "25"
 # analysis/morfologik polish support

gradle/wrapper/gradle-wrapper.jar.sha256

@@ -1 +1 @@
-76805e32c009c0cf0dd5d206bddc9fb22ea42e84db904b764f3047de095493f3 *gradle-wrapper.jar
+b3a875ddc1f044746e1b1a55f645584505f4a10438c1afea9f15e92a7c42ec13 *gradle-wrapper.jar

gradle/wrapper/gradle-wrapper.jar.version

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 {
-    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/EmojiTokenizationTestUnicode_12_1.java": "9c4bc3ce66359cbe1e20d8e3ee718cc90caf21a4",
-    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/generateEmojiTokenizationTest.pl": "b178c0ec31dc843d5b7a8ff4ae85601a00b0a89f",
+    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/EmojiTokenizationTestUnicode_12_1.java": "5e771f9188b774ccd4fea87a9b8d53bc798f9095",
+    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/generateEmojiTokenizationTest.pl": "d859fead98e8c4ca9d6fa37e8723bdd583708c73",
     "property:unicodeVersion": "12.1"
 }

gradlew

@@ -1,5 +1,5 @@
 {
     "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/WordBreakTestUnicode_12_1.java": "--",
-    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/generateJavaUnicodeWordBreakTest.pl": "ff0d692c51f777daa72e706c2f7e527e88aecb01",
+    "lucene/test-framework/src/java/org/apache/lucene/tests/analysis/standard/generateJavaUnicodeWordBreakTest.pl": "7e82363c86893919234395e5297e6995a9b687ea",
     "property:unicodeVersion": "12.1"
 }