Apache Lucene open-source search software
LUCENE-10328: Module path for compiling and running tests is wrong (#571)
Dawid Weissff547e7bbdc7
diff --git a/gradle/documentation/render-javadoc.gradle b/gradle/documentation/render-javadoc.gradleindex 7bedb0ca112..139e151ee3f 100644--- a/gradle/documentation/render-javadoc.gradle+++ b/gradle/documentation/render-javadoc.gradle@@ -57,7 +57,7 @@ allprojects {outputDir = project.javadoc.destinationDir}- if (project.path == ':lucene:luke' || project.path.endsWith(".tests")) {+ if (project.path == ':lucene:luke' || !(project in rootProject.ext.mavenProjects)) {// These projects are not part of the public API so we don't render their javadocs// as part of the site's creation. A side-effect of this is that javadocs would not// be linted for these projects. To avoid this, we connect the regular javadoc task@@ -165,26 +165,6 @@ configure(project(":lucene:test-framework")) {project.tasks.withType(RenderJavadocTask) {// TODO: fix missing javadocsjavadocMissingLevel = "class"- // TODO: clean up split packages- javadocMissingIgnore = [- "org.apache.lucene.analysis",- "org.apache.lucene.analysis.standard",- "org.apache.lucene.codecs",- "org.apache.lucene.codecs.blockterms",- "org.apache.lucene.codecs.bloom",- "org.apache.lucene.codecs.compressing",- "org.apache.lucene.codecs.uniformsplit",- "org.apache.lucene.codecs.uniformsplit.sharedterms",- "org.apache.lucene.geo",- "org.apache.lucene.index",- "org.apache.lucene.search",- "org.apache.lucene.search.similarities",- "org.apache.lucene.search.spans",- "org.apache.lucene.store",- "org.apache.lucene.util",- "org.apache.lucene.util.automaton",- "org.apache.lucene.util.fst"- ]}}@@ -195,6 +175,13 @@ configure(project(":lucene:sandbox")) {}}+configure(project(":lucene:spatial-test-fixtures")) {+ project.tasks.withType(RenderJavadocTask) {+ // TODO: fix missing javadocs+ javadocMissingLevel = "class"+ }+}+configure(project(":lucene:misc")) {project.tasks.withType(RenderJavadocTask) {// TODO: fix missing javadocsdiff --git a/gradle/java/modules.gradle b/gradle/java/modules.gradleindex 5e334ab2db2..fa751167586 100644--- a/gradle/java/modules.gradle+++ b/gradle/java/modules.gradle@@ -15,6 +15,8 @@* limitations under the License.*/+import java.nio.file.Path+// Configure miscellaneous aspects required for supporting the java module system layer.// Debugging utilities.@@ -27,189 +29,162 @@ allprojects {modularity.inferModulePath.set(false)}- // Map convention configuration names to "modular" corresponding configurations.- Closure<String> moduleConfigurationNameFor = { String configurationName ->- return "module" + configurationName.capitalize().replace("Classpath", "Path")- }-- //- // For each source set, create explicit configurations for declaring modular dependencies.- // These "modular" configurations correspond 1:1 to Gradle's conventions but have a 'module' prefix- // and a capitalized remaining part of the conventional name. For example, an 'api' configuration in- // the main source set would have a corresponding 'moduleApi' configuration for declaring modular- // dependencies.- //- // Gradle's java plugin "convention" configurations extend from their modular counterparts- // so all dependencies end up on classpath by default for backward compatibility with other- // tasks and gradle infrastructure.//- // At the same time, we also know which dependencies (and their transitive graph of dependencies!)- // should be placed on module-path only.- //- // Note that an explicit configuration of modular dependencies also opens up the possibility of automatically- // validating whether the dependency configuration for a gradle project is consistent with the information in- // the module-info descriptor because there is a (nearly?) direct correspondence between the two:- //- // moduleApi - 'requires transitive'- // moduleImplementation - 'requires'- // moduleCompileOnly - 'requires static'+ // Configure modular extensions for each source set.//project.sourceSets.all { SourceSet sourceSet ->- ConfigurationContainer configurations = project.configurations-- // Create modular configurations for convention configurations.- Closure<Configuration> createModuleConfigurationForConvention = { String configurationName ->- Configuration conventionConfiguration = configurations.maybeCreate(configurationName)- Configuration moduleConfiguration = configurations.maybeCreate(moduleConfigurationNameFor(configurationName))- moduleConfiguration.canBeConsumed(false)- moduleConfiguration.canBeResolved(false)- conventionConfiguration.extendsFrom(moduleConfiguration)-- project.logger.info("Created module configuration for '${conventionConfiguration.name}': ${moduleConfiguration.name}")- return moduleConfiguration- }-- Configuration moduleApi = createModuleConfigurationForConvention(sourceSet.apiConfigurationName)- Configuration moduleImplementation = createModuleConfigurationForConvention(sourceSet.implementationConfigurationName)- moduleImplementation.extendsFrom(moduleApi)- Configuration moduleRuntimeOnly = createModuleConfigurationForConvention(sourceSet.runtimeOnlyConfigurationName)- Configuration moduleCompileOnly = createModuleConfigurationForConvention(sourceSet.compileOnlyConfigurationName)- // sourceSet.compileOnlyApiConfigurationName // This seems like a very esoteric use case, leave out.-- // Set up compilation module path configuration combining corresponding convention configurations.- Closure<Configuration> createResolvableModuleConfiguration = { String configurationName ->- Configuration conventionConfiguration = configurations.maybeCreate(configurationName)- Configuration moduleConfiguration = configurations.maybeCreate(- moduleConfigurationNameFor(conventionConfiguration.name))- moduleConfiguration.canBeConsumed(false)- moduleConfiguration.canBeResolved(true)- moduleConfiguration.attributes {- // Prefer class folders over JARs. The exception is made for tests projects which require a composition- // of classes and resources, otherwise split into two folders.- if (project.name.endsWith(".tests")) {- attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements, LibraryElements.JAR))- } else {- attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements, LibraryElements.CLASSES))- }- }-- project.logger.info("Created resolvable module configuration for '${conventionConfiguration.name}': ${moduleConfiguration.name}")- return moduleConfiguration- }-- Configuration compileModulePathConfiguration = createResolvableModuleConfiguration(sourceSet.compileClasspathConfigurationName)- compileModulePathConfiguration.extendsFrom(moduleCompileOnly, moduleImplementation)-- Configuration runtimeModulePathConfiguration = createResolvableModuleConfiguration(sourceSet.runtimeClasspathConfigurationName)- runtimeModulePathConfiguration.extendsFrom(moduleRuntimeOnly, moduleImplementation)-// Create and register a source set extension for manipulating classpath/ module-path- ModularPathsExtension modularPaths = new ModularPathsExtension(project, sourceSet,- compileModulePathConfiguration,- runtimeModulePathConfiguration)+ ModularPathsExtension modularPaths = new ModularPathsExtension(project, sourceSet)sourceSet.extensions.add("modularPaths", modularPaths)- // Customized the JavaCompile for this source set so that it has proper module path.+ // LUCENE-10344: We have to provide a special-case extension for ECJ because it does not+ // support all of the module-specific javac options.+ ModularPathsExtension modularPathsForEcj = modularPaths+ if (sourceSet.name == SourceSet.TEST_SOURCE_SET_NAME && project.path in [+ ":lucene:spatial-extras",+ ":lucene:spatial3d",+ ]) {+ modularPathsForEcj = modularPaths.cloneWithMode(ModularPathsExtension.Mode.CLASSPATH_ONLY)+ }+ sourceSet.extensions.add("modularPathsForEcj", modularPathsForEcj)++ // TODO: the tests of these projects currently don't compile or work in+ // module-path mode. Make the modular paths extension use class path only.+ if (sourceSet.name == SourceSet.TEST_SOURCE_SET_NAME && project.path in [+ // Circular dependency between artifacts or source set outputs,+ // causing package split issues at runtime.+ ":lucene:core",+ ":lucene:codecs",+ ":lucene:test-framework",+ ]) {+ modularPaths.mode = ModularPathsExtension.Mode.CLASSPATH_ONLY+ }++ // Configure the JavaCompile task associated with this source set.tasks.named(sourceSet.getCompileJavaTaskName()).configure({ JavaCompile task ->task.dependsOn modularPaths.compileModulePathConfiguration- // LUCENE-10327: don't allow gradle to emit an empty sourcepath as it would break compilation.+ // LUCENE-10327: don't allow gradle to emit an empty sourcepath as it would break+ // compilation of modules.task.options.setSourcepath(sourceSet.java.sourceDirectories)// Add modular dependencies and their transitive dependencies to module path.- task.options.compilerArgumentProviders.add((CommandLineArgumentProvider) {- def modularPathFiles = modularPaths.compileModulePathConfiguration.files- def extraArgs = []- if (!modularPathFiles.isEmpty()) {- if (!modularPaths.hasModuleDescriptor()) {- // We're compiling a non-module so we'll bring everything on module path in- // otherwise things wouldn't be part of the resolved module graph.- extraArgs += ["--add-modules", "ALL-MODULE-PATH"]- }-- extraArgs += ["--module-path", modularPathFiles.join(File.pathSeparator)]- }-- task.logger.info("Module path for ${task.path}:\n " + modularPathFiles.sort().join("\n "))-- return extraArgs- })+ task.options.compilerArgumentProviders.add(modularPaths.compilationArguments)// LUCENE-10304: if we modify the classpath here, IntelliJ no longer sees the dependencies as compile-time// dependencies, don't know why.if (!rootProject.ext.isIdea) {- // Modify the default classpath by removing anything already placed on module path.- // This could be done in a fancier way but a set difference is just fine for us here. Use a lazy- // provider to delay computation of the actual path.- task.classpath = files({ ->- def trimmedClasspath = sourceSet.compileClasspath - modularPaths.compileModulePathConfiguration- task.logger.info("Class path for ${task.path}:\n " + trimmedClasspath.files.sort().join("\n "))- return trimmedClasspath- })+ task.classpath = modularPaths.compilationClasspath+ }++ doFirst {+ modularPaths.logCompilationPaths(logger)}})++ // For source sets that contain a module descriptor, configure a jar task that combines+ // classes and resources into a single module.+ if (sourceSet.name != SourceSet.MAIN_SOURCE_SET_NAME) {+ tasks.maybeCreate(sourceSet.getJarTaskName(), org.gradle.jvm.tasks.Jar).configure({+ archiveClassifier = sourceSet.name+ from(sourceSet.output)+ })+ }+ }++ // Connect modular configurations between their "test" and "main" source sets, this reflects+ // the conventions set by the Java plugin.+ project.configurations {+ moduleTestApi.extendsFrom moduleApi+ moduleTestImplementation.extendsFrom moduleImplementation+ moduleTestRuntimeOnly.extendsFrom moduleRuntimeOnly+ moduleTestCompileOnly.extendsFrom moduleCompileOnly}+ // Gradle's java plugin sets the compile and runtime classpath to be a combination+ // of configuration dependencies and source set's outputs. For source sets with modules,+ // this leads to split class and resource folders.//- // Configure the (default) test task to use module paths.+ // We tweak the default source set path configurations here by assembling jar task outputs+ // of the respective source set, instead of their source set output folders. We also attach+ // the main source set's jar to the modular test implementation configuration.+ SourceSet mainSourceSet = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)+ boolean mainIsModular = mainSourceSet.modularPaths.hasModuleDescriptor()+ boolean mainIsEmpty = mainSourceSet.allJava.isEmpty()+ SourceSet testSourceSet = project.sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME)+ boolean testIsModular = testSourceSet.modularPaths.hasModuleDescriptor()++ // LUCENE-10304: if we modify the classpath here, IntelliJ no longer sees the dependencies as compile-time+ // dependencies, don't know why.+ if (!rootProject.ext.isIdea) {+ def jarTask = project.tasks.getByName(mainSourceSet.getJarTaskName())+ def testJarTask = project.tasks.getByName(testSourceSet.getJarTaskName())++ // Consider various combinations of module/classpath configuration between the main and test source set.+ if (testIsModular) {+ if (mainIsModular || mainIsEmpty) {+ // If the main source set is empty, skip the jar task.+ def jarTaskOutputs = mainIsEmpty ? [] : jarTask.outputs++ // Fully modular tests - must have no split packages, proper access, etc.+ // Work around the split classes/resources problem by adjusting classpaths to+ // rely on JARs rather than source set output folders.+ testSourceSet.compileClasspath = project.objects.fileCollection().from(+ jarTaskOutputs,+ project.configurations.getByName(testSourceSet.getCompileClasspathConfigurationName()),+ )+ testSourceSet.runtimeClasspath = project.objects.fileCollection().from(+ jarTaskOutputs,+ testJarTask.outputs,+ project.configurations.getByName(testSourceSet.getRuntimeClasspathConfigurationName()),+ )++ project.dependencies {+ moduleTestImplementation files(jarTaskOutputs)+ moduleTestRuntimeOnly files(testJarTask.outputs)+ }+ } else {+ // This combination simply does not make any sense (in my opinion).+ throw GradleException("Test source set is modular and main source set is class-based, this makes no sense: " + project.path)+ }+ } else {+ if (mainIsModular) {+ // This combination is a potential candidate for patching the main sourceset's module with test classes. I could+ // not resolve all the difficulties that arise when you try to do it though:+ // - either a separate module descriptor is needed that opens test packages, adds dependencies via requires clauses+ // or a series of jvm arguments (--add-reads, --add-opens, etc.) has to be generated and maintained. This is+ // very low-level (ECJ doesn't support a full set of these instructions, for example).+ //+ // Fall back to classpath mode.+ } else {+ // This is the 'plain old classpath' mode: neither the main source set nor the test set are modular.+ }+ }+ }++ //+ // Configures a Test task associated with the provided source set to use module paths.//// There is no explicit connection between source sets and test tasks so there is no way (?)// to do this automatically, convention-style.-+ //// This closure can be used to configure a different task, with a different source set, should we// have the need for it.Closure<Void> configureTestTaskForSourceSet = { Test task, SourceSet sourceSet ->task.configure {- Configuration modulePath = task.project.configurations.maybeCreate(- moduleConfigurationNameFor(sourceSet.getRuntimeClasspathConfigurationName()))+ ModularPathsExtension modularPaths = sourceSet.modularPaths- task.dependsOn modulePath+ dependsOn modularPaths// Add modular dependencies and their transitive dependencies to module path.- task.jvmArgumentProviders.add((CommandLineArgumentProvider) {- def extraArgs = []-- // Determine whether the source set classes themselves should be appended- // to classpath or module path.- boolean sourceSetIsAModule = sourceSet.modularPaths.hasModuleDescriptor()-- if (!modulePath.isEmpty() || sourceSetIsAModule) {- if (sourceSetIsAModule) {- // Add source set outputs to module path.- extraArgs += ["--module-path", (modulePath + sourceSet.output.classesDirs).files.join(File.pathSeparator)]- // Ideally, we should only add the sourceset's module here, everything else would be resolved via the- // module descriptor. But this would require parsing the module descriptor and may cause JVM version conflicts- // so keeping it simple.- extraArgs += ["--add-modules", "ALL-MODULE-PATH"]- } else {- extraArgs += ["--module-path", modulePath.files.join(File.pathSeparator)]- // In this case we're running a non-module against things on the module path so let's bring in- // everything on module path into the resolution graph.- extraArgs += ["--add-modules", "ALL-MODULE-PATH"]- }- }+ jvmArgumentProviders.add(modularPaths.runtimeArguments)- task.logger.info("Module path for ${task.path}:\n " + modulePath.files.sort().join("\n "))-- return extraArgs- })+ // Modify the default classpath.+ classpath = modularPaths.runtimeClasspath-- // Modify the default classpath by removing anything already placed on module path.- // This could be done in a fancier way but a set difference is just fine for us here. Use a lazy- // provider to delay computation of the actual path.- task.classpath = files({ ->- def trimmedClasspath = sourceSet.runtimeClasspath - modulePath-- boolean sourceSetIsAModule = sourceSet.modularPaths.hasModuleDescriptor()- if (sourceSetIsAModule) {- // also subtract the sourceSet's output directories.- trimmedClasspath = trimmedClasspath - sourceSet.output.classesDirs- }-- task.logger.info("Class path for ${task.path}:\n " + trimmedClasspath.files.sort().join("\n "))- return trimmedClasspath- })+ doFirst {+ modularPaths.logRuntimePaths(logger)+ }}}@@ -237,19 +212,233 @@ allprojects {}-class ModularPathsExtension {+//+// For a source set, create explicit configurations for declaring modular dependencies.+//+// These "modular" configurations correspond 1:1 to Gradle's conventions but have a 'module' prefix+// and a capitalized remaining part of the conventional name. For example, an 'api' configuration in+// the main source set would have a corresponding 'moduleApi' configuration for declaring modular+// dependencies.+//+// Gradle's java plugin "convention" configurations extend from their modular counterparts+// so all dependencies end up on classpath by default for backward compatibility with other+// tasks and gradle infrastructure.+//+// At the same time, we also know which dependencies (and their transitive graph of dependencies!)+// should be placed on module-path only.+//+// Note that an explicit configuration of modular dependencies also opens up the possibility of automatically+// validating whether the dependency configuration for a gradle project is consistent with the information in+// the module-info descriptor because there is a (nearly?) direct correspondence between the two:+//+// moduleApi - 'requires transitive'+// moduleImplementation - 'requires'+// moduleCompileOnly - 'requires static'+//+class ModularPathsExtension implements Cloneable, Iterable<Object> {+ /**+ * Determines how paths are split between module path and classpath.+ */+ enum Mode {+ /**+ * Dependencies and source set outputs are placed on classpath, even if declared on modular+ * configurations. This would be the 'default' backward-compatible mode.+ */+ CLASSPATH_ONLY,++ /**+ * Dependencies from modular configurations are placed on module path. Source set outputs+ * are placed on classpath.+ */+ DEPENDENCIES_ON_MODULE_PATH+ }+Project projectSourceSet sourceSetConfiguration compileModulePathConfigurationConfiguration runtimeModulePathConfiguration+ Configuration modulePatchOnlyConfiguration- ModularPathsExtension(Project project, SourceSet sourceSet,- Configuration compileModulePathConfiguration,- Configuration runtimeModulePathConfiguration) {- this.project = project+ // The mode of splitting paths for this source set.+ Mode mode = Mode.DEPENDENCIES_ON_MODULE_PATH++ // More verbose debugging for paths.+ private boolean debugPaths++ /**+ * A list of module name - path provider entries that will be converted+ * into {@code --patch-module} options.+ */+ private List<Map.Entry<String, Provider<Path>>> modulePatches = new ArrayList<>()++ ModularPathsExtension(Project project, SourceSet sourceSet) {+ this.project = projectthis.sourceSet = sourceSet- this.compileModulePathConfiguration = compileModulePathConfiguration- this.runtimeModulePathConfiguration = runtimeModulePathConfiguration++ debugPaths = Boolean.parseBoolean(project.propertyOrDefault('build.debug.paths', 'false'))++ ConfigurationContainer configurations = project.configurations++ // Create modular configurations for gradle's java plugin convention configurations.+ Configuration moduleApi = createModuleConfigurationForConvention(sourceSet.apiConfigurationName)+ Configuration moduleImplementation = createModuleConfigurationForConvention(sourceSet.implementationConfigurationName)+ Configuration moduleRuntimeOnly = createModuleConfigurationForConvention(sourceSet.runtimeOnlyConfigurationName)+ Configuration moduleCompileOnly = createModuleConfigurationForConvention(sourceSet.compileOnlyConfigurationName)+++ // Apply hierarchy relationships to modular configurations.+ moduleImplementation.extendsFrom(moduleApi)++ // Patched modules have to end up in the implementation configuration for IDEs, which+ // otherwise get terribly confused.+ Configuration modulePatchOnly = createModuleConfigurationForConvention(+ SourceSet.isMain(sourceSet) ? "patchOnly" : sourceSet.name + "PatchOnly")+ modulePatchOnly.canBeResolved(true)+ moduleImplementation.extendsFrom(modulePatchOnly)+ this.modulePatchOnlyConfiguration = modulePatchOnly++ // This part of convention configurations seems like a very esoteric use case, leave out for now.+ // sourceSet.compileOnlyApiConfigurationName++ // We have to ensure configurations are using assembled resources and classes (jar variant) as a single+ // module can't be expanded into multiple folders.+ Closure<Void> ensureJarVariant = { Configuration c ->+ c.attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements, LibraryElements.JAR))+ }++ // Set up compilation module path configuration combining corresponding convention configurations.+ Closure<Configuration> createResolvableModuleConfiguration = { String configurationName ->+ Configuration conventionConfiguration = configurations.maybeCreate(configurationName)+ Configuration moduleConfiguration = configurations.maybeCreate(moduleConfigurationNameFor(conventionConfiguration.name))+ moduleConfiguration.canBeConsumed(false)+ moduleConfiguration.canBeResolved(true)+ ensureJarVariant(moduleConfiguration)++ project.logger.info("Created resolvable module configuration for '${conventionConfiguration.name}': ${moduleConfiguration.name}")+ return moduleConfiguration+ }++ ensureJarVariant(configurations.maybeCreate(sourceSet.compileClasspathConfigurationName))+ ensureJarVariant(configurations.maybeCreate(sourceSet.runtimeClasspathConfigurationName))++ this.compileModulePathConfiguration = createResolvableModuleConfiguration(sourceSet.compileClasspathConfigurationName)+ compileModulePathConfiguration.extendsFrom(moduleCompileOnly, moduleImplementation)++ this.runtimeModulePathConfiguration = createResolvableModuleConfiguration(sourceSet.runtimeClasspathConfigurationName)+ runtimeModulePathConfiguration.extendsFrom(moduleRuntimeOnly, moduleImplementation)+ }++ /**+ * Adds {@code --patch-module} option for the provided module name and the provider of a+ * folder or JAR file.+ *+ * @param moduleName+ * @param pathProvider+ */+ void patchModule(String moduleName, Provider<Path> pathProvider) {+ modulePatches.add(Map.entry(moduleName, pathProvider));+ }++ private FileCollection getCompilationModulePath() {+ if (mode == Mode.CLASSPATH_ONLY) {+ return project.files()+ }+ return compileModulePathConfiguration - modulePatchOnlyConfiguration+ }++ private FileCollection getRuntimeModulePath() {+ if (mode == Mode.CLASSPATH_ONLY) {+ if (hasModuleDescriptor()) {+ // The source set is itself a module.+ throw new GradleException("Source set contains a module but classpath-only" ++ " dependencies requested: ${project.path}, source set '${sourceSet.name}'")+ }++ return project.files()+ }++ return runtimeModulePathConfiguration - modulePatchOnlyConfiguration+ }++ FileCollection getCompilationClasspath() {+ if (mode == Mode.CLASSPATH_ONLY) {+ return sourceSet.compileClasspath+ }++ // Modify the default classpath by removing anything already placed on module path.+ // Use a lazy provider to delay computation.+ project.files({ ->+ return sourceSet.compileClasspath - compileModulePathConfiguration - modulePatchOnlyConfiguration+ })+ }++ CommandLineArgumentProvider getCompilationArguments() {+ return new CommandLineArgumentProvider() {+ @Override+ Iterable<String> asArguments() {+ FileCollection modulePath = ModularPathsExtension.this.compilationModulePath++ if (modulePath.isEmpty()) {+ return []+ }++ ArrayList<String> extraArgs = []+ extraArgs += ["--module-path", modulePath.join(File.pathSeparator)]++ if (!hasModuleDescriptor()) {+ // We're compiling what appears to be a non-module source set so we'll+ // bring everything on module path in the resolution graph,+ // otherwise modular dependencies wouldn't be part of the resolved module graph and this+ // would result in class-not-found compilation problems.+ extraArgs += ["--add-modules", "ALL-MODULE-PATH"]+ }++ // Add module-patching.+ extraArgs += getPatchModuleArguments(modulePatches)++ return extraArgs+ }+ }+ }++ FileCollection getRuntimeClasspath() {+ if (mode == Mode.CLASSPATH_ONLY) {+ return sourceSet.runtimeClasspath+ }++ // Modify the default classpath by removing anything already placed on module path.+ // Use a lazy provider to delay computation.+ project.files({ ->+ return sourceSet.runtimeClasspath - runtimeModulePath - modulePatchOnlyConfiguration+ })+ }++ CommandLineArgumentProvider getRuntimeArguments() {+ return new CommandLineArgumentProvider() {+ @Override+ Iterable<String> asArguments() {+ FileCollection modulePath = ModularPathsExtension.this.runtimeModulePath++ if (modulePath.isEmpty()) {+ return []+ }++ def extraArgs = []++ // Add source set outputs to module path.+ extraArgs += ["--module-path", modulePath.files.join(File.pathSeparator)]++ // Ideally, we should only add the sourceset's module here, everything else would be resolved via the+ // module descriptor. But this would require parsing the module descriptor and may cause JVM version conflicts+ // so keeping it simple.+ extraArgs += ["--add-modules", "ALL-MODULE-PATH"]++ // Add module-patching.+ extraArgs += getPatchModuleArguments(modulePatches)++ return extraArgs+ }+ }}boolean hasModuleDescriptor() {@@ -257,4 +446,86 @@ class ModularPathsExtension {.map(dir -> new File(dir, "module-info.java")).anyMatch(file -> file.exists())}++ private List<String> getPatchModuleArguments(List<Map.Entry<String, Provider<Path>>> patches) {+ def args = []+ patches.each {+ args.add("--patch-module");+ args.add(it.key + "=" + it.value.get())+ }+ return args+ }++ private static String toList(FileCollection files) {+ return files.isEmpty() ? " [empty]" : ("\n " + files.sort().join("\n "))+ }++ private static String toList(List<Map.Entry<String, Provider<Path>>> patches) {+ return patches.isEmpty() ? " [empty]" : ("\n " + patches.collect {"${it.key}=${it.value.get()}"}.join("\n "))+ }++ public void logCompilationPaths(Logger logger) {+ def value = "Modular extension, compilation paths, source set=${sourceSet.name}${hasModuleDescriptor() ? " (module)" : ""}, mode=${mode}:\n" ++ " Module path:${toList(compilationModulePath)}\n" ++ " Class path: ${toList(compilationClasspath)}\n" ++ " Patches: ${toList(modulePatches)}"++ if (debugPaths) {+ logger.lifecycle(value)+ } else {+ logger.info(value)+ }+ }++ public void logRuntimePaths(Logger logger) {+ def value = "Modular extension, runtime paths, source set=${sourceSet.name}${hasModuleDescriptor() ? " (module)" : ""}, mode=${mode}:\n" ++ " Module path:${toList(runtimeModulePath)}\n" ++ " Class path: ${toList(runtimeClasspath)}\n" ++ " Patches : ${toList(modulePatches)}"++ if (debugPaths) {+ logger.lifecycle(value)+ } else {+ logger.info(value)+ }+ }++ public ModularPathsExtension clone() {+ return (ModularPathsExtension) super.clone()+ }++ ModularPathsExtension cloneWithMode(Mode newMode) {+ def cloned = this.clone()+ cloned.mode = newMode+ return cloned+ }++ // Map convention configuration names to "modular" corresponding configurations.+ static String moduleConfigurationNameFor(String configurationName) {+ return "module" + configurationName.capitalize().replace("Classpath", "Path")+ }++ // Create module configuration for the corresponding convention configuration.+ private Configuration createModuleConfigurationForConvention(String configurationName) {+ ConfigurationContainer configurations = project.configurations+ Configuration conventionConfiguration = configurations.maybeCreate(configurationName)+ Configuration moduleConfiguration = configurations.maybeCreate(moduleConfigurationNameFor(configurationName))+ moduleConfiguration.canBeConsumed(false)+ moduleConfiguration.canBeResolved(false)+ conventionConfiguration.extendsFrom(moduleConfiguration)++ project.logger.info("Created module configuration for '${conventionConfiguration.name}': ${moduleConfiguration.name}")+ return moduleConfiguration+ }++ /**+ * Provide internal dependencies for tasks willing to depend on this modular paths object.+ */+ @Override+ Iterator<Object> iterator() {+ return [+ compileModulePathConfiguration,+ runtimeModulePathConfiguration+ ].iterator()+ }}\ No newline at end of filediff --git a/gradle/maven/publications.gradle b/gradle/maven/publications.gradleindex cc9bc9682d0..17b444b09e8 100644--- a/gradle/maven/publications.gradle+++ b/gradle/maven/publications.gradle@@ -38,7 +38,9 @@ configure(rootProject) {// Exclude the parent container project for analysis modules (no artifacts).":lucene:analysis",// Exclude the native module.- ":lucene:misc:native"+ ":lucene:misc:native",+ // Exclude test fixtures.+ ":lucene:spatial-test-fixtures"]// Exclude all subprojects that are modular test projects and those explicitlydiff --git a/gradle/validation/check-environment.gradle b/gradle/validation/check-environment.gradleindex 7694f8d5d43..00912c4e11c 100644--- a/gradle/validation/check-environment.gradle+++ b/gradle/validation/check-environment.gradle@@ -33,14 +33,20 @@ configure(rootProject) {def currentJavaVersion = JavaVersion.current()if (currentJavaVersion < minJavaVersion) {throw new GradleException("At least Java ${minJavaVersion} is required, you are running Java ${currentJavaVersion} "- + "[${System.getProperty('java.vm.name')} ${System.getProperty('java.vm.version')}]")+ + "[${System.getProperty('java.vm.name')} ${System.getProperty('java.vm.version')}]")}// If we're regenerating the wrapper, skip the check.if (!gradle.startParameter.taskNames.contains("wrapper")) {def currentGradleVersion = GradleVersion.current()if (currentGradleVersion != GradleVersion.version(expectedGradleVersion)) {- throw new GradleException("Gradle ${expectedGradleVersion} is required (hint: use the gradlew script): this gradle is ${currentGradleVersion}")+ if (currentGradleVersion.baseVersion == GradleVersion.version(expectedGradleVersion).baseVersion) {+ logger.warn("Gradle ${expectedGradleVersion} is required but base version of this gradle matches, proceeding (" ++ "this gradle is ${currentGradleVersion})")+ } else {+ throw new GradleException("Gradle ${expectedGradleVersion} is required (hint: use the gradlew script): " ++ "this gradle is ${currentGradleVersion}")+ }}}}diff --git a/gradle/validation/ecj-lint.gradle b/gradle/validation/ecj-lint.gradleindex 0d99d2cecce..33b79ca149e 100644--- a/gradle/validation/ecj-lint.gradle+++ b/gradle/validation/ecj-lint.gradle@@ -74,42 +74,36 @@ allprojects {args += [ "-properties", file("${resources}/ecj.javadocs.prefs").absolutePath ]// We depend on modular paths.- def modularPaths = sourceSet.modularPaths- dependsOn modularPaths.compileModulePathConfiguration+ def modularPaths = sourceSet.modularPathsForEcj+ dependsOn modularPaths- // Place input files in an external file to dodge command line argument- // limits. We could pass a directory but ecj seems to be buggy: when it- // encounters a module-info.java file it no longer compiles other source files.- def inputsFile = file("${tmpDst}/ecj-inputs.txt")+ // Add modular dependencies and their transitive dependencies to module path.+ task.argumentProviders.add(modularPaths.compilationArguments)+ // Add classpath, if needed.task.argumentProviders.add((CommandLineArgumentProvider) {- // Add modular dependencies and their transitive dependencies to module path.- def modularPathFiles = modularPaths.compileModulePathConfiguration.files- def extraArgs = []- if (!modularPathFiles.isEmpty()) {- if (!modularPaths.hasModuleDescriptor()) {- // We're compiling a non-module so we'll bring everything on module path in- // otherwise things wouldn't be part of the resolved module graph.- extraArgs += ["--add-modules", "ALL-MODULE-PATH"]- }-- extraArgs += ["--module-path", modularPathFiles.join(File.pathSeparator)]- }-// Add classpath locations in a lazy provider (can't resolve the// configuration at evaluation time). Filter out non-existing entries// (output folders for non-existing input source dirs like resources).- def cpath = sourceSet.compileClasspath.filter { p -> p.exists() }- cpath = cpath - modularPathFiles+ FileCollection cpath = modularPaths.compilationClasspath.filter { p -> p.exists() }if (!cpath.isEmpty()) {- extraArgs += ["-classpath", cpath.join(File.pathSeparator)]+ return ["-classpath", cpath.join(File.pathSeparator)]+ } else {+ return []}+ })- extraArgs += ["@" + inputsFile.absolutePath]- return extraArgs+ // Place input files in an external file to dodge command line argument+ // limits. We could pass a directory but ecj seems to be buggy: when it+ // encounters a module-info.java file it no longer compiles other source files.+ def inputsFile = file("${tmpDst}/ecj-inputs.txt")+ task.argumentProviders.add((CommandLineArgumentProvider) {+ return ["@" + inputsFile.absolutePath]})doFirst {+ modularPaths.logCompilationPaths(logger)+tmpDst.mkdirs()// escape filename accoring to ECJ's rules:@@ -118,7 +112,12 @@ allprojects {def escapeFileName = { String s -> s.replaceAll(/ +/, /"$0"/) }inputsFile.setText(srcDirs.collectMany { dir ->- project.fileTree(dir: dir, include: "**/*.java" ).files+ project.fileTree(+ dir: dir,+ include: "**/*.java",+ // Exclude the benchmark class with dependencies on nekohtml, which causes module-classpath conflicts and breaks ecj.+ exclude: "**/DemoHTMLParser.java"+ ).files}// Try to sort all input files; a side-effect of this should be that module-info.java// is placed first on the list, which works around ECJ bug:diff --git a/gradle/validation/validate-source-patterns.gradle b/gradle/validation/validate-source-patterns.gradleindex cc01d37e981..40080eaea80 100644--- a/gradle/validation/validate-source-patterns.gradle+++ b/gradle/validation/validate-source-patterns.gradle@@ -154,12 +154,11 @@ class ValidateSourcePatternsTask extends DefaultTask {(~$/\n\s*var\s+.*=.*<>.*/$) : 'Diamond operators should not be used with var']- def found = 0;def violations = new TreeSet();def reportViolation = { f, name ->- logger.error('{}: {}', name, f);- violations.add(name);- found++;+ String msg = String.format(Locale.ROOT, "%s: %s", f, name)+ logger.error(msg)+ violations.add(msg)}def javadocsPattern = ~$/(?sm)^\Q/**\E(.*?)\Q*/\E/$;@@ -258,9 +257,10 @@ class ValidateSourcePatternsTask extends DefaultTask {}progress.completed()- if (found) {- throw new GradleException(String.format(Locale.ENGLISH, 'Found %d violations in source files (%s).',- found, violations.join(', ')));+ if (!violations.isEmpty()) {+ throw new GradleException(String.format(Locale.ENGLISH, 'Found %d source violation(s):\n %s',+ violations.size(),+ violations.join('\n ')))}}}diff --git a/lucene/analysis/common/build.gradle b/lucene/analysis/common/build.gradleindex 1815041f46f..6530ac6f908 100644--- a/lucene/analysis/common/build.gradle+++ b/lucene/analysis/common/build.gradle@@ -21,7 +21,7 @@ description = 'Analyzers for indexing content in different languages and domainsdependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}// Fetch the data and enable regression tests against woorm/ libreoffice dictionaries.diff --git a/lucene/analysis/icu/build.gradle b/lucene/analysis/icu/build.gradleindex e76b32789a1..aba455f4e54 100644--- a/lucene/analysis/icu/build.gradle+++ b/lucene/analysis/icu/build.gradle@@ -25,5 +25,5 @@ dependencies {moduleApi 'com.ibm.icu:icu4j'- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/kuromoji/build.gradle b/lucene/analysis/kuromoji/build.gradleindex 07fc0b0fe31..fd8aedbbc1e 100644--- a/lucene/analysis/kuromoji/build.gradle+++ b/lucene/analysis/kuromoji/build.gradle@@ -23,5 +23,5 @@ dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:analysis:common')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/morfologik.tests/build.gradle b/lucene/analysis/morfologik.tests/build.gradleindex 9cd6720fa1c..d2f94ddc33f 100644--- a/lucene/analysis/morfologik.tests/build.gradle+++ b/lucene/analysis/morfologik.tests/build.gradle@@ -21,8 +21,5 @@ description = 'Module tests for :lucene:analysis:morfologik'dependencies {moduleTestImplementation project(':lucene:analysis:morfologik')- moduleTestImplementation("junit:junit", {- exclude group: "org.hamcrest"- })- moduleTestImplementation "org.hamcrest:hamcrest"+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/morfologik.tests/src/test/module-info.java b/lucene/analysis/morfologik.tests/src/test/module-info.javaindex 15642a9421f..b6f869fca65 100644--- a/lucene/analysis/morfologik.tests/src/test/module-info.java+++ b/lucene/analysis/morfologik.tests/src/test/module-info.java@@ -21,7 +21,7 @@ module org.apache.lucene.analysis.morfologik.tests {requires org.apache.lucene.core;requires org.apache.lucene.analysis.common;requires org.apache.lucene.analysis.morfologik;- requires junit;+ requires org.apache.lucene.test_framework;exports org.apache.lucene.analysis.morfologik.tests;}diff --git a/lucene/analysis/morfologik.tests/src/test/org/apache/lucene/analysis/morfologik/tests/TestMorfologikAnalyzer.java b/lucene/analysis/morfologik.tests/src/test/org/apache/lucene/analysis/morfologik/tests/TestMorfologikAnalyzer.javaindex c2933fc7f28..b1607d9ab44 100644--- a/lucene/analysis/morfologik.tests/src/test/org/apache/lucene/analysis/morfologik/tests/TestMorfologikAnalyzer.java+++ b/lucene/analysis/morfologik.tests/src/test/org/apache/lucene/analysis/morfologik/tests/TestMorfologikAnalyzer.java@@ -19,28 +19,24 @@ package org.apache.lucene.analysis.morfologik.tests;import org.apache.lucene.analysis.morfologik.MorfologikAnalyzer;import org.apache.lucene.analysis.uk.UkrainianMorfologikAnalyzer;import org.apache.lucene.index.IndexWriter;+import org.apache.lucene.tests.util.LuceneTestCase;import org.junit.Assert;-import org.junit.Test;-public class TestMorfologikAnalyzer {- @Test+public class TestMorfologikAnalyzer extends LuceneTestCase {public void testMorfologikAnalyzerLoads() {var analyzer = new MorfologikAnalyzer();Assert.assertNotNull(analyzer);}- @Testpublic void testUkrainianMorfologikAnalyzerLoads() {var analyzer = new UkrainianMorfologikAnalyzer();Assert.assertNotNull(analyzer);}- @Testpublic void testWeAreModule() {Assert.assertTrue(this.getClass().getModule().isNamed());}- @Testpublic void testLuceneIsAModule() {Assert.assertTrue(IndexWriter.class.getModule().isNamed());}diff --git a/lucene/analysis/morfologik/build.gradle b/lucene/analysis/morfologik/build.gradleindex 03d7c098d93..4faee5d3424 100644--- a/lucene/analysis/morfologik/build.gradle+++ b/lucene/analysis/morfologik/build.gradle@@ -27,5 +27,5 @@ dependencies {moduleImplementation 'org.carrot2:morfologik-polish'moduleImplementation 'ua.net.nlp:morfologik-ukrainian-search'- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/nori/build.gradle b/lucene/analysis/nori/build.gradleindex 079cf50010e..c84ade814f9 100644--- a/lucene/analysis/nori/build.gradle+++ b/lucene/analysis/nori/build.gradle@@ -22,7 +22,7 @@ description = 'Korean Morphological Analyzer'dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:analysis:common')-- testImplementation project(':lucene:test-framework')++ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/opennlp/build.gradle b/lucene/analysis/opennlp/build.gradleindex 3fee61a188e..2964e88d212 100644--- a/lucene/analysis/opennlp/build.gradle+++ b/lucene/analysis/opennlp/build.gradle@@ -24,5 +24,5 @@ dependencies {moduleApi project(':lucene:analysis:common')moduleApi 'org.apache.opennlp:opennlp-tools'- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/phonetic/build.gradle b/lucene/analysis/phonetic/build.gradleindex 2297af53c85..1b8eee8f845 100644--- a/lucene/analysis/phonetic/build.gradle+++ b/lucene/analysis/phonetic/build.gradle@@ -25,6 +25,6 @@ dependencies {moduleApi 'commons-codec:commons-codec'- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/smartcn/build.gradle b/lucene/analysis/smartcn/build.gradleindex 960be700e71..87aafc971d6 100644--- a/lucene/analysis/smartcn/build.gradle+++ b/lucene/analysis/smartcn/build.gradle@@ -23,5 +23,5 @@ dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:analysis:common')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/analysis/stempel/build.gradle b/lucene/analysis/stempel/build.gradleindex 32991597fd7..52d1b816c5e 100644--- a/lucene/analysis/stempel/build.gradle+++ b/lucene/analysis/stempel/build.gradle@@ -23,5 +23,5 @@ dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:analysis:common')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/backward-codecs/build.gradle b/lucene/backward-codecs/build.gradleindex d5e25d92c49..528c1a5aca5 100644--- a/lucene/backward-codecs/build.gradle+++ b/lucene/backward-codecs/build.gradle@@ -22,5 +22,5 @@ description = 'Codecs for older versions of Lucene'dependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/benchmark/build.gradle b/lucene/benchmark/build.gradleindex 9da51c36229..97f17bd3cfb 100644--- a/lucene/benchmark/build.gradle+++ b/lucene/benchmark/build.gradle@@ -36,11 +36,18 @@ dependencies {moduleImplementation "org.locationtech.spatial4j:spatial4j"moduleImplementation ("net.sourceforge.nekohtml:nekohtml", {exclude module: "xml-apis"+ // LUCENE-10337: Exclude xercesImpl from module path because it has split packages with the JDK (!)+ exclude module: "xercesImpl"+ })++ // LUCENE-10337: Include xercesImpl on regular classpath where it won't cause conflicts.+ implementation ("xerces:xercesImpl", {+ exclude module: "xml-apis"})moduleRuntimeOnly project(':lucene:analysis:icu')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}// We add 'conf' to resources because we validate *.alg script correctness in one of the tests.diff --git a/lucene/classification/build.gradle b/lucene/classification/build.gradleindex 8566cdbf146..1b8a1bdb3fa 100644--- a/lucene/classification/build.gradle+++ b/lucene/classification/build.gradle@@ -25,7 +25,7 @@ dependencies {moduleImplementation project(':lucene:queries')moduleImplementation project(':lucene:grouping')- testImplementation project(':lucene:test-framework')- testImplementation project(':lucene:analysis:common')- testImplementation project(':lucene:codecs')+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:analysis:common')+ moduleTestImplementation project(':lucene:codecs')}diff --git a/lucene/codecs/build.gradle b/lucene/codecs/build.gradleindex 92e0782c9c0..1de66fe9bbb 100644--- a/lucene/codecs/build.gradle+++ b/lucene/codecs/build.gradle@@ -21,5 +21,5 @@ description = 'Lucene codecs and postings formats'dependencies {moduleImplementation project(':lucene:core')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/MockTermStateFactory.java b/lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/tests/MockTermStateFactory.javasimilarity index 71%rename from lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/MockTermStateFactory.javarename to lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/tests/MockTermStateFactory.javaindex 17ee5ef8bb0..69c36e792c0 100644--- a/lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/MockTermStateFactory.java+++ b/lucene/codecs/src/test/org/apache/lucene/codecs/lucene90/tests/MockTermStateFactory.java@@ -15,13 +15,14 @@* limitations under the License.*/-package org.apache.lucene.codecs.lucene90;+package org.apache.lucene.codecs.lucene90.tests;-/** Test utility class to create mock {@link Lucene90PostingsFormat.IntBlockTermState}. */-public class MockTermStateFactory {+import org.apache.lucene.codecs.lucene90.Lucene90PostingsFormat.IntBlockTermState;- /** Creates an empty {@link Lucene90PostingsFormat.IntBlockTermState}. */- public static Lucene90PostingsFormat.IntBlockTermState create() {- return new Lucene90PostingsFormat.IntBlockTermState();+/** Test utility class to create mock {@link IntBlockTermState}. */+public class MockTermStateFactory {+ /** Creates an empty {@link IntBlockTermState}. */+ public static IntBlockTermState create() {+ return new IntBlockTermState();}}diff --git a/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/TestBlockWriter.java b/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/TestBlockWriter.javaindex 5d74e7bf0d0..5f05cb09f07 100644--- a/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/TestBlockWriter.java+++ b/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/TestBlockWriter.java@@ -19,7 +19,7 @@ package org.apache.lucene.codecs.uniformsplit;import java.io.IOException;import java.util.Collections;-import org.apache.lucene.codecs.lucene90.MockTermStateFactory;+import org.apache.lucene.codecs.lucene90.tests.MockTermStateFactory;import org.apache.lucene.index.DocValuesType;import org.apache.lucene.index.FieldInfo;import org.apache.lucene.index.IndexOptions;diff --git a/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/sharedterms/TestSTBlockReader.java b/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/sharedterms/TestSTBlockReader.javaindex 2a5e9121edf..dc5a4c20cab 100644--- a/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/sharedterms/TestSTBlockReader.java+++ b/lucene/codecs/src/test/org/apache/lucene/codecs/uniformsplit/sharedterms/TestSTBlockReader.java@@ -27,7 +27,7 @@ import java.util.Map;import java.util.Set;import org.apache.lucene.codecs.BlockTermState;import org.apache.lucene.codecs.PostingsReaderBase;-import org.apache.lucene.codecs.lucene90.MockTermStateFactory;+import org.apache.lucene.codecs.lucene90.tests.MockTermStateFactory;import org.apache.lucene.codecs.uniformsplit.BlockHeader;import org.apache.lucene.codecs.uniformsplit.BlockLine;import org.apache.lucene.codecs.uniformsplit.FSTDictionary;diff --git a/lucene/core.tests/build.gradle b/lucene/core.tests/build.gradleindex 9ada3003aaa..4bc8bf5cef5 100644--- a/lucene/core.tests/build.gradle+++ b/lucene/core.tests/build.gradle@@ -21,8 +21,5 @@ description = 'Module tests for :lucene:core'dependencies {moduleTestImplementation project(':lucene:core')- moduleTestImplementation("junit:junit", {- exclude group: "org.hamcrest"- })- moduleTestImplementation "org.hamcrest:hamcrest"+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/core.tests/src/java/module-info.java b/lucene/core.tests/src/java/module-info.javanew file mode 100644index 00000000000..28f8806f876--- /dev/null+++ b/lucene/core.tests/src/java/module-info.java@@ -0,0 +1,24 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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.+ */++/**+ * A placeholder module descriptor just so that we can check whether referencing it from the actual+ * test module works.+ */+module org.apache.lucene.core.tests.main {+ exports org.apache.lucene.core.tests.main;+}diff --git a/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/EmptyReference.java b/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/EmptyReference.javanew file mode 100644index 00000000000..55c367b5729--- /dev/null+++ b/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/EmptyReference.java@@ -0,0 +1,23 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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 org.apache.lucene.core.tests.main;++/** Just an empty class to reference from the actual tests. */+public class EmptyReference {+ /** No instantiation. */+ private EmptyReference() {}+}diff --git a/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/package-info.java b/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/package-info.javanew file mode 100644index 00000000000..5b9241b8ae5--- /dev/null+++ b/lucene/core.tests/src/java/org/apache/lucene/core/tests/main/package-info.java@@ -0,0 +1,19 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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.+ */++/** Contains a placeholder class for referencing in tests. */+package org.apache.lucene.core.tests.main;diff --git a/lucene/core.tests/src/java/overview.html b/lucene/core.tests/src/java/overview.htmlnew file mode 100644index 00000000000..e71200a7af4--- /dev/null+++ b/lucene/core.tests/src/java/overview.html@@ -0,0 +1,26 @@+<!--+ Licensed to the Apache Software Foundation (ASF) under one or more+ contributor license agreements. See the NOTICE file distributed with+ this work for additional information regarding copyright ownership.+ The ASF licenses this file to You 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.+-->+<html>+<head>+ <title>Apache Lucene Core Tests</title>+</head>+ <body>++ <p>A placeholder module descriptor just so that we can check whether+ referencing it from the actual test module works.</p>+ </body>+</html>diff --git a/lucene/core.tests/src/test/module-info.java b/lucene/core.tests/src/test/module-info.javaindex 21fb2714c41..26fa5952b83 100644--- a/lucene/core.tests/src/test/module-info.java+++ b/lucene/core.tests/src/test/module-info.java@@ -19,7 +19,8 @@@SuppressWarnings({"requires-automatic"})module org.apache.lucene.core.tests {requires org.apache.lucene.core;- requires junit;+ requires org.apache.lucene.test_framework;+ requires org.apache.lucene.core.tests.main;exports org.apache.lucene.core.tests;diff --git a/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestMMap.java b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestMMap.javaindex 23248465893..fcaae01e982 100644--- a/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestMMap.java+++ b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestMMap.java@@ -17,12 +17,11 @@package org.apache.lucene.core.tests;import org.apache.lucene.store.MMapDirectory;+import org.apache.lucene.tests.util.LuceneTestCase;import org.junit.Assert;-import org.junit.Test;-public class TestMMap {- @Test- public void testUnmapSupported() throws Exception {+public class TestMMap extends LuceneTestCase {+ public void testUnmapSupported() {final Module module = MMapDirectory.class.getModule();Assert.assertTrue("Lucene Core is not loaded as module", module.isNamed());Assert.assertTrue(diff --git a/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestModuleResourceLoader.java b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestModuleResourceLoader.javaindex ac111e66f68..edbd7058243 100644--- a/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestModuleResourceLoader.java+++ b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestModuleResourceLoader.java@@ -17,13 +17,12 @@package org.apache.lucene.core.tests;import java.io.IOException;+import org.apache.lucene.tests.util.LuceneTestCase;import org.apache.lucene.util.ModuleResourceLoader;import org.apache.lucene.util.ResourceLoader;-import org.junit.Assert;import org.junit.BeforeClass;-import org.junit.Test;-public class TestModuleResourceLoader extends Assert {+public class TestModuleResourceLoader extends LuceneTestCase {private static final Module MODULE = TestModuleResourceLoader.class.getModule();private final ResourceLoader loader = new ModuleResourceLoader(MODULE);@@ -33,7 +32,6 @@ public class TestModuleResourceLoader extends Assert {assertTrue("Test class must be in a named module", MODULE.isNamed());}- @Testpublic void testModuleResources() throws Exception {try (var stream = loader.openResource("org/apache/lucene/core/testresources/accessible.txt")) {stream.available();@@ -51,8 +49,7 @@ public class TestModuleResourceLoader extends Assert {}}- @Test- public void testModuleClassloading() throws Exception {+ public void testModuleClassloading() {assertSame(TestModuleResourceLoader.class,loader.findClass(TestModuleResourceLoader.class.getName(), Object.class));diff --git a/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestRuntimeDependenciesSane.java b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestRuntimeDependenciesSane.javanew file mode 100644index 00000000000..2a07d4b8bac--- /dev/null+++ b/lucene/core.tests/src/test/org/apache/lucene/core/tests/TestRuntimeDependenciesSane.java@@ -0,0 +1,58 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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 org.apache.lucene.core.tests;++import org.apache.lucene.core.tests.main.EmptyReference;+import org.apache.lucene.index.IndexWriter;+import org.junit.Test;++/** Intentionally not a subclass of {@code LuceneTestCase}. */+public class TestRuntimeDependenciesSane {+ @Test+ public void testExternalDependenciesAreModules() {+ isModule(org.junit.Test.class);+ }++ @Test+ public void testInterProjectDependenciesAreModules() {+ // The core Lucene should be a modular dependency.+ isModule(IndexWriter.class);+ }++ @Test+ public void testTestSourceSetIsAModule() {+ // The test source set itself should be loaded as a module.+ isModule(getClass());+ }++ @Test+ public void testMainSourceSetIsAModule() {+ // The test source set itself should be loaded as a module.+ isModule(EmptyReference.class);+ }++ private static void isModule(Class<?> clazz) {+ var module = clazz.getModule();+ if (!module.isNamed()) {+ throw new AssertionError(+ "Class should be loaded from a named module: "+ + clazz.getName()+ + " but is instead part of: "+ + module);+ }+ }+}diff --git a/lucene/core/build.gradle b/lucene/core/build.gradleindex 989c57f0935..e55c0853f61 100644--- a/lucene/core/build.gradle+++ b/lucene/core/build.gradle@@ -20,6 +20,6 @@ apply plugin: 'java-library'description = 'Lucene core library'dependencies {- testImplementation project(':lucene:codecs')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:codecs')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/demo/build.gradle b/lucene/demo/build.gradleindex 70fd1df8248..a5c9469c06e 100644--- a/lucene/demo/build.gradle+++ b/lucene/demo/build.gradle@@ -27,5 +27,5 @@ dependencies {moduleImplementation project(':lucene:queryparser')moduleImplementation project(':lucene:expressions')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/expressions/build.gradle b/lucene/expressions/build.gradleindex 6823ae68782..f9fcee6aacd 100644--- a/lucene/expressions/build.gradle+++ b/lucene/expressions/build.gradle@@ -29,5 +29,5 @@ dependencies {moduleImplementation 'org.ow2.asm:asm'moduleImplementation 'org.ow2.asm:asm-commons'- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/facet/build.gradle b/lucene/facet/build.gradleindex 1b16f94d574..87b1950fcc3 100644--- a/lucene/facet/build.gradle+++ b/lucene/facet/build.gradle@@ -22,11 +22,10 @@ description = 'Faceted indexing and search capabilities'dependencies {moduleApi project(':lucene:core')-moduleImplementation 'com.carrotsearch:hppc'- testImplementation project(':lucene:test-framework')- testImplementation project(':lucene:queries')+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:queries')// Required for opening older indexes for backward compatibility tests- testImplementation project(':lucene:backward-codecs')+ moduleTestImplementation project(':lucene:backward-codecs')}diff --git a/lucene/grouping/build.gradle b/lucene/grouping/build.gradleindex 7035a11c692..5915c78cccc 100644--- a/lucene/grouping/build.gradle+++ b/lucene/grouping/build.gradle@@ -25,5 +25,5 @@ dependencies {moduleImplementation project(':lucene:queries')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/highlighter/build.gradle b/lucene/highlighter/build.gradleindex 105f1dee539..d2e7baf391f 100644--- a/lucene/highlighter/build.gradle+++ b/lucene/highlighter/build.gradle@@ -26,7 +26,7 @@ dependencies {moduleImplementation project(':lucene:queries')moduleImplementation project(':lucene:memory')- testImplementation project(':lucene:test-framework')- testImplementation project(':lucene:analysis:common')- testImplementation project(':lucene:queryparser')+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:analysis:common')+ moduleTestImplementation project(':lucene:queryparser')}diff --git a/lucene/join/build.gradle b/lucene/join/build.gradleindex d8c2eabc52d..840b3bc8f65 100644--- a/lucene/join/build.gradle+++ b/lucene/join/build.gradle@@ -21,5 +21,5 @@ description = 'Index-time and Query-time joins for normalized content'dependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}\ No newline at end of filediff --git a/lucene/luke/build.gradle b/lucene/luke/build.gradleindex 6def3e6d88b..150424003db 100644--- a/lucene/luke/build.gradle+++ b/lucene/luke/build.gradle@@ -45,7 +45,7 @@ dependencies {moduleImplementation project(':lucene:analysis:stempel')moduleImplementation project(':lucene:suggest')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}// Configure main class name for all JARs.diff --git a/lucene/memory/build.gradle b/lucene/memory/build.gradleindex eb6626e6d4d..789070f6c24 100644--- a/lucene/memory/build.gradle+++ b/lucene/memory/build.gradle@@ -23,6 +23,6 @@ description = 'Single-document in-memory index implementation'dependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')- testImplementation project(':lucene:queryparser')+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:queryparser')}\ No newline at end of filediff --git a/lucene/misc/build.gradle b/lucene/misc/build.gradleindex b9d76265d5a..1c4468a504b 100644--- a/lucene/misc/build.gradle+++ b/lucene/misc/build.gradle@@ -21,7 +21,7 @@ description = 'Index tools and other miscellaneous code'dependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')nativeDeps project(":lucene:misc:native")}\ No newline at end of filediff --git a/lucene/monitor/build.gradle b/lucene/monitor/build.gradleindex ff6677f3704..83d6759c892 100644--- a/lucene/monitor/build.gradle+++ b/lucene/monitor/build.gradle@@ -25,6 +25,6 @@ dependencies {moduleImplementation project(':lucene:memory')moduleImplementation project(':lucene:analysis:common')- testImplementation project(':lucene:queryparser')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:queryparser')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/queries/build.gradle b/lucene/queries/build.gradleindex d0cc010ad77..560365cf54e 100644--- a/lucene/queries/build.gradle+++ b/lucene/queries/build.gradle@@ -22,7 +22,7 @@ description = 'Filters and Queries that add to core Lucene'dependencies {moduleApi project(':lucene:core')- testImplementation project(':lucene:test-framework')- testImplementation project(':lucene:expressions')+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:expressions')}diff --git a/lucene/queryparser/build.gradle b/lucene/queryparser/build.gradleindex b50b565e2f7..2390cfe52ca 100644--- a/lucene/queryparser/build.gradle+++ b/lucene/queryparser/build.gradle@@ -24,5 +24,5 @@ dependencies {moduleApi project(':lucene:queries')moduleApi project(':lucene:sandbox')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/replicator/build.gradle b/lucene/replicator/build.gradleindex d3dfc07e3b3..20585023046 100644--- a/lucene/replicator/build.gradle+++ b/lucene/replicator/build.gradle@@ -30,12 +30,12 @@ dependencies {moduleImplementation 'javax.servlet:javax.servlet-api'- testImplementation 'org.eclipse.jetty:jetty-server'- testImplementation('org.eclipse.jetty:jetty-servlet', {+ moduleTestImplementation project(':lucene:test-framework')++ moduleTestImplementation 'org.eclipse.jetty:jetty-server'+ moduleTestImplementation('org.eclipse.jetty:jetty-servlet', {exclude group: "org.eclipse.jetty", module: "jetty-security"})- testImplementation 'org.eclipse.jetty:jetty-continuation'-- testImplementation project(':lucene:test-framework')+ moduleTestImplementation 'org.eclipse.jetty:jetty-continuation'}diff --git a/lucene/sandbox/build.gradle b/lucene/sandbox/build.gradleindex b7e8018ea64..93f01e3f96d 100644--- a/lucene/sandbox/build.gradle+++ b/lucene/sandbox/build.gradle@@ -22,5 +22,5 @@ description = 'Various third party contributions and new ideas'dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:queries')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/spatial-extras/build.gradle b/lucene/spatial-extras/build.gradleindex 34fa10e13e7..baa772f3053 100644--- a/lucene/spatial-extras/build.gradle+++ b/lucene/spatial-extras/build.gradle@@ -19,6 +19,10 @@ apply plugin: 'java-library'description = 'Geospatial search'+configurations {+ spatial4jTestPatch+}+dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:spatial3d')@@ -26,11 +30,17 @@ dependencies {moduleApi 'org.locationtech.spatial4j:spatial4j'moduleApi 'io.sgr:s2-geometry-library-java'- testImplementation project(':lucene:test-framework')- testImplementation testFixtures(project(':lucene:spatial3d'))-+ moduleTestImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:spatial-test-fixtures')moduleTestImplementation 'org.locationtech.jts:jts-core'- testImplementation 'org.locationtech.spatial4j:spatial4j::tests'-}+ // We add patched modules to this configuration because otherwise IDEs would not see the+ // dependency at all, even in classpath mode (they don't see --patch-module commands we+ // add to the compiler and test tasks).+ moduleTestPatchOnly 'org.locationtech.spatial4j:spatial4j::tests'+ spatial4jTestPatch 'org.locationtech.spatial4j:spatial4j::tests'+}+sourceSets.test.extensions.configure("modularPaths", {+ it.patchModule("spatial4j", project.providers.provider({ configurations.spatial4jTestPatch.singleFile }))+})\ No newline at end of filediff --git a/lucene/spatial-extras/src/test/org/apache/lucene/spatial/spatial4j/TestGeo3dRpt.java b/lucene/spatial-extras/src/test/org/apache/lucene/spatial/spatial4j/TestGeo3dRpt.javaindex 425142e82d1..0d3e8125a03 100644--- a/lucene/spatial-extras/src/test/org/apache/lucene/spatial/spatial4j/TestGeo3dRpt.java+++ b/lucene/spatial-extras/src/test/org/apache/lucene/spatial/spatial4j/TestGeo3dRpt.java@@ -16,7 +16,7 @@*/package org.apache.lucene.spatial.spatial4j;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import static org.locationtech.spatial4j.distance.DistanceUtils.DEGREES_TO_RADIANS;import java.io.IOException;diff --git a/lucene/spatial-test-fixtures/build.gradle b/lucene/spatial-test-fixtures/build.gradlenew file mode 100644index 00000000000..983416d8a87--- /dev/null+++ b/lucene/spatial-test-fixtures/build.gradle@@ -0,0 +1,25 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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.+ */++apply plugin: 'java-library'++description = '3D spatial planar geometry test fixtures'++dependencies {+ moduleImplementation project(':lucene:test-framework')+ moduleImplementation project(':lucene:spatial3d')+}diff --git a/lucene/spatial3d/src/testFixtures/java/org/apache/lucene/spatial3d/geom/RandomGeo3dShapeGenerator.java b/lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/RandomGeo3dShapeGenerator.javasimilarity index 95%rename from lucene/spatial3d/src/testFixtures/java/org/apache/lucene/spatial3d/geom/RandomGeo3dShapeGenerator.javarename to lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/RandomGeo3dShapeGenerator.javaindex da4ac89197f..d3ddb3f7855 100644--- a/lucene/spatial3d/src/testFixtures/java/org/apache/lucene/spatial3d/geom/RandomGeo3dShapeGenerator.java+++ b/lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/RandomGeo3dShapeGenerator.java@@ -15,7 +15,7 @@* limitations under the License.*/-package org.apache.lucene.spatial3d.geom;+package org.apache.lucene.spatial3d.tests;import com.carrotsearch.randomizedtesting.RandomizedContext;import com.carrotsearch.randomizedtesting.RandomizedTest;@@ -25,6 +25,23 @@ import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Random;+import org.apache.lucene.spatial3d.geom.GeoArea;+import org.apache.lucene.spatial3d.geom.GeoAreaShape;+import org.apache.lucene.spatial3d.geom.GeoBBox;+import org.apache.lucene.spatial3d.geom.GeoBBoxFactory;+import org.apache.lucene.spatial3d.geom.GeoCircle;+import org.apache.lucene.spatial3d.geom.GeoCircleFactory;+import org.apache.lucene.spatial3d.geom.GeoCompositeAreaShape;+import org.apache.lucene.spatial3d.geom.GeoCompositeMembershipShape;+import org.apache.lucene.spatial3d.geom.GeoPath;+import org.apache.lucene.spatial3d.geom.GeoPathFactory;+import org.apache.lucene.spatial3d.geom.GeoPoint;+import org.apache.lucene.spatial3d.geom.GeoPointShape;+import org.apache.lucene.spatial3d.geom.GeoPointShapeFactory;+import org.apache.lucene.spatial3d.geom.GeoPolygon;+import org.apache.lucene.spatial3d.geom.GeoPolygonFactory;+import org.apache.lucene.spatial3d.geom.GeoShape;+import org.apache.lucene.spatial3d.geom.PlanetModel;/*** Class for generating random Geo3dShapes. They can be generated under given constraints which are@@ -42,22 +59,22 @@ public final class RandomGeo3dShapeGenerator {private static final int MAX_POINT_ITERATIONS = 1000;/* Supported shapes */- protected static final int CONVEX_POLYGON = 0;- protected static final int CONVEX_POLYGON_WITH_HOLES = 1;- protected static final int CONCAVE_POLYGON = 2;- protected static final int CONCAVE_POLYGON_WITH_HOLES = 3;- protected static final int COMPLEX_POLYGON = 4;- protected static final int CIRCLE = 5;- protected static final int RECTANGLE = 6;- protected static final int PATH = 7;- protected static final int COLLECTION = 8;- protected static final int POINT = 9;- protected static final int LINE = 10;- protected static final int EXACT_CIRCLE = 11;+ public static final int CONVEX_POLYGON = 0;+ public static final int CONVEX_POLYGON_WITH_HOLES = 1;+ public static final int CONCAVE_POLYGON = 2;+ public static final int CONCAVE_POLYGON_WITH_HOLES = 3;+ public static final int COMPLEX_POLYGON = 4;+ public static final int CIRCLE = 5;+ public static final int RECTANGLE = 6;+ public static final int PATH = 7;+ public static final int COLLECTION = 8;+ public static final int POINT = 9;+ public static final int LINE = 10;+ public static final int EXACT_CIRCLE = 11;/* Helper shapes for generating constraints whch are just three sided polygons */- protected static final int CONVEX_SIMPLE_POLYGON = 500;- protected static final int CONCAVE_SIMPLE_POLYGON = 501;+ public static final int CONVEX_SIMPLE_POLYGON = 500;+ public static final int CONCAVE_SIMPLE_POLYGON = 501;/** Static methods only. */private RandomGeo3dShapeGenerator() {}@@ -550,7 +567,7 @@ public final class RandomGeo3dShapeGenerator {collection.addShape(member);}}- if (collection.shapes.size() == 0) {+ if (collection.size() == 0) {continue;}return collection;@@ -963,7 +980,7 @@ public final class RandomGeo3dShapeGenerator {* @param points The points to order.* @return The list of ordered points anti-clockwise.*/- protected static List<GeoPoint> orderPoints(List<GeoPoint> points) {+ public static List<GeoPoint> orderPoints(List<GeoPoint> points) {double x = 0;double y = 0;double z = 0;@@ -1005,8 +1022,7 @@ public final class RandomGeo3dShapeGenerator {* Class that holds the constraints that are given to build shapes. It consists in a list of* GeoAreaShapes and relationships the new shape needs to satisfy.*/- static class Constraints extends HashMap<GeoAreaShape, Integer> {-+ public static class Constraints extends HashMap<GeoAreaShape, Integer> {/*** Check if the shape is valid under the constraints.*@@ -1052,7 +1068,7 @@ public final class RandomGeo3dShapeGenerator {// For GeoCompositeMembershipShape we only consider the first shape to help// convergingif (relationship == GeoArea.WITHIN && shape instanceof GeoCompositeMembershipShape) {- shape = (((GeoCompositeMembershipShape) shape).shapes.get(0));+ shape = (((GeoCompositeMembershipShape) shape).getShapes().get(0));}switch (relationship) {case GeoArea.DISJOINT:diff --git a/lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/package-info.java b/lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/package-info.javanew file mode 100644index 00000000000..004a77b0598--- /dev/null+++ b/lucene/spatial-test-fixtures/src/java/org/apache/lucene/spatial3d/tests/package-info.java@@ -0,0 +1,19 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You 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.+ */++/** Shared test fixtures for spatial packages. */+package org.apache.lucene.spatial3d.tests;diff --git a/lucene/spatial-test-fixtures/src/java/overview.html b/lucene/spatial-test-fixtures/src/java/overview.htmlnew file mode 100644index 00000000000..08e16bcb80d--- /dev/null+++ b/lucene/spatial-test-fixtures/src/java/overview.html@@ -0,0 +1,24 @@+<!--+ Licensed to the Apache Software Foundation (ASF) under one or more+ contributor license agreements. See the NOTICE file distributed with+ this work for additional information regarding copyright ownership.+ The ASF licenses this file to You 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.+-->+<html>+ <head>+ <title>Apache Lucene Spatial Test Fixtures Module</title>+ </head>+ <body>+ <h1>Internal test fixtures for spatial modules</h1>+ </body>+</html>diff --git a/lucene/spatial3d/build.gradle b/lucene/spatial3d/build.gradleindex 219d0293dc2..0b258337cac 100644--- a/lucene/spatial3d/build.gradle+++ b/lucene/spatial3d/build.gradle@@ -16,13 +16,17 @@*/apply plugin: 'java-library'-apply plugin: 'java-test-fixtures'description = '3D spatial planar geometry APIs'dependencies {moduleApi project(':lucene:core')+ moduleTestImplementation project(':lucene:test-framework')- testFixturesApi project(':lucene:test-framework')- testImplementation project(':lucene:test-framework')+ // We have to exclude ourselves because spatial-test-fixtures depend+ // on the main source set of this project and tests would receive the+ // dependency twice - on classpath and in module path.+ moduleTestImplementation(project(':lucene:spatial-test-fixtures'), {+ exclude module: "spatial3d"+ })}diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoBaseCompositeShape.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoBaseCompositeShape.javaindex 8c877068423..876882a350e 100644--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoBaseCompositeShape.java+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoBaseCompositeShape.java@@ -22,6 +22,7 @@ import java.io.InputStream;import java.io.OutputStream;import java.util.ArrayList;import java.util.Arrays;+import java.util.Collections;import java.util.List;/**@@ -149,4 +150,9 @@ public abstract class GeoBaseCompositeShape<T extends GeoShape> extends BasePlanGeoBaseCompositeShape<?> other = (GeoBaseCompositeShape<?>) o;return super.equals(other) && shapes.equals(other.shapes);}++ /** Returns an unmodifiable list of composed shapes. */+ public List<T> getShapes() {+ return Collections.unmodifiableList(shapes);+ }}diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestGeoExactCircle.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestGeoExactCircle.javaindex c99f6020011..28036e2aeff 100644--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestGeoExactCircle.java+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestGeoExactCircle.java@@ -17,9 +17,10 @@package org.apache.lucene.spatial3d.geom;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import com.carrotsearch.randomizedtesting.annotations.Repeat;+import org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator;import org.apache.lucene.tests.util.LuceneTestCase;import org.junit.Test;diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomBinaryCodec.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomBinaryCodec.javaindex 214ef7dff49..3c0a6a895be 100644--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomBinaryCodec.java+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomBinaryCodec.java@@ -17,7 +17,7 @@package org.apache.lucene.spatial3d.geom;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import com.carrotsearch.randomizedtesting.annotations.Repeat;import java.io.ByteArrayInputStream;diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoPolygon.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoPolygon.javaindex e5a9d7d1a57..ac87144b3dd 100644--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoPolygon.java+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoPolygon.java@@ -16,7 +16,7 @@*/package org.apache.lucene.spatial3d.geom;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import com.carrotsearch.randomizedtesting.generators.BiasedNumbers;import java.util.ArrayList;diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoShapeRelationship.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoShapeRelationship.javaindex 9f3bd751738..9b63b4e4e9e 100644--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoShapeRelationship.java+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomGeoShapeRelationship.java@@ -17,7 +17,7 @@package org.apache.lucene.spatial3d.geom;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import org.apache.lucene.tests.util.LuceneTestCase;import org.junit.Test;diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomPlane.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomPlane.javaindex 2ed0066cc76..503188a102f 100644--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomPlane.java+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/TestRandomPlane.java@@ -17,7 +17,7 @@package org.apache.lucene.spatial3d.geom;-import static org.apache.lucene.spatial3d.geom.RandomGeo3dShapeGenerator.*;+import static org.apache.lucene.spatial3d.tests.RandomGeo3dShapeGenerator.*;import com.carrotsearch.randomizedtesting.annotations.Repeat;import java.util.ArrayList;diff --git a/lucene/suggest/build.gradle b/lucene/suggest/build.gradleindex 3afccd85686..25a444d0dbf 100644--- a/lucene/suggest/build.gradle+++ b/lucene/suggest/build.gradle@@ -23,5 +23,5 @@ dependencies {moduleApi project(':lucene:core')moduleApi project(':lucene:analysis:common')- testImplementation project(':lucene:test-framework')+ moduleTestImplementation project(':lucene:test-framework')}diff --git a/lucene/test-framework/src/java/module-info.java b/lucene/test-framework/src/java/module-info.javaindex 81ee06280b2..d87d56a6938 100644--- a/lucene/test-framework/src/java/module-info.java+++ b/lucene/test-framework/src/java/module-info.java@@ -16,12 +16,12 @@*//** Lucene test framework. */-@SuppressWarnings({"module", "requires-automatic"})+@SuppressWarnings({"module", "requires-automatic", "requires-transitive-automatic"})module org.apache.lucene.test_framework {requires org.apache.lucene.core;requires org.apache.lucene.codecs;- requires junit;- requires randomizedtesting.runner;+ requires transitive junit;+ requires transitive randomizedtesting.runner;exports org.apache.lucene.tests.analysis.standard;exports org.apache.lucene.tests.analysis;diff --git a/settings.gradle b/settings.gradleindex 0923e9db874..971fbb6c5bc 100644--- a/settings.gradle+++ b/settings.gradle@@ -63,5 +63,6 @@ include "lucene:replicator"include "lucene:sandbox"include "lucene:spatial3d"include "lucene:spatial-extras"+include "lucene:spatial-test-fixtures"include "lucene:suggest"include "lucene:test-framework"diff --git a/versions.lock b/versions.lockindex c596e6e0fa8..fb12bb6aee8 100644--- a/versions.lock+++ b/versions.lock@@ -23,7 +23,7 @@ org.ow2.asm:asm-analysis:7.2 (1 constraints: e409d9a5)org.ow2.asm:asm-commons:7.2 (1 constraints: ad042e2c)org.ow2.asm:asm-tree:7.2 (2 constraints: 2f14468c)ua.net.nlp:morfologik-ukrainian-search:4.9.1 (1 constraints: 10051b36)-xerces:xercesImpl:2.12.0 (2 constraints: 1f14b675)+xerces:xercesImpl:2.12.0 (1 constraints: 3705353b)[Test dependencies]org.assertj:assertj-core:3.21.0 (1 constraints: 38053c3b)