Review AI code

Author: vjovanov

AGENTS.md

@@ -22,30 +22,22 @@
 - In java, always import classes and use them without qualified names.
 
 ## Testing individual components
-```console
-# Clean previous build outputs for the selected coordinates
-./gradlew clean -Pcoordinates=[group:artifact:version|k/n|all]
-# Pre-fetch Docker images allowed by metadata (used in tests) for the selected coordinates
-./gradlew pullAllowedDockerImages -Pcoordinates=[group:artifact:version|k/n|all]
-# Validate reachability metadata files for the selected coordinates
-./gradlew checkMetadataFiles -Pcoordinates=[group:artifact:version|k/n|all]
-# Run Checkstyle for the selected coordinates
-./gradlew checkstyle -Pcoordinates=[group:artifact:version|k/n|all]
-# Compile test sources for the selected coordinates
-./gradlew compileTestJava -Pcoordinates=[group:artifact:version|k/n|all]
-# Run JVM-based tests for the selected coordinates
-./gradlew javaTest -Pcoordinates=[group:artifact:version|k/n|all]
-# Build native images used by native tests (compile-only) for the selected coordinates
-./gradlew nativeTestCompile -Pcoordinates=[group:artifact:version|k/n|all]
-# Run all tests for the selected coordinates
-./gradlew test -Pcoordinates=[group:artifact:version|k/n|all]
-```
 
-### Check style and formatting
+- Clean previous build outputs for the selected coordinates: ./gradlew clean -Pcoordinates=[group:artifact:version|k/n|all]
+- Pre-fetch Docker images allowed by metadata (used in tests) for the selected coordinates: ./gradlew pullAllowedDockerImages -Pcoordinates=[group:artifact:version|k/n|all]
+- Validate reachability metadata files for the selected coordinates: ./gradlew checkMetadataFiles -Pcoordinates=[group:artifact:version|k/n|all]
+- Run Checkstyle for the selected coordinates: ./gradlew checkstyle -Pcoordinates=[group:artifact:version|k/n|all]
+- Compile test sources for the selected coordinates: ./gradlew compileTestJava -Pcoordinates=[group:artifact:version|k/n|all]
+- Run JVM-based tests for the selected coordinates: ./gradlew javaTest -Pcoordinates=[group:artifact:version|k/n|all]
+- Build native images used by native tests (compile-only) for the selected coordinates: ./gradlew nativeTestCompile -Pcoordinates=[group:artifact:version|k/n|all]
+- Run all tests for the selected coordinates: ./gradlew test -Pcoordinates=[group:artifact:version|k/n|all]
+
+
+## Check style and formatting
 - Style check: ./gradlew checkstyle
 - Format check: ./gradlew spotlessCheck
 
-### Testing the metadata
+## Testing the metadata
 - Single library (replace with group:artifact:version):
   - ./gradlew pullAllowedDockerImages -Pcoordinates=group:artifact:version
   - ./gradlew checkMetadataFiles -Pcoordinates=group:artifact:version
@@ -55,18 +47,18 @@
   - ./gradlew checkMetadataFiles -Pcoordinates=1/64
   - ./gradlew test -Pcoordinates=1/64
 
-### Docker Image Vulnerability Scanning
+## Docker Image Vulnerability Scanning
 - Changed images between commits:
   - ./gradlew checkAllowedDockerImages --baseCommit=$(git rev-parse origin/master) --newCommit=$(git rev-parse HEAD)
 - All allowed images:
   - ./gradlew checkAllowedDockerImages
 
-### Compatibility Automation (latest library versions)
+##s Compatibility Automation (latest library versions)
 - List libs with newer upstream versions:
   - ./gradlew fetchExistingLibrariesWithNewerVersions --quiet
 - Record a newly tested version:
   - ./gradlew addTestedVersion -Pcoordinates="group:artifact:newVersion" --lastSupportedVersion="oldVersion"
   - Example: ./gradlew addTestedVersion -Pcoordinates="org.postgresql:postgresql:42.7.4" --lastSupportedVersion="42.7.3"
 
-# Releases and Packaging
+## Releases and Packaging
 - Package artifacts: ./gradlew package

build.gradle

@@ -87,18 +87,28 @@ ext.runLoggedCommand = { List<String> args, String label, File logFile, File wor
     return exit
 }
 
+static List<Map> testAllCommands(String gradleCmd, String target) {
+    def taskNames = [
+            "checkstyle",
+            "spotlessCheck",
+            "checkMetadataFiles",
+            "fetchExistingLibrariesWithNewerVersions",
+            "test"
+    ]
+    return taskNames.collect { name ->
+        [name: name, args: [gradleCmd, name, "-Pcoordinates=${target}"]]
+    }
+}
+
 tasks.register('testAllParallel') { t ->
     t.group = "verification"
-    t.setDescription("For each target, run clean and pullAllowedDockerImages first (sequentially), then run style checks and individual testing stages (checkstyle, spotlessCheck, checkMetadataFiles, compileTestJava, javaTest, nativeTestCompile, test) concurrently with isolated logs. Options: -Pcoordinates to specify a single coordinate or 1/64 for the pull step; -Pparallelism to control the number of concurrent tasks.")
+    t.setDescription("For each target, run clean and pullAllowedDockerImages first (sequentially), then run style checks and individual testing stages (checkstyle, spotlessCheck, checkMetadataFiles, fetchExistingLibrariesWithNewerVersions, test) concurrently with isolated logs. Options: -Pcoordinates to specify a single coordinate or 1/64 for the pull step; -Pparallelism to control the number of concurrent tasks.")
 
     doLast {
         def selectedArtifact = "org.postgresql:postgresql:42.7.3"
-        def selectedCoord = "1/64"
+        def selectedBatch = "1/64"
 
-        def logsDir = layout.buildDirectory.dir("command-logs").get().asFile
-        logsDir.mkdirs()
         def gradleCmd = System.getProperty("os.name").toLowerCase().contains("windows") ? "gradlew.bat" : "./gradlew"
-        // Determine parallelism: default is 4 if -Pparallelism=n is not provided
         def parallelismProp = (project.findProperty('parallelism') ?: '').toString().trim()
         int parallelism = 4
         if (!parallelismProp.isEmpty()) {
@@ -113,45 +123,42 @@ tasks.register('testAllParallel') { t ->
         }
         println("Using parallelism=${parallelism} for testAllParallel.")
 
+        def logsDir = layout.buildDirectory.dir("command-logs").get().asFile
+        logsDir.mkdirs()
+
         // Helper to run pull + command set for a given target (artifact or coordinates)
-        def runPhaseForTarget = { String target ->
-            // Clean project before pulling Docker images for this target
+        def runPhaseForCoordinate = { String coordinate ->
+            // Clean project before pulling Docker images for this coordinate
             def cleanLogsDir = new File(project.rootDir, "command-logs-clean")
             cleanLogsDir.mkdirs()
-            def cleanLogFile = new File(cleanLogsDir, "clean-${target.replaceAll(File.separator, "-")}.log")
-            int cleanExit = project.ext.runLoggedCommand([gradleCmd, "clean", "-Pcoordinates=${target}"], "clean (${target})", cleanLogFile, project.rootDir)
+
+            def fileSuffix = coordinate.replaceAll(File.separator, "-")
+            def cleanLogFile = new File(cleanLogsDir, "clean-${fileSuffix}.log")
+            int cleanExit = project.ext.runLoggedCommand([gradleCmd, "clean", "-Pcoordinates=${coordinate}"], "clean (${coordinate})", cleanLogFile, project.rootDir)
             if (cleanExit != 0) {
                 throw new GradleException("clean failed with exit code ${cleanExit} (see ${cleanLogFile})")
             }
             // Ensure logsDir exists after clean
             logsDir.mkdirs()
 
-            // Pull Docker images sequentially for this target
-            def pullArgs = [gradleCmd, "pullAllowedDockerImages", "-Pcoordinates=${target}"]
-            def pullLogFile = new File(logsDir, "pullAllowedDockerImages-${target}.log")
-            int pullExit = project.ext.runLoggedCommand(pullArgs, "pullAllowedDockerImages (${target})", pullLogFile, project.rootDir)
+            // Pull Docker images sequentially for this coordinate
+            def pullArgs = [gradleCmd, "pullAllowedDockerImages", "-Pcoordinates=${coordinate}"]
+            def pullLogFile = new File(logsDir, "pullAllowedDockerImages-${fileSuffix}.log")
+            int pullExit = project.ext.runLoggedCommand(pullArgs, "pullAllowedDockerImages (${coordinate})", pullLogFile, project.rootDir)
             if (pullExit != 0) {
                 throw new GradleException("pullAllowedDockerImages failed with exit code ${pullExit} (see ${pullLogFile})")
             }
 
-            // Commands to run in parallel (style checks and individual testing stages) for this target
-            def commands = [
-                    [name: "checkstyle", args: [gradleCmd, "checkstyle", "-Pcoordinates=${target}"]],
-                    [name: "spotlessCheck", args: [gradleCmd, "spotlessCheck", "-Pcoordinates=${target}"]],
-                    [name: "checkMetadataFiles", args: [gradleCmd, "checkMetadataFiles", "-Pcoordinates=${target}"]],
-                    [name: "fetchExistingLibrariesWithNewerVersions", args: [gradleCmd, "fetchExistingLibrariesWithNewerVersions", "-Pcoordinates=${target}"]],
-                    [name: "test", args: [gradleCmd, "test", "-Pcoordinates=${target}"]]
-            ]
-
+            def commands = testAllCommands(gradleCmd, coordinate)
             int effectiveParallelism = Math.min(parallelism, commands.size())
             def pool = Executors.newFixedThreadPool(effectiveParallelism)
             def failures = Collections.synchronizedList(new ArrayList<Map>())
             def futures = []
 
             commands.each { cmd ->
                 futures << pool.submit {
-                    def label = "${cmd.name} (${target})"
-                    def logFile = new File(logsDir, "${cmd.name}-${target}.log")
+                    def label = "${cmd.name} (${coordinate})"
+                    def logFile = new File(logsDir, "${cmd.name}-${fileSuffix}.log")
                     int exit = project.ext.runLoggedCommand(cmd.args, label, logFile, project.rootDir)
                     if (exit != 0) {
                         failures.add([label: label, logFile: logFile, exit: exit])
@@ -164,11 +171,11 @@ tasks.register('testAllParallel') { t ->
             pool.awaitTermination(1, TimeUnit.HOURS)
 
             if (!failures.isEmpty()) {
-                println("Some commands failed (coordinates=${target}). Logs in: ${logsDir}")
+                println("Some commands failed (coordinates=${coordinate}). Logs in: ${logsDir}")
                 failures.each { f ->
                     println(" - ${f.label} failed with exit code ${f.exit} (see ${f.logFile})")
                 }
-                println("==== BEGIN FAILED TASK LOGS (${target})")
+                println("==== BEGIN FAILED TASK LOGS (${coordinate})")
                 failures.each { f ->
                     println("---- LOG: ${f.logFile}")
                     try {
@@ -181,15 +188,15 @@ tasks.register('testAllParallel') { t ->
                         println("Error reading ${f.logFile}: ${e.message}")
                     }
                 }
-                println("==== END FAILED TASK LOGS (${target})")
+                println("==== END FAILED TASK LOGS (${coordinate})")
                 throw new GradleException("Failures encountered. See logs above. Logs directory: ${logsDir}")
             } else {
-                println("All commands succeeded for coordinates=${target}. Logs in: ${logsDir}")
+                println("All commands succeeded for coordinates=${coordinate}. Logs in: ${logsDir}")
             }
         }
 
-        // Run phases sequentially: first the selectedArtifact, then the selectedCoord
-        runPhaseForTarget(selectedArtifact)
-        runPhaseForTarget(selectedCoord)
+        // Run parallel phases sequentially: first the selectedArtifact, then the selectedBatch
+        runPhaseForCoordinate(selectedArtifact)
+        runPhaseForCoordinate(selectedBatch)
     }
 }

docs/CI.md

@@ -3,8 +3,8 @@
 This repository uses GitHub Actions and Gradle-based checks to ensure metadata quality, stability, and automated releases.
 Below is an overview of the CI pipelines and the configuration they rely on.
 
-- Source of truth for style checks: [gradle/checkstyle.xml](../gradle/checkstyle.xml)
 - GitHub Actions workflows: [.github/workflows](../.github/workflows)/*.yml
+- Source of truth for style checks: [gradle/checkstyle.xml](../gradle/checkstyle.xml)
 
 CI prefetches docker images and temporarily disables Docker networking for test isolation via [`.github/workflows/disable-docker.sh`](../.github/workflows/scripts/disable-docker.sh). 
 You usually do not need this locally.

docs/DEVELOPING.md

@@ -53,7 +53,7 @@ For a single coordinate, CI runs three steps in this order:
 3. Then run tests:
     ```console
    ./gradlew test -Pcoordinates=org.postgresql:postgresql:42.7.3
-    ```
+   ```
 
 ### Testing libraries in bulk
 
@@ -105,18 +105,18 @@ Each stage of the testing can be run with `-Pcoordinates=[group:artifact:version
 These tasks support the scheduled workflow that checks newer upstream library versions and updates our metadata accordingly.
 
 1. List supported libraries that have newer upstream versions
-     ```console
-     ./gradlew fetchExistingLibrariesWithNewerVersions --quiet
+    ```console
+    ./gradlew fetchExistingLibrariesWithNewerVersions --quiet
     ```
 
 2. Mark a new tested version for a library
     ```console
     ./gradlew addTestedVersion -Pcoordinates="group:artifact:newVersion" --lastSupportedVersion="oldVersion"
     ```
-   For example:
-   ```console
-   ./gradlew addTestedVersion -Pcoordinates="org.postgresql:postgresql:42.7.4" --lastSupportedVersion="42.7.3"
-   ```
+    For example:
+    ```console
+    ./gradlew addTestedVersion -Pcoordinates="org.postgresql:postgresql:42.7.4" --lastSupportedVersion="42.7.3"
+    ```
 
 ### Releases and Packaging
 

tests/tck-build-logic/src/main/groovy/org.graalvm.internal.tck-harness.gradle

@@ -27,7 +27,7 @@ import org.graalvm.internal.tck.harness.tasks.NativeTestCompileInvocationTask
 import org.graalvm.internal.tck.harness.tasks.FetchExistingLibrariesWithNewerVersionsTask
 import org.gradle.util.internal.VersionNumber
 import org.graalvm.internal.tck.harness.tasks.ComputeAndPullAllowedDockerImagesTask
-import org.graalvm.internal.tck.utils.CoordinateUtils;
+import org.graalvm.internal.tck.utils.CoordinateUtils
 
 
 import static org.graalvm.internal.tck.Utils.generateTaskName
@@ -304,12 +304,9 @@ tasks.register("checkAllowedDockerImages", GrypeTask.class) { task ->
     task.setGroup(METADATA_GROUP)
 }
 
-def imagesFileProvider = project.layout.buildDirectory.file("tck/required-docker-images.txt")
-
 tasks.register("pullAllowedDockerImages", ComputeAndPullAllowedDockerImagesTask.class) { task ->
     task.setDescription("Computes and pulls allowed docker images required by matching coordinates")
     task.setGroup(METADATA_GROUP)
-    task.getImagesFile().set(imagesFileProvider)
 }
 
 

tests/tck-build-logic/src/main/groovy/org/graalvm/internal/tck/harness/tasks/CleanInvocationTask.groovy

@@ -1,3 +1,10 @@
+/*
+ * Copyright and related rights waived via CC0
+ *
+ * You should have received a copy of the CC0 legalcode along with this
+ * work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
 package org.graalvm.internal.tck.harness.tasks
 
 import org.gradle.api.tasks.Input