From eab5317b1a2cd4d666dfd45f445a4b35fd857130 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 10:34:49 +0000 Subject: [PATCH 01/26] addtional gradle versions --- docs/testing-guide.md | 17 ++++ .../junit/AdditionalGradleVersions.java | 39 ++++++++ .../junit/GradleVersioningClassTemplate.java | 18 +++- .../ete/AdditionalGradleVersionsTest.java | 95 +++++++++++++++++++ .../AdditionalGradleVersionsFixtureTest.java | 40 ++++++++ 5 files changed, 207 insertions(+), 2 deletions(-) create mode 100644 gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java create mode 100644 gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java create mode 100644 gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java diff --git a/docs/testing-guide.md b/docs/testing-guide.md index c9d991e1..414b9989 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -145,6 +145,23 @@ If not specified, tests run against the default version (currently `8.14.3`). See [Resolution of Gradle versions to test against](../README.md#resolution-of-gradle-versions-to-test-against) for more details. +#### Adding Versions for Specific Tests + +Use `@AdditionalGradleVersions` to add extra Gradle versions for a specific test class: + +```java +@GradlePluginTests +@AdditionalGradleVersions({"7.6.5", "8.0"}) +class CompatibilityTest { + @Test + void works_on_older_gradle_versions(GradleInvoker gradle, RootProject project) { + // This test runs against the globally configured versions PLUS 7.6.5 and 8.0 + } +} +``` + +The versions from `@AdditionalGradleVersions` are merged with the globally configured versions. Duplicate versions are automatically deduplicated. + ## File Operations ### Working with Files diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java new file mode 100644 index 00000000..bdfe28c5 --- /dev/null +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java @@ -0,0 +1,39 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.junit; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Annotation that can be used alongside {@link GradlePluginTests} to add additional Gradle versions to test against. + * The versions specified in this annotation will be merged with the versions configured via the + * {@code com.palantir.gradle.testing.gradle_versions_to_test} configuration parameter. + * This annotation can be applied to a test class. + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface AdditionalGradleVersions { + + /** + * The additional Gradle versions to test against. + * @return an array of Gradle version strings (e.g., "7.6.5", "8.0") + */ + String[] value(); +} diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 451133de..bb6e0c55 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -18,12 +18,17 @@ import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; +import java.util.Arrays; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Optional; +import java.util.Set; import java.util.stream.Stream; import org.junit.jupiter.api.extension.ClassTemplateInvocationContext; import org.junit.jupiter.api.extension.ClassTemplateInvocationContextProvider; import org.junit.jupiter.api.extension.Extension; import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; final class GradleVersioningClassTemplate implements ClassTemplateInvocationContextProvider { @Override @@ -39,9 +44,18 @@ public Stream provideClassTemplateInvo .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?")); - List gradleVersions = Splitter.on(',').splitToList(gradleVersionsToTestAgainst); + List configuredVersions = Splitter.on(',').splitToList(gradleVersionsToTestAgainst); - return gradleVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); + Set allVersions = new LinkedHashSet<>(configuredVersions); + findAdditionalVersions(context).ifPresent(additional -> allVersions.addAll(Arrays.asList(additional))); + + return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); + } + + private static Optional findAdditionalVersions(ExtensionContext context) { + return context.getTestClass() + .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, AdditionalGradleVersions.class)) + .map(AdditionalGradleVersions::value); } private record GradleVersionInvocationContext(GradleVersion gradleVersion) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java new file mode 100644 index 00000000..cf14a17d --- /dev/null +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java @@ -0,0 +1,95 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.ete; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.palantir.example.AdditionalGradleVersionsFixtureTest; +import java.nio.file.Path; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.junit.platform.engine.TestExecutionResult; +import org.junit.platform.engine.TestExecutionResult.Status; +import org.junit.platform.engine.discovery.DiscoverySelectors; +import org.junit.platform.testkit.engine.EngineExecutionResults; +import org.junit.platform.testkit.engine.EngineTestKit; +import org.junit.platform.testkit.engine.Event; + +final class AdditionalGradleVersionsTest { + @Test + void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(AdditionalGradleVersionsFixtureTest.class)) + // Base version configured via parameter + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + + // Should have 3 test runs: 7.6.5 from config + 8.0 and 8.5 from @AdditionalGradleVersions + assertThat(finished).hasSize(3); + + assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); + assertThatRanWithCorrectGradleVersion(finished.get(1), "8.0"); + assertThatRanWithCorrectGradleVersion(finished.get(2), "8.5"); + } + + @Test + void duplicate_versions_are_deduplicated() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(AdditionalGradleVersionsFixtureTest.class)) + // 8.0 is both in config and in @AdditionalGradleVersions + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "8.0") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + + // Should have 2 test runs: 8.0 (deduplicated) and 8.5 from @AdditionalGradleVersions + assertThat(finished).hasSize(2); + + assertThatRanWithCorrectGradleVersion(finished.get(0), "8.0"); + assertThatRanWithCorrectGradleVersion(finished.get(1), "8.5"); + } + + private static void assertThatRanWithCorrectGradleVersion(Event event, String gradleVersion) { + assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); + + assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { + assertThat(testExecutionResult.getStatus()).isEqualTo(Status.FAILED); + + Assertions.assertThatTestFailureExceptionMessageContains( + testExecutionResult, "GradleVersion: " + gradleVersion); + }); + + assertThat(Path.of( + "build/gradle-plugin-testing", + AdditionalGradleVersionsFixtureTest.class.getSimpleName(), + "test name", + gradleVersion, + "build.gradle")) + .exists(); + } + + private static void assertThatTestContainerDescriptorHasDisplayName( + Event event, String containerDescriptorDisplayName) { + assertThat(event.getTestDescriptor().getParent()).hasValueSatisfying(desc -> { + assertThat(desc.getDisplayName()).isEqualTo(containerDescriptorDisplayName); + }); + } +} diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java new file mode 100644 index 00000000..ef74756f --- /dev/null +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java @@ -0,0 +1,40 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.example; + +import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.AdditionalGradleVersions; +import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.project.RootProject; +import org.junit.jupiter.api.Test; + +// This is a test fixture, not a real test. See AdditionalGradleVersionsTest which uses it. +@GradlePluginTests +@AdditionalGradleVersions({"8.0", "8.5"}) +public class AdditionalGradleVersionsFixtureTest { + @Test + void test_name(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + // This exception is just so we can pass the output back up to the JUnit testkit-based test that + // is running this fixture. + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } +} From 92c670b72d3be9da453a0a863ce4cde82cd9ad1b Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 10:37:59 +0000 Subject: [PATCH 02/26] tidy --- .../palantir/gradle/testing/junit/AdditionalGradleVersions.java | 2 +- .../palantir/example/AdditionalGradleVersionsFixtureTest.java | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java index bdfe28c5..a488018a 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java @@ -22,7 +22,7 @@ import java.lang.annotation.Target; /** - * Annotation that can be used alongside {@link GradlePluginTests} to add additional Gradle versions to test against. + * Annotation that can be used to add additional Gradle versions to test against. * The versions specified in this annotation will be merged with the versions configured via the * {@code com.palantir.gradle.testing.gradle_versions_to_test} configuration parameter. * This annotation can be applied to a test class. diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java index ef74756f..24c4326a 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java @@ -22,7 +22,6 @@ import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; -// This is a test fixture, not a real test. See AdditionalGradleVersionsTest which uses it. @GradlePluginTests @AdditionalGradleVersions({"8.0", "8.5"}) public class AdditionalGradleVersionsFixtureTest { From 2f996ed933196a7ce23fe487f6b5badc9034b921 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 11:17:00 +0000 Subject: [PATCH 03/26] move to helper --- .../ete/AdditionalGradleVersionsTest.java | 39 +++---------------- .../gradle/testing/ete/Assertions.java | 30 ++++++++++++++ .../GradleVersionsFromJunitParameterTest.java | 33 +--------------- 3 files changed, 37 insertions(+), 65 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java index cf14a17d..2766f72c 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java @@ -19,11 +19,8 @@ import static org.assertj.core.api.Assertions.assertThat; import com.palantir.example.AdditionalGradleVersionsFixtureTest; -import java.nio.file.Path; import java.util.List; import org.junit.jupiter.api.Test; -import org.junit.platform.engine.TestExecutionResult; -import org.junit.platform.engine.TestExecutionResult.Status; import org.junit.platform.engine.discovery.DiscoverySelectors; import org.junit.platform.testkit.engine.EngineExecutionResults; import org.junit.platform.testkit.engine.EngineTestKit; @@ -44,9 +41,9 @@ void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { // Should have 3 test runs: 7.6.5 from config + 8.0 and 8.5 from @AdditionalGradleVersions assertThat(finished).hasSize(3); - assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); - assertThatRanWithCorrectGradleVersion(finished.get(1), "8.0"); - assertThatRanWithCorrectGradleVersion(finished.get(2), "8.5"); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.0"); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(2), "8.5"); } @Test @@ -63,33 +60,7 @@ void duplicate_versions_are_deduplicated() { // Should have 2 test runs: 8.0 (deduplicated) and 8.5 from @AdditionalGradleVersions assertThat(finished).hasSize(2); - assertThatRanWithCorrectGradleVersion(finished.get(0), "8.0"); - assertThatRanWithCorrectGradleVersion(finished.get(1), "8.5"); - } - - private static void assertThatRanWithCorrectGradleVersion(Event event, String gradleVersion) { - assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); - - assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { - assertThat(testExecutionResult.getStatus()).isEqualTo(Status.FAILED); - - Assertions.assertThatTestFailureExceptionMessageContains( - testExecutionResult, "GradleVersion: " + gradleVersion); - }); - - assertThat(Path.of( - "build/gradle-plugin-testing", - AdditionalGradleVersionsFixtureTest.class.getSimpleName(), - "test name", - gradleVersion, - "build.gradle")) - .exists(); - } - - private static void assertThatTestContainerDescriptorHasDisplayName( - Event event, String containerDescriptorDisplayName) { - assertThat(event.getTestDescriptor().getParent()).hasValueSatisfying(desc -> { - assertThat(desc.getDisplayName()).isEqualTo(containerDescriptorDisplayName); - }); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "8.0"); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.5"); } } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index 0b2fe958..c7c5b760 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -18,7 +18,11 @@ import static org.assertj.core.api.Assertions.assertThat; +import com.palantir.example.AdditionalGradleVersionsFixtureTest; +import java.nio.file.Path; import org.junit.platform.engine.TestExecutionResult; +import org.junit.platform.engine.TestExecutionResult.Status; +import org.junit.platform.testkit.engine.Event; public final class Assertions { @@ -29,5 +33,31 @@ public static void assertThatTestFailureExceptionMessageContains( }); } + public static void assertThatRanWithCorrectGradleVersion(Event event, String gradleVersion) { + assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); + + assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { + assertThat(testExecutionResult.getStatus()).isEqualTo(Status.FAILED); + + Assertions.assertThatTestFailureExceptionMessageContains( + testExecutionResult, "GradleVersion: " + gradleVersion); + }); + + assertThat(Path.of( + "build/gradle-plugin-testing", + AdditionalGradleVersionsFixtureTest.class.getSimpleName(), + "test name", + gradleVersion, + "build.gradle")) + .exists(); + } + + private static void assertThatTestContainerDescriptorHasDisplayName( + Event event, String containerDescriptorDisplayName) { + assertThat(event.getTestDescriptor().getParent()).hasValueSatisfying(desc -> { + assertThat(desc.getDisplayName()).isEqualTo(containerDescriptorDisplayName); + }); + } + private Assertions() {} } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java index 42d0b5c9..92b7bb62 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java @@ -19,11 +19,8 @@ import static org.assertj.core.api.Assertions.assertThat; import com.palantir.example.GradleVersionsFromJunitParameterFixtureTest; -import java.nio.file.Path; import java.util.List; import org.junit.jupiter.api.Test; -import org.junit.platform.engine.TestExecutionResult; -import org.junit.platform.engine.TestExecutionResult.Status; import org.junit.platform.engine.discovery.DiscoverySelectors; import org.junit.platform.testkit.engine.EngineExecutionResults; import org.junit.platform.testkit.engine.EngineTestKit; @@ -42,33 +39,7 @@ void runs_tests_with_gradle_versions_from_junit_parameter() { assertThat(finished).hasSize(2); - assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); - assertThatRanWithCorrectGradleVersion(finished.get(1), "8.14.3"); - } - - private static void assertThatRanWithCorrectGradleVersion(Event event, String gradleVersion) { - assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); - - assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { - assertThat(testExecutionResult.getStatus()).isEqualTo(Status.FAILED); - - Assertions.assertThatTestFailureExceptionMessageContains( - testExecutionResult, "GradleVersion: " + gradleVersion); - }); - - assertThat(Path.of( - "build/gradle-plugin-testing", - GradleVersionsFromJunitParameterFixtureTest.class.getSimpleName(), - "test name", - gradleVersion, - "build.gradle")) - .exists(); - } - - private static void assertThatTestContainerDescriptorHasDisplayName( - Event event, String containerDescriptorDisplayName) { - assertThat(event.getTestDescriptor().getParent()).hasValueSatisfying(desc -> { - assertThat(desc.getDisplayName()).isEqualTo(containerDescriptorDisplayName); - }); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); + Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.14.3"); } } From 5fcaf9d1f94824faf27243ba56f4f965680899ad Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 11:43:49 +0000 Subject: [PATCH 04/26] fix --- .../testing/ete/AdditionalGradleVersionsTest.java | 15 ++++++++++----- .../palantir/gradle/testing/ete/Assertions.java | 5 ++--- .../ete/GradleVersionsFromJunitParameterTest.java | 6 ++++-- 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java index 2766f72c..22ce9568 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java @@ -41,9 +41,12 @@ void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { // Should have 3 test runs: 7.6.5 from config + 8.0 and 8.5 from @AdditionalGradleVersions assertThat(finished).hasSize(3); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.0"); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(2), "8.5"); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, finished.get(0), "7.6.5"); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, finished.get(1), "8.0"); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, finished.get(2), "8.5"); } @Test @@ -60,7 +63,9 @@ void duplicate_versions_are_deduplicated() { // Should have 2 test runs: 8.0 (deduplicated) and 8.5 from @AdditionalGradleVersions assertThat(finished).hasSize(2); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "8.0"); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.5"); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, finished.get(0), "8.0"); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, finished.get(1), "8.5"); } } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index c7c5b760..cfcf92a8 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -18,7 +18,6 @@ import static org.assertj.core.api.Assertions.assertThat; -import com.palantir.example.AdditionalGradleVersionsFixtureTest; import java.nio.file.Path; import org.junit.platform.engine.TestExecutionResult; import org.junit.platform.engine.TestExecutionResult.Status; @@ -33,7 +32,7 @@ public static void assertThatTestFailureExceptionMessageContains( }); } - public static void assertThatRanWithCorrectGradleVersion(Event event, String gradleVersion) { + public static void assertThatRanWithCorrectGradleVersion(Class testClass, Event event, String gradleVersion) { assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { @@ -45,7 +44,7 @@ public static void assertThatRanWithCorrectGradleVersion(Event event, String gra assertThat(Path.of( "build/gradle-plugin-testing", - AdditionalGradleVersionsFixtureTest.class.getSimpleName(), + testClass.getSimpleName(), "test name", gradleVersion, "build.gradle")) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java index 92b7bb62..9234e7b6 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/GradleVersionsFromJunitParameterTest.java @@ -39,7 +39,9 @@ void runs_tests_with_gradle_versions_from_junit_parameter() { assertThat(finished).hasSize(2); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(0), "7.6.5"); - Assertions.assertThatRanWithCorrectGradleVersion(finished.get(1), "8.14.3"); + Assertions.assertThatRanWithCorrectGradleVersion( + GradleVersionsFromJunitParameterFixtureTest.class, finished.get(0), "7.6.5"); + Assertions.assertThatRanWithCorrectGradleVersion( + GradleVersionsFromJunitParameterFixtureTest.class, finished.get(1), "8.14.3"); } } From cff2347f57225c9ad3716e2df535c693a631a004 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 14:10:46 +0000 Subject: [PATCH 05/26] allow method level --- .../junit/AdditionalGradleVersions.java | 6 +- .../AdditionalGradleVersionsCondition.java | 84 +++++++++++++++++++ .../junit/GradleVersioningClassTemplate.java | 26 ++++-- .../ete/AdditionalGradleVersionsTest.java | 30 +++++++ ...elAdditionalGradleVersionsFixtureTest.java | 53 ++++++++++++ 5 files changed, 192 insertions(+), 7 deletions(-) create mode 100644 gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java create mode 100644 gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java index a488018a..278cc47f 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java @@ -25,9 +25,11 @@ * Annotation that can be used to add additional Gradle versions to test against. * The versions specified in this annotation will be merged with the versions configured via the * {@code com.palantir.gradle.testing.gradle_versions_to_test} configuration parameter. - * This annotation can be applied to a test class. + * This annotation can be applied to a test class or individual test methods. + * + *

When applied to both a class and a method, the versions are combined (base + class + method versions). */ -@Target(ElementType.TYPE) +@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface AdditionalGradleVersions { diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java new file mode 100644 index 00000000..21bb4e66 --- /dev/null +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java @@ -0,0 +1,84 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.junit; + +import com.google.common.base.Splitter; +import com.palantir.gradle.testing.execution.GradleVersion; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; +import org.junit.jupiter.api.extension.ConditionEvaluationResult; +import org.junit.jupiter.api.extension.ExecutionCondition; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; + +/** + * Execution condition that filters tests based on Gradle version. + * + *

When a method has its own {@link AdditionalGradleVersions} annotation, this condition ensures + * that only the method-specific versions (plus base and class-level versions) run for that method. + * For methods without the annotation, only base and class-level versions run. + */ +final class AdditionalGradleVersionsCondition implements ExecutionCondition { + + @Override + public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { + // Only evaluate for test methods + if (context.getTestMethod().isEmpty()) { + return ConditionEvaluationResult.enabled("No test method"); + } + + GradleVersion currentVersion = GradleVersionStore.gradleVersion(context); + + Set versionsForThisMethod = getVersionsForMethod(context); + String currentVersionString = currentVersion.toString(); + + if (versionsForThisMethod.contains(currentVersionString)) { + return ConditionEvaluationResult.enabled( + "Gradle version " + currentVersionString + " is in the allowed set for this method"); + } + + return ConditionEvaluationResult.disabled("Gradle version " + currentVersionString + + " is not in the allowed set for this method: " + versionsForThisMethod); + } + + private Set getVersionsForMethod(ExtensionContext context) { + Set versions = new LinkedHashSet<>(); + + // Add base versions from configuration + context.getConfigurationParameter("com.palantir.gradle.testing.gradle_versions_to_test") + .ifPresent(param -> { + List configuredVersions = Splitter.on(',').splitToList(param); + versions.addAll(configuredVersions); + }); + + // Add class-level additional versions + context.getTestClass() + .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, AdditionalGradleVersions.class)) + .map(AdditionalGradleVersions::value) + .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); + + // Add method-level additional versions (only for this method) + context.getTestMethod() + .flatMap(method -> AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class)) + .map(AdditionalGradleVersions::value) + .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); + + return versions; + } +} diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index bb6e0c55..ee1e2169 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -18,10 +18,10 @@ import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; +import java.lang.reflect.Method; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; -import java.util.Optional; import java.util.Set; import java.util.stream.Stream; import org.junit.jupiter.api.extension.ClassTemplateInvocationContext; @@ -47,15 +47,30 @@ public Stream provideClassTemplateInvo List configuredVersions = Splitter.on(',').splitToList(gradleVersionsToTestAgainst); Set allVersions = new LinkedHashSet<>(configuredVersions); - findAdditionalVersions(context).ifPresent(additional -> allVersions.addAll(Arrays.asList(additional))); + allVersions.addAll(findAdditionalVersions(context)); return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); } - private static Optional findAdditionalVersions(ExtensionContext context) { - return context.getTestClass() + private static Set findAdditionalVersions(ExtensionContext context) { + Set additionalVersions = new LinkedHashSet<>(); + + // Find class-level annotation + context.getTestClass() .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, AdditionalGradleVersions.class)) - .map(AdditionalGradleVersions::value); + .map(AdditionalGradleVersions::value) + .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); + + // Find method-level annotations from all test methods + context.getTestClass().ifPresent(testClass -> { + for (Method method : testClass.getDeclaredMethods()) { + AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class) + .map(AdditionalGradleVersions::value) + .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); + } + }); + + return additionalVersions; } private record GradleVersionInvocationContext(GradleVersion gradleVersion) @@ -73,6 +88,7 @@ public void prepareInvocation(ExtensionContext context) { @Override public List getAdditionalExtensions() { return List.of( + new AdditionalGradleVersionsCondition(), new GradleInvokerParameterResolver(), new GradleProjectParameterResolver(), new MavenRepoParameterResolver()); diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java index 22ce9568..fc476f92 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java @@ -19,8 +19,10 @@ import static org.assertj.core.api.Assertions.assertThat; import com.palantir.example.AdditionalGradleVersionsFixtureTest; +import com.palantir.example.MethodLevelAdditionalGradleVersionsFixtureTest; import java.util.List; import org.junit.jupiter.api.Test; +import org.junit.platform.engine.TestDescriptor; import org.junit.platform.engine.discovery.DiscoverySelectors; import org.junit.platform.testkit.engine.EngineExecutionResults; import org.junit.platform.testkit.engine.EngineTestKit; @@ -68,4 +70,32 @@ void duplicate_versions_are_deduplicated() { Assertions.assertThatRanWithCorrectGradleVersion( AdditionalGradleVersionsFixtureTest.class, finished.get(1), "8.5"); } + + @Test + void method_level_additional_gradle_versions_only_apply_to_annotated_method() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(MethodLevelAdditionalGradleVersionsFixtureTest.class)) + // Base version configured via parameter + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + List skipped = executionResults.testEvents().skipped().stream().toList(); + + // Method without annotation: runs with base + class (7.6.5, 8.0) = 2 runs + // Method with @AdditionalGradleVersions({"8.5"}): runs with base + class + method (7.6.5, 8.0, 8.5) = 3 runs + // Total finished: 5 tests, skipped: 1 (method without annotation skipped for 8.5) + assertThat(finished).hasSize(5); + assertThat(skipped).hasSize(1); + + // Verify the skipped test is the method without annotation running on 8.5 + assertThat(skipped.get(0).getTestDescriptor().getDisplayName()).contains("test without method annotation"); + assertThat(skipped.get(0) + .getTestDescriptor() + .getParent() + .map(TestDescriptor::getDisplayName) + .orElse("")) + .isEqualTo("Gradle 8.5"); + } } diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java new file mode 100644 index 00000000..53eff4fc --- /dev/null +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java @@ -0,0 +1,53 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.example; + +import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.AdditionalGradleVersions; +import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.project.RootProject; +import org.junit.jupiter.api.Test; + +@GradlePluginTests +@AdditionalGradleVersions("8.0") +public class MethodLevelAdditionalGradleVersionsFixtureTest { + + @Test + void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + // This exception is just so we can pass the output back up to the JUnit testkit-based test that + // is running this fixture. + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } + + @Test + @AdditionalGradleVersions("8.5") + void test_with_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + // This exception is just so we can pass the output back up to the JUnit testkit-based test that + // is running this fixture. + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } +} From dec4d011e592fed6cafbff02dac7237801e9678c Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 14:18:31 +0000 Subject: [PATCH 06/26] update docs --- docs/testing-guide.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index 414b9989..0ef29fd6 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -147,7 +147,7 @@ See [Resolution of Gradle versions to test against](../README.md#resolution-of-g #### Adding Versions for Specific Tests -Use `@AdditionalGradleVersions` to add extra Gradle versions for a specific test class: +Use `@AdditionalGradleVersions` to add extra Gradle versions for a specific test class or individual test methods: ```java @GradlePluginTests @@ -157,10 +157,16 @@ class CompatibilityTest { void works_on_older_gradle_versions(GradleInvoker gradle, RootProject project) { // This test runs against the globally configured versions PLUS 7.6.5 and 8.0 } + + @Test + @AdditionalGradleVersions("8.5") + void test_specific_version(GradleInvoker gradle, RootProject project) { + // This test runs against globally configured versions PLUS 7.6.5, 8.0 (from class), and 8.5 (from method) + } } ``` -The versions from `@AdditionalGradleVersions` are merged with the globally configured versions. Duplicate versions are automatically deduplicated. +The versions from `@AdditionalGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. ## File Operations From 8651c1281078b7dea720405c1a31630cb0b36768 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 14:31:32 +0000 Subject: [PATCH 07/26] cleanup --- .../junit/GradleVersioningClassTemplate.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index ee1e2169..1917e752 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -18,7 +18,6 @@ import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; -import java.lang.reflect.Method; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; @@ -62,13 +61,14 @@ private static Set findAdditionalVersions(ExtensionContext context) { .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); // Find method-level annotations from all test methods - context.getTestClass().ifPresent(testClass -> { - for (Method method : testClass.getDeclaredMethods()) { - AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class) - .map(AdditionalGradleVersions::value) - .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); - } - }); + context.getTestClass() + .map(Class::getDeclaredMethods) + .stream() + .flatMap(Arrays::stream) + .flatMap(method -> AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class).stream()) + .map(AdditionalGradleVersions::value) + .flatMap(Arrays::stream) + .forEach(additionalVersions::add); return additionalVersions; } From cf57cb8eddd0e2f27c4743a924985fa118f897c5 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 14:58:33 +0000 Subject: [PATCH 08/26] spotless apply --- .../gradle/testing/junit/GradleVersioningClassTemplate.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 1917e752..11d94463 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -61,9 +61,7 @@ private static Set findAdditionalVersions(ExtensionContext context) { .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); // Find method-level annotations from all test methods - context.getTestClass() - .map(Class::getDeclaredMethods) - .stream() + context.getTestClass().map(Class::getDeclaredMethods).stream() .flatMap(Arrays::stream) .flatMap(method -> AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class).stream()) .map(AdditionalGradleVersions::value) From 92d8ce42393d34bae79f9a36f1c9c090d1f7ac35 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 5 Jan 2026 16:47:56 +0000 Subject: [PATCH 09/26] better test exceptions --- .../AdditionalGradleVersionsCondition.java | 9 +-- .../junit/GradleVersioningClassTemplate.java | 16 ++--- .../ete/AdditionalGradleVersionsTest.java | 71 +++++++++++-------- 3 files changed, 51 insertions(+), 45 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java index 21bb4e66..6b742ade 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java @@ -16,11 +16,9 @@ package com.palantir.gradle.testing.junit; -import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; import java.util.Arrays; import java.util.LinkedHashSet; -import java.util.List; import java.util.Set; import org.junit.jupiter.api.extension.ConditionEvaluationResult; import org.junit.jupiter.api.extension.ExecutionCondition; @@ -58,14 +56,9 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con } private Set getVersionsForMethod(ExtensionContext context) { - Set versions = new LinkedHashSet<>(); // Add base versions from configuration - context.getConfigurationParameter("com.palantir.gradle.testing.gradle_versions_to_test") - .ifPresent(param -> { - List configuredVersions = Splitter.on(',').splitToList(param); - versions.addAll(configuredVersions); - }); + Set versions = new LinkedHashSet<>(GradleVersioningClassTemplate.configuredVersions(context)); // Add class-level additional versions context.getTestClass() diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 11d94463..6b4efb3b 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -38,19 +38,19 @@ public boolean supportsClassTemplate(ExtensionContext context) { @Override public Stream provideClassTemplateInvocationContexts( ExtensionContext context) { - String gradleVersionsToTestAgainst = context.getConfigurationParameter( - "com.palantir.gradle.testing.gradle_versions_to_test") - .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " - + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?")); - - List configuredVersions = Splitter.on(',').splitToList(gradleVersionsToTestAgainst); - - Set allVersions = new LinkedHashSet<>(configuredVersions); + Set allVersions = new LinkedHashSet<>(configuredVersions(context)); allVersions.addAll(findAdditionalVersions(context)); return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); } + static List configuredVersions(ExtensionContext context) { + return context.getConfigurationParameter("com.palantir.gradle.testing.gradle_versions_to_test") + .map(param -> Splitter.on(',').splitToList(param)) + .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " + + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?")); + } + private static Set findAdditionalVersions(ExtensionContext context) { Set additionalVersions = new LinkedHashSet<>(); diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java index fc476f92..2b190bf8 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java @@ -21,6 +21,7 @@ import com.palantir.example.AdditionalGradleVersionsFixtureTest; import com.palantir.example.MethodLevelAdditionalGradleVersionsFixtureTest; import java.util.List; +import java.util.function.Consumer; import org.junit.jupiter.api.Test; import org.junit.platform.engine.TestDescriptor; import org.junit.platform.engine.discovery.DiscoverySelectors; @@ -40,15 +41,14 @@ void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { List finished = executionResults.testEvents().finished().stream().toList(); - // Should have 3 test runs: 7.6.5 from config + 8.0 and 8.5 from @AdditionalGradleVersions - assertThat(finished).hasSize(3); - - Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, finished.get(0), "7.6.5"); - Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, finished.get(1), "8.0"); - Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, finished.get(2), "8.5"); + assertThat(finished) + .satisfiesExactlyInAnyOrder( + // from config parameter + ranWithGradleVersion("7.6.5"), + // from @AdditionalGradleVersions + ranWithGradleVersion("8.0"), + // from @AdditionalGradleVersions + ranWithGradleVersion("8.5")); } @Test @@ -62,13 +62,12 @@ void duplicate_versions_are_deduplicated() { List finished = executionResults.testEvents().finished().stream().toList(); - // Should have 2 test runs: 8.0 (deduplicated) and 8.5 from @AdditionalGradleVersions - assertThat(finished).hasSize(2); - - Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, finished.get(0), "8.0"); - Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, finished.get(1), "8.5"); + assertThat(finished) + .satisfiesExactlyInAnyOrder( + // 8.0 is in both config and @AdditionalGradleVersions, but only runs once + ranWithGradleVersion("8.0"), + // from @AdditionalGradleVersions + ranWithGradleVersion("8.5")); } @Test @@ -83,19 +82,33 @@ void method_level_additional_gradle_versions_only_apply_to_annotated_method() { List finished = executionResults.testEvents().finished().stream().toList(); List skipped = executionResults.testEvents().skipped().stream().toList(); - // Method without annotation: runs with base + class (7.6.5, 8.0) = 2 runs - // Method with @AdditionalGradleVersions({"8.5"}): runs with base + class + method (7.6.5, 8.0, 8.5) = 3 runs - // Total finished: 5 tests, skipped: 1 (method without annotation skipped for 8.5) - assertThat(finished).hasSize(5); - assertThat(skipped).hasSize(1); + assertThat(finished) + .satisfiesExactlyInAnyOrder( + // "test without method annotation" runs on base (7.6.5) and class-level (8.0) + ranWithNameAndVersion("test without method annotation", "7.6.5"), + ranWithNameAndVersion("test without method annotation", "8.0"), + // "test with method annotation" runs on base (7.6.5), class-level (8.0), and method-level (8.5) + ranWithNameAndVersion("test with method annotation", "7.6.5"), + ranWithNameAndVersion("test with method annotation", "8.0"), + ranWithNameAndVersion("test with method annotation", "8.5")); + // Method without annotation is skipped for 8.5 (only runs on base + class versions) + assertThat(skipped).satisfiesExactly(event -> { + assertThat(event.getTestDescriptor().getDisplayName()).contains("test without method annotation"); + assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) + .hasValue("Gradle 8.5"); + }); + } + + private static Consumer ranWithGradleVersion(String gradleVersion) { + return event -> Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, event, gradleVersion); + } - // Verify the skipped test is the method without annotation running on 8.5 - assertThat(skipped.get(0).getTestDescriptor().getDisplayName()).contains("test without method annotation"); - assertThat(skipped.get(0) - .getTestDescriptor() - .getParent() - .map(TestDescriptor::getDisplayName) - .orElse("")) - .isEqualTo("Gradle 8.5"); + private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { + return event -> { + assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); + Assertions.assertThatRanWithCorrectGradleVersion( + AdditionalGradleVersionsFixtureTest.class, event, gradleVersion); + }; } } From 277450797bd2475a670fe2908a21f0246c42d030 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 09:56:43 +0000 Subject: [PATCH 10/26] update docs --- docs/testing-guide.md | 11 ++++--- .../junit/GradleVersioningClassTemplate.java | 10 +++---- ...eVersions.java => WithGradleVersions.java} | 14 +++++---- ....java => WithGradleVersionsCondition.java} | 12 ++++---- .../gradle/testing/ete/Assertions.java | 7 ++++- ...sTest.java => WithGradleVersionsTest.java} | 30 +++++++++---------- ...odLevelWithGradleVersionsFixtureTest.java} | 8 ++--- ...ava => WithGradleVersionsFixtureTest.java} | 6 ++-- 8 files changed, 54 insertions(+), 44 deletions(-) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{AdditionalGradleVersions.java => WithGradleVersions.java} (65%) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{AdditionalGradleVersionsCondition.java => WithGradleVersionsCondition.java} (88%) rename gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/{AdditionalGradleVersionsTest.java => WithGradleVersionsTest.java} (81%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{MethodLevelAdditionalGradleVersionsFixtureTest.java => MethodLevelWithGradleVersionsFixtureTest.java} (90%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{AdditionalGradleVersionsFixtureTest.java => WithGradleVersionsFixtureTest.java} (89%) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index 0ef29fd6..d89c9970 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -147,11 +147,14 @@ See [Resolution of Gradle versions to test against](../README.md#resolution-of-g #### Adding Versions for Specific Tests -Use `@AdditionalGradleVersions` to add extra Gradle versions for a specific test class or individual test methods: +Use `@WithGradleVersions` to add extra Gradle versions for a specific test class or individual test methods. + +> **Note:** This annotation is intended for exceptional cases where a specific test needs additional versions. +> For configuring Gradle versions across your entire test suite, prefer setting versions in the `gradle/gradle-test-versions.yml` file. ```java @GradlePluginTests -@AdditionalGradleVersions({"7.6.5", "8.0"}) +@WithGradleVersions({"7.6.5", "8.0"}) class CompatibilityTest { @Test void works_on_older_gradle_versions(GradleInvoker gradle, RootProject project) { @@ -159,14 +162,14 @@ class CompatibilityTest { } @Test - @AdditionalGradleVersions("8.5") + @WithGradleVersions("8.5") void test_specific_version(GradleInvoker gradle, RootProject project) { // This test runs against globally configured versions PLUS 7.6.5, 8.0 (from class), and 8.5 (from method) } } ``` -The versions from `@AdditionalGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. +The versions from `@WithGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. ## File Operations diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 6b4efb3b..6f483081 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -56,15 +56,15 @@ private static Set findAdditionalVersions(ExtensionContext context) { // Find class-level annotation context.getTestClass() - .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, AdditionalGradleVersions.class)) - .map(AdditionalGradleVersions::value) + .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) + .map(WithGradleVersions::value) .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); // Find method-level annotations from all test methods context.getTestClass().map(Class::getDeclaredMethods).stream() .flatMap(Arrays::stream) - .flatMap(method -> AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class).stream()) - .map(AdditionalGradleVersions::value) + .flatMap(method -> AnnotationSupport.findAnnotation(method, WithGradleVersions.class).stream()) + .map(WithGradleVersions::value) .flatMap(Arrays::stream) .forEach(additionalVersions::add); @@ -86,7 +86,7 @@ public void prepareInvocation(ExtensionContext context) { @Override public List getAdditionalExtensions() { return List.of( - new AdditionalGradleVersionsCondition(), + new WithGradleVersionsCondition(), new GradleInvokerParameterResolver(), new GradleProjectParameterResolver(), new MavenRepoParameterResolver()); diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java similarity index 65% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java index 278cc47f..dad26cfa 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java @@ -22,16 +22,18 @@ import java.lang.annotation.Target; /** - * Annotation that can be used to add additional Gradle versions to test against. - * The versions specified in this annotation will be merged with the versions configured via the - * {@code com.palantir.gradle.testing.gradle_versions_to_test} configuration parameter. - * This annotation can be applied to a test class or individual test methods. + * Annotation for adding additional Gradle versions to individual test classes or methods. * - *

When applied to both a class and a method, the versions are combined (base + class + method versions). + *

Important: This annotation is intended for exceptional cases where a specific test or test class + * needs to run against additional Gradle versions beyond the globally configured versions. For configuring + * Gradle versions across your entire test suite, prefer setting versions in the + * {@code gradle/gradle-test-versions.yml} file + * + *

The versions specified in this annotation will be merged with the versions configured in the yml file. */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) -public @interface AdditionalGradleVersions { +public @interface WithGradleVersions { /** * The additional Gradle versions to test against. diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java similarity index 88% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java index 6b742ade..66cd7909 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionalGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java @@ -28,11 +28,11 @@ /** * Execution condition that filters tests based on Gradle version. * - *

When a method has its own {@link AdditionalGradleVersions} annotation, this condition ensures + *

When a method has its own {@link WithGradleVersions} annotation, this condition ensures * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. */ -final class AdditionalGradleVersionsCondition implements ExecutionCondition { +final class WithGradleVersionsCondition implements ExecutionCondition { @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { @@ -62,14 +62,14 @@ private Set getVersionsForMethod(ExtensionContext context) { // Add class-level additional versions context.getTestClass() - .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, AdditionalGradleVersions.class)) - .map(AdditionalGradleVersions::value) + .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) + .map(WithGradleVersions::value) .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); // Add method-level additional versions (only for this method) context.getTestMethod() - .flatMap(method -> AnnotationSupport.findAnnotation(method, AdditionalGradleVersions.class)) - .map(AdditionalGradleVersions::value) + .flatMap(method -> AnnotationSupport.findAnnotation(method, WithGradleVersions.class)) + .map(WithGradleVersions::value) .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); return versions; diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index cfcf92a8..b313558f 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -33,6 +33,11 @@ public static void assertThatTestFailureExceptionMessageContains( } public static void assertThatRanWithCorrectGradleVersion(Class testClass, Event event, String gradleVersion) { + assertThatRanWithCorrectGradleVersion(testClass, event, gradleVersion, "test name"); + } + + public static void assertThatRanWithCorrectGradleVersion( + Class testClass, Event event, String gradleVersion, String testName) { assertThatTestContainerDescriptorHasDisplayName(event, "Gradle " + gradleVersion); assertThat(event.getPayload(TestExecutionResult.class)).hasValueSatisfying(testExecutionResult -> { @@ -45,7 +50,7 @@ public static void assertThatRanWithCorrectGradleVersion(Class testClass, Eve assertThat(Path.of( "build/gradle-plugin-testing", testClass.getSimpleName(), - "test name", + testName, gradleVersion, "build.gradle")) .exists(); diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java similarity index 81% rename from gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java rename to gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java index 2b190bf8..ad3dd547 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionalGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java @@ -18,8 +18,8 @@ import static org.assertj.core.api.Assertions.assertThat; -import com.palantir.example.AdditionalGradleVersionsFixtureTest; -import com.palantir.example.MethodLevelAdditionalGradleVersionsFixtureTest; +import com.palantir.example.MethodLevelWithGradleVersionsFixtureTest; +import com.palantir.example.WithGradleVersionsFixtureTest; import java.util.List; import java.util.function.Consumer; import org.junit.jupiter.api.Test; @@ -29,11 +29,11 @@ import org.junit.platform.testkit.engine.EngineTestKit; import org.junit.platform.testkit.engine.Event; -final class AdditionalGradleVersionsTest { +final class WithGradleVersionsTest { @Test - void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { + void with_gradle_versions_annotation_adds_versions_to_test_matrix() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(AdditionalGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(WithGradleVersionsFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -45,17 +45,17 @@ void additional_gradle_versions_annotation_adds_versions_to_test_matrix() { .satisfiesExactlyInAnyOrder( // from config parameter ranWithGradleVersion("7.6.5"), - // from @AdditionalGradleVersions + // from @WithGradleVersions ranWithGradleVersion("8.0"), - // from @AdditionalGradleVersions + // from @WithGradleVersions ranWithGradleVersion("8.5")); } @Test void duplicate_versions_are_deduplicated() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(AdditionalGradleVersionsFixtureTest.class)) - // 8.0 is both in config and in @AdditionalGradleVersions + .selectors(DiscoverySelectors.selectClass(WithGradleVersionsFixtureTest.class)) + // 8.0 is both in config and in @WithGradleVersions .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -64,16 +64,16 @@ void duplicate_versions_are_deduplicated() { assertThat(finished) .satisfiesExactlyInAnyOrder( - // 8.0 is in both config and @AdditionalGradleVersions, but only runs once + // 8.0 is in both config and @WithGradleVersions, but only runs once ranWithGradleVersion("8.0"), - // from @AdditionalGradleVersions + // from @WithGradleVersions ranWithGradleVersion("8.5")); } @Test - void method_level_additional_gradle_versions_only_apply_to_annotated_method() { + void method_level_with_gradle_versions_only_apply_to_annotated_method() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(MethodLevelAdditionalGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(MethodLevelWithGradleVersionsFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -101,14 +101,14 @@ void method_level_additional_gradle_versions_only_apply_to_annotated_method() { private static Consumer ranWithGradleVersion(String gradleVersion) { return event -> Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, event, gradleVersion); + WithGradleVersionsFixtureTest.class, event, gradleVersion); } private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( - AdditionalGradleVersionsFixtureTest.class, event, gradleVersion); + MethodLevelWithGradleVersionsFixtureTest.class, event, gradleVersion, displayNameContains); }; } } diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java similarity index 90% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java index 53eff4fc..be03df24 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionalGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java @@ -17,14 +17,14 @@ package com.palantir.example; import com.palantir.gradle.testing.execution.GradleInvoker; -import com.palantir.gradle.testing.junit.AdditionalGradleVersions; import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.junit.WithGradleVersions; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@AdditionalGradleVersions("8.0") -public class MethodLevelAdditionalGradleVersionsFixtureTest { +@WithGradleVersions("8.0") +public class MethodLevelWithGradleVersionsFixtureTest { @Test void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { @@ -39,7 +39,7 @@ void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject roo } @Test - @AdditionalGradleVersions("8.5") + @WithGradleVersions("8.5") void test_with_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java similarity index 89% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java index 24c4326a..599e939d 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionalGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java @@ -17,14 +17,14 @@ package com.palantir.example; import com.palantir.gradle.testing.execution.GradleInvoker; -import com.palantir.gradle.testing.junit.AdditionalGradleVersions; import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.junit.WithGradleVersions; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@AdditionalGradleVersions({"8.0", "8.5"}) -public class AdditionalGradleVersionsFixtureTest { +@WithGradleVersions({"8.0", "8.5"}) +public class WithGradleVersionsFixtureTest { @Test void test_name(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" From 3ae90113fa3f0ae084d9b67699c29d5e89e43f84 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 10:08:48 +0000 Subject: [PATCH 11/26] helper methods --- .../junit/GradleVersioningClassTemplate.java | 37 +++++++++---------- .../junit/WithGradleVersionsCondition.java | 29 +++------------ 2 files changed, 23 insertions(+), 43 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 6f483081..214a3f1c 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -18,6 +18,7 @@ import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; +import java.lang.reflect.Method; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; @@ -38,37 +39,35 @@ public boolean supportsClassTemplate(ExtensionContext context) { @Override public Stream provideClassTemplateInvocationContexts( ExtensionContext context) { - Set allVersions = new LinkedHashSet<>(configuredVersions(context)); - allVersions.addAll(findAdditionalVersions(context)); + Set allVersions = new LinkedHashSet<>(baseVersions(context)); + + context.getTestClass().stream() + .flatMap(clazz -> Arrays.stream(clazz.getDeclaredMethods())) + .forEach(method -> allVersions.addAll(methodVersions(method))); return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); } - static List configuredVersions(ExtensionContext context) { - return context.getConfigurationParameter("com.palantir.gradle.testing.gradle_versions_to_test") + static Set baseVersions(ExtensionContext context) { + Set versions = new LinkedHashSet<>(context.getConfigurationParameter( + "com.palantir.gradle.testing.gradle_versions_to_test") .map(param -> Splitter.on(',').splitToList(param)) .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " - + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?")); - } - - private static Set findAdditionalVersions(ExtensionContext context) { - Set additionalVersions = new LinkedHashSet<>(); + + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?"))); - // Find class-level annotation context.getTestClass() .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) .map(WithGradleVersions::value) - .ifPresent(versions -> additionalVersions.addAll(Arrays.asList(versions))); + .ifPresent(v -> versions.addAll(Arrays.asList(v))); - // Find method-level annotations from all test methods - context.getTestClass().map(Class::getDeclaredMethods).stream() - .flatMap(Arrays::stream) - .flatMap(method -> AnnotationSupport.findAnnotation(method, WithGradleVersions.class).stream()) - .map(WithGradleVersions::value) - .flatMap(Arrays::stream) - .forEach(additionalVersions::add); + return versions; + } - return additionalVersions; + static Set methodVersions(Method method) { + return AnnotationSupport.findAnnotation(method, WithGradleVersions.class) + .map(WithGradleVersions::value) + .map(v -> new LinkedHashSet<>(Arrays.asList(v))) + .orElseGet(LinkedHashSet::new); } private record GradleVersionInvocationContext(GradleVersion gradleVersion) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java index 66cd7909..9056d805 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java @@ -17,13 +17,11 @@ package com.palantir.gradle.testing.junit; import com.palantir.gradle.testing.execution.GradleVersion; -import java.util.Arrays; import java.util.LinkedHashSet; import java.util.Set; import org.junit.jupiter.api.extension.ConditionEvaluationResult; import org.junit.jupiter.api.extension.ExecutionCondition; import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.platform.commons.support.AnnotationSupport; /** * Execution condition that filters tests based on Gradle version. @@ -42,10 +40,13 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con } GradleVersion currentVersion = GradleVersionStore.gradleVersion(context); - - Set versionsForThisMethod = getVersionsForMethod(context); String currentVersionString = currentVersion.toString(); + Set versionsForThisMethod = new LinkedHashSet<>(GradleVersioningClassTemplate.baseVersions(context)); + context.getTestMethod() + .map(GradleVersioningClassTemplate::methodVersions) + .ifPresent(versionsForThisMethod::addAll); + if (versionsForThisMethod.contains(currentVersionString)) { return ConditionEvaluationResult.enabled( "Gradle version " + currentVersionString + " is in the allowed set for this method"); @@ -54,24 +55,4 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con return ConditionEvaluationResult.disabled("Gradle version " + currentVersionString + " is not in the allowed set for this method: " + versionsForThisMethod); } - - private Set getVersionsForMethod(ExtensionContext context) { - - // Add base versions from configuration - Set versions = new LinkedHashSet<>(GradleVersioningClassTemplate.configuredVersions(context)); - - // Add class-level additional versions - context.getTestClass() - .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) - .map(WithGradleVersions::value) - .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); - - // Add method-level additional versions (only for this method) - context.getTestMethod() - .flatMap(method -> AnnotationSupport.findAnnotation(method, WithGradleVersions.class)) - .map(WithGradleVersions::value) - .ifPresent(additionalVersions -> versions.addAll(Arrays.asList(additionalVersions))); - - return versions; - } } From 013ce0592ee6394fc01cd8113b68ce7dd46c4fce Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 10:13:34 +0000 Subject: [PATCH 12/26] reason --- .../palantir/gradle/testing/junit/WithGradleVersions.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java index dad26cfa..a6af2a65 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java @@ -40,4 +40,10 @@ * @return an array of Gradle version strings (e.g., "7.6.5", "8.0") */ String[] value(); + + /** + * Optional reason explaining why these additional Gradle versions are needed. + * @return the reason for requiring these specific versions + */ + String reason() default ""; } From 32333a4b1172818e5f2a57342bcef3cf15c228fc Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 10:33:21 +0000 Subject: [PATCH 13/26] with only --- .../junit/GradleVersioningClassTemplate.java | 6 + .../junit/WithGradleVersionsCondition.java | 20 +++ .../testing/junit/WithOnlyGradleVersions.java | 53 ++++++++ .../gradle/testing/ete/Assertions.java | 18 +++ .../testing/ete/WithGradleVersionsTest.java | 36 +++-- .../ete/WithOnlyGradleVersionsTest.java | 124 ++++++++++++++++++ ...evelWithOnlyGradleVersionsFixtureTest.java | 42 ++++++ ...hOnlyAndWithGradleVersionsFixtureTest.java | 44 +++++++ .../WithOnlyGradleVersionsFixtureTest.java | 65 +++++++++ 9 files changed, 389 insertions(+), 19 deletions(-) create mode 100644 gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java create mode 100644 gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java create mode 100644 gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java create mode 100644 gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithGradleVersionsFixtureTest.java create mode 100644 gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 214a3f1c..f0c04189 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -45,6 +45,12 @@ public Stream provideClassTemplateInvo .flatMap(clazz -> Arrays.stream(clazz.getDeclaredMethods())) .forEach(method -> allVersions.addAll(methodVersions(method))); + // Apply class-level @WithOnlyGradleVersions filter to the matrix + context.getTestClass() + .flatMap(clazz -> AnnotationSupport.findAnnotation(clazz, WithOnlyGradleVersions.class)) + .map(WithOnlyGradleVersions::value) + .ifPresent(onlyVersions -> allVersions.retainAll(Arrays.asList(onlyVersions))); + return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); } diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java index 9056d805..78618d0a 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java @@ -17,11 +17,14 @@ package com.palantir.gradle.testing.junit; import com.palantir.gradle.testing.execution.GradleVersion; +import java.util.Arrays; import java.util.LinkedHashSet; +import java.util.Optional; import java.util.Set; import org.junit.jupiter.api.extension.ConditionEvaluationResult; import org.junit.jupiter.api.extension.ExecutionCondition; import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; /** * Execution condition that filters tests based on Gradle version. @@ -29,6 +32,11 @@ *

When a method has its own {@link WithGradleVersions} annotation, this condition ensures * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. + * + *

When a method has {@link WithOnlyGradleVersions}, the allowed versions are filtered + * to only include versions that appear in both the normal allowed set AND the "only" filter. + * Class-level {@link WithOnlyGradleVersions} is handled in {@link GradleVersioningClassTemplate} + * to filter the test matrix upfront. */ final class WithGradleVersionsCondition implements ExecutionCondition { @@ -47,6 +55,10 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con .map(GradleVersioningClassTemplate::methodVersions) .ifPresent(versionsForThisMethod::addAll); + // Apply WithOnlyGradleVersions filter if present (class-level first, then method-level) + Optional> onlyFilter = getOnlyGradleVersionsFilter(context); + onlyFilter.ifPresent(versionsForThisMethod::retainAll); + if (versionsForThisMethod.contains(currentVersionString)) { return ConditionEvaluationResult.enabled( "Gradle version " + currentVersionString + " is in the allowed set for this method"); @@ -55,4 +67,12 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con return ConditionEvaluationResult.disabled("Gradle version " + currentVersionString + " is not in the allowed set for this method: " + versionsForThisMethod); } + + private Optional> getOnlyGradleVersionsFilter(ExtensionContext context) { + // Only check method-level @WithOnlyGradleVersions here. + // Class-level is handled in GradleVersioningClassTemplate to filter the matrix upfront. + return context.getTestMethod() + .flatMap(method -> AnnotationSupport.findAnnotation(method, WithOnlyGradleVersions.class)) + .map(annotation -> new LinkedHashSet<>(Arrays.asList(annotation.value()))); + } } diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java new file mode 100644 index 00000000..a118c4d2 --- /dev/null +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java @@ -0,0 +1,53 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.junit; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Annotation for filtering Gradle versions to only run the specified versions. + * + *

Unlike {@link WithGradleVersions} which adds versions to the test matrix, this annotation filters the + * available versions to only include the specified ones. If a specified version is not in the test matrix + * (from configuration or {@code @WithGradleVersions}), it will simply not run. + * + *

Example: If the test matrix has versions 7.6.5 and 8.0, and you annotate with + * {@code @WithOnlyGradleVersions("8.0")}, only 8.0 will run. If you annotate with + * {@code @WithOnlyGradleVersions("8.5")}, no tests will run (since 8.5 is not in the matrix). + * + *

To run a specific version that isn't in the matrix, use both annotations: + * {@code @WithGradleVersions("8.5")} and {@code @WithOnlyGradleVersions("8.5")}. + */ +@Target({ElementType.TYPE, ElementType.METHOD}) +@Retention(RetentionPolicy.RUNTIME) +public @interface WithOnlyGradleVersions { + + /** + * The Gradle versions to filter to. + * @return an array of Gradle version strings (e.g., "7.6.5", "8.0") + */ + String[] value(); + + /** + * Optional reason explaining why only these specific Gradle versions should run. + * @return the reason for filtering to these specific versions + */ + String reason() default ""; +} diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index b313558f..aebad335 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -19,6 +19,8 @@ import static org.assertj.core.api.Assertions.assertThat; import java.nio.file.Path; +import java.util.function.Consumer; +import org.junit.platform.engine.TestDescriptor; import org.junit.platform.engine.TestExecutionResult; import org.junit.platform.engine.TestExecutionResult.Status; import org.junit.platform.testkit.engine.Event; @@ -56,6 +58,22 @@ public static void assertThatRanWithCorrectGradleVersion( .exists(); } + public static Consumer ranWithNameAndVersion( + Class testClass, String displayNameContains, String gradleVersion) { + return event -> { + assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); + assertThatRanWithCorrectGradleVersion(testClass, event, gradleVersion, displayNameContains); + }; + } + + public static Consumer skippedWithNameAndVersion(String displayNameContains, String gradleVersion) { + return event -> { + assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); + assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) + .hasValue("Gradle " + gradleVersion); + }; + } + private static void assertThatTestContainerDescriptorHasDisplayName( Event event, String containerDescriptorDisplayName) { assertThat(event.getTestDescriptor().getParent()).hasValueSatisfying(desc -> { diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java index ad3dd547..e381213c 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java @@ -16,6 +16,8 @@ package com.palantir.gradle.testing.ete; +import static com.palantir.gradle.testing.ete.Assertions.ranWithNameAndVersion; +import static com.palantir.gradle.testing.ete.Assertions.skippedWithNameAndVersion; import static org.assertj.core.api.Assertions.assertThat; import com.palantir.example.MethodLevelWithGradleVersionsFixtureTest; @@ -23,7 +25,6 @@ import java.util.List; import java.util.function.Consumer; import org.junit.jupiter.api.Test; -import org.junit.platform.engine.TestDescriptor; import org.junit.platform.engine.discovery.DiscoverySelectors; import org.junit.platform.testkit.engine.EngineExecutionResults; import org.junit.platform.testkit.engine.EngineTestKit; @@ -85,30 +86,27 @@ void method_level_with_gradle_versions_only_apply_to_annotated_method() { assertThat(finished) .satisfiesExactlyInAnyOrder( // "test without method annotation" runs on base (7.6.5) and class-level (8.0) - ranWithNameAndVersion("test without method annotation", "7.6.5"), - ranWithNameAndVersion("test without method annotation", "8.0"), + ranWithNameAndVersion( + MethodLevelWithGradleVersionsFixtureTest.class, + "test without method annotation", + "7.6.5"), + ranWithNameAndVersion( + MethodLevelWithGradleVersionsFixtureTest.class, + "test without method annotation", + "8.0"), // "test with method annotation" runs on base (7.6.5), class-level (8.0), and method-level (8.5) - ranWithNameAndVersion("test with method annotation", "7.6.5"), - ranWithNameAndVersion("test with method annotation", "8.0"), - ranWithNameAndVersion("test with method annotation", "8.5")); + ranWithNameAndVersion( + MethodLevelWithGradleVersionsFixtureTest.class, "test with method annotation", "7.6.5"), + ranWithNameAndVersion( + MethodLevelWithGradleVersionsFixtureTest.class, "test with method annotation", "8.0"), + ranWithNameAndVersion( + MethodLevelWithGradleVersionsFixtureTest.class, "test with method annotation", "8.5")); // Method without annotation is skipped for 8.5 (only runs on base + class versions) - assertThat(skipped).satisfiesExactly(event -> { - assertThat(event.getTestDescriptor().getDisplayName()).contains("test without method annotation"); - assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) - .hasValue("Gradle 8.5"); - }); + assertThat(skipped).satisfiesExactly(skippedWithNameAndVersion("test without method annotation", "8.5")); } private static Consumer ranWithGradleVersion(String gradleVersion) { return event -> Assertions.assertThatRanWithCorrectGradleVersion( WithGradleVersionsFixtureTest.class, event, gradleVersion); } - - private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { - return event -> { - assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); - Assertions.assertThatRanWithCorrectGradleVersion( - MethodLevelWithGradleVersionsFixtureTest.class, event, gradleVersion, displayNameContains); - }; - } } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java new file mode 100644 index 00000000..6dcc3974 --- /dev/null +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java @@ -0,0 +1,124 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.ete; + +import static com.palantir.gradle.testing.ete.Assertions.ranWithNameAndVersion; +import static com.palantir.gradle.testing.ete.Assertions.skippedWithNameAndVersion; +import static org.assertj.core.api.Assertions.assertThat; + +import com.palantir.example.ClassLevelWithOnlyGradleVersionsFixtureTest; +import com.palantir.example.WithOnlyAndWithGradleVersionsFixtureTest; +import com.palantir.example.WithOnlyGradleVersionsFixtureTest; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.junit.platform.engine.discovery.DiscoverySelectors; +import org.junit.platform.testkit.engine.EngineExecutionResults; +import org.junit.platform.testkit.engine.EngineTestKit; +import org.junit.platform.testkit.engine.Event; + +final class WithOnlyGradleVersionsTest { + + @Test + void with_only_gradle_versions_filters_to_specified_version() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(WithOnlyGradleVersionsFixtureTest.class)) + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + List skipped = executionResults.testEvents().skipped().stream().toList(); + + // test_without_only_annotation runs on both base versions (7.6.5, 8.0) + // test_with_only_annotation_filtering_to_existing_version runs only on 8.0 (filtered) + // test_with_only_annotation_filtering_to_nonexisting_version is skipped on both (8.5 not in matrix) + + assertThat(finished) + .satisfiesExactlyInAnyOrder( + // test_without_only_annotation runs on both base versions + ranWithNameAndVersion( + WithOnlyGradleVersionsFixtureTest.class, "test without only annotation", "7.6.5"), + ranWithNameAndVersion( + WithOnlyGradleVersionsFixtureTest.class, "test without only annotation", "8.0"), + // test_with_only_annotation_filtering_to_existing_version only runs on 8.0 + ranWithNameAndVersion( + WithOnlyGradleVersionsFixtureTest.class, + "test with only annotation filtering to existing version", + "8.0")); + + // test_with_only_annotation_filtering_to_existing_version is skipped on 7.6.5 + // test_with_only_annotation_filtering_to_nonexisting_version is skipped on both versions + assertThat(skipped).hasSize(3); + assertThat(skipped) + .satisfiesExactlyInAnyOrder( + // 7.6.5 skipped for "only 8.0" test + skippedWithNameAndVersion("test with only annotation filtering to existing version", "7.6.5"), + // 7.6.5 skipped for "only 8.5" test (nonexistent in matrix) + skippedWithNameAndVersion( + "test with only annotation filtering to nonexisting version", "7.6.5"), + // 8.0 skipped for "only 8.5" test (nonexistent in matrix) + skippedWithNameAndVersion("test with only annotation filtering to nonexisting version", "8.0")); + } + + @Test + void with_only_and_with_gradle_versions_combined_adds_then_filters() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(WithOnlyAndWithGradleVersionsFixtureTest.class)) + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + List skipped = executionResults.testEvents().skipped().stream().toList(); + + // @WithGradleVersions("8.5") adds 8.5 to matrix, @WithOnlyGradleVersions("8.5") filters to only 8.5 + assertThat(finished) + .satisfiesExactly(ranWithNameAndVersion( + WithOnlyAndWithGradleVersionsFixtureTest.class, + "test with both annotations adding and filtering", + "8.5")); + + // 7.6.5 and 8.0 are skipped because @WithOnlyGradleVersions filters them out + assertThat(skipped).hasSize(2); + assertThat(skipped) + .satisfiesExactlyInAnyOrder( + skippedWithNameAndVersion("test with both annotations adding and filtering", "7.6.5"), + skippedWithNameAndVersion("test with both annotations adding and filtering", "8.0")); + } + + @Test + void class_level_with_only_gradle_versions_filters_matrix_upfront() { + EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") + .selectors(DiscoverySelectors.selectClass(ClassLevelWithOnlyGradleVersionsFixtureTest.class)) + .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") + .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") + .execute(); + + List finished = executionResults.testEvents().finished().stream().toList(); + List skipped = executionResults.testEvents().skipped().stream().toList(); + + // Class-level @WithOnlyGradleVersions("8.0") filters matrix to only 8.0 + // No tests should be skipped - 7.6.5 is not even in the matrix + assertThat(finished) + .satisfiesExactly(ranWithNameAndVersion( + ClassLevelWithOnlyGradleVersionsFixtureTest.class, + "test runs only on filtered version", + "8.0")); + + assertThat(skipped).isEmpty(); + } +} diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java new file mode 100644 index 00000000..74a0bdd3 --- /dev/null +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java @@ -0,0 +1,42 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.example; + +import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.project.RootProject; +import org.junit.jupiter.api.Test; + +/** + * Test fixture for testing class-level {@link WithOnlyGradleVersions} annotation behavior. + * When applied at class level, the annotation filters the test matrix upfront. + */ +@GradlePluginTests +@WithOnlyGradleVersions("8.0") +public class ClassLevelWithOnlyGradleVersionsFixtureTest { + + @Test + void test_runs_only_on_filtered_version(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } +} diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithGradleVersionsFixtureTest.java new file mode 100644 index 00000000..cb621987 --- /dev/null +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithGradleVersionsFixtureTest.java @@ -0,0 +1,44 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.example; + +import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.junit.WithGradleVersions; +import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.project.RootProject; +import org.junit.jupiter.api.Test; + +/** + * Test fixture for testing {@link WithOnlyGradleVersions} combined with {@link WithGradleVersions}. + * This is in a separate fixture so that the @WithGradleVersions doesn't affect the test matrix of other tests. + */ +@GradlePluginTests +public class WithOnlyAndWithGradleVersionsFixtureTest { + + @Test + @WithGradleVersions("8.5") + @WithOnlyGradleVersions("8.5") + void test_with_both_annotations_adding_and_filtering(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } +} diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java new file mode 100644 index 00000000..7369cb7f --- /dev/null +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java @@ -0,0 +1,65 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.example; + +import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.GradlePluginTests; +import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.project.RootProject; +import org.junit.jupiter.api.Test; + +/** + * Test fixture for testing {@link WithOnlyGradleVersions} annotation behavior. + * This fixture is designed to be run with base versions 7.6.5 and 8.0 via configuration parameter. + */ +@GradlePluginTests +public class WithOnlyGradleVersionsFixtureTest { + + @Test + void test_without_only_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + // This exception is just so we can pass the output back up to the JUnit testkit-based test + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } + + @Test + @WithOnlyGradleVersions("8.0") + void test_with_only_annotation_filtering_to_existing_version(GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } + + @Test + @WithOnlyGradleVersions("8.5") + void test_with_only_annotation_filtering_to_nonexisting_version( + GradleInvoker gradleInvoker, RootProject rootProject) { + rootProject.buildGradle().append(""" + import org.gradle.util.GradleVersion + println "GradleVersion: ${GradleVersion.current().version}" + """); + + throw new RuntimeException(gradleInvoker.withArgs().buildsSuccessfully().output()); + } +} From e5d0346573dcd7dc25204705c52ca3efff453aa4 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:16:53 +0000 Subject: [PATCH 14/26] good --- docs/testing-guide.md | 38 ++++++ .../testing/junit/GradleVersionFilter.java | 115 ++++++++++++++++++ .../junit/GradleVersioningClassTemplate.java | 42 +------ .../junit/WithGradleVersionsCondition.java | 37 ++---- .../testing/junit/WithOnlyGradleVersions.java | 4 - 5 files changed, 161 insertions(+), 75 deletions(-) create mode 100644 gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersionFilter.java diff --git a/docs/testing-guide.md b/docs/testing-guide.md index d89c9970..0946bb73 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -171,6 +171,44 @@ class CompatibilityTest { The versions from `@WithGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. +#### Filtering to Specific Versions + +Use `@WithOnlyGradleVersions` to filter the test matrix to only run on specific Gradle versions. Unlike `@WithGradleVersions` which adds versions, this annotation restricts which versions from the matrix will actually run. + +```java +@GradlePluginTests +class FilteredVersionTest { + @Test + @WithOnlyGradleVersions(value = "8.14.3", reason = "This test only applies to Gradle 8.14.3") + void test_only_on_specific_version(GradleInvoker gradle, RootProject project) { + // This test only runs on 8.14.3, even if other versions are in the matrix + } + + @Test + @WithOnlyGradleVersions({"8.10", "8.14.3"}) + void test_on_subset_of_versions(GradleInvoker gradle, RootProject project) { + // This test only runs on 8.10 and 8.14.3 + } +} +``` + +**Key differences from `@WithGradleVersions`:** +- `@WithGradleVersions` **adds** versions to the test matrix +- `@WithOnlyGradleVersions` **filters** the existing matrix to only include specified versions + +**Important:** If you specify a version that isn't in the test matrix, the test simply won't run for that version. To run a specific version that isn't in the matrix, use both annotations together: + +```java +@Test +@WithGradleVersions("8.5") // Add 8.5 to the matrix +@WithOnlyGradleVersions("8.5") // Filter to only run 8.5 +void test_only_on_8_5(GradleInvoker gradle, RootProject project) { + // Runs exclusively on Gradle 8.5 +} +``` + +The annotation can be applied at the class level to filter all tests in the class, or at the method level for individual tests. Method-level filters are applied in addition to class-level filters. + ## File Operations ### Working with Files diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersionFilter.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersionFilter.java new file mode 100644 index 00000000..fed75c4a --- /dev/null +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersionFilter.java @@ -0,0 +1,115 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.junit; + +import com.google.common.base.Splitter; +import com.palantir.gradle.testing.execution.GradleVersion; +import java.lang.reflect.AnnotatedElement; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; + +/** + * Utility class for filtering Gradle versions based on annotations. + * + *

Provides two main methods: + *

    + *
  • {@link #allFilteredVersions} - all versions across class and methods, with class-level filter applied
    • + *
  • {@link #filteredVersionsForMethod} - versions for a specific method, with method-level filter applied
    • + *
+ */ +final class GradleVersionFilter { + + private static final String GRADLE_VERSIONS_CONFIG_PARAM = "com.palantir.gradle.testing.gradle_versions_to_test"; + + /** + * Returns all Gradle versions for the test class, including versions from all methods, + * with the class-level {@link WithOnlyGradleVersions} filter applied. + * + *

This is used to build the complete test matrix for the class. + */ + static Set allFilteredVersions(ExtensionContext context) { + Set versions = configuredVersions(context); + + context.getTestClass().ifPresent(clazz -> { + versions.addAll(versionsFromAnnotation(clazz)); + + Arrays.stream(clazz.getDeclaredMethods()) + .filter(GradleVersionFilter::isTestMethod) + .forEach(method -> versions.addAll(versionsFromAnnotation(method))); + + applyFilter(versions, clazz); + }); + + return versions; + } + + /** + * Returns all Gradle versions for a specific method, including class-level versions, + * with the method-level {@link WithOnlyGradleVersions} filter applied. + * + *

This is used to determine if a method should run for a given Gradle version. + */ + static Set filteredVersionsForMethod(ExtensionContext context) { + Set versions = configuredVersions(context); + + context.getTestClass().ifPresent(clazz -> versions.addAll(versionsFromAnnotation(clazz))); + + context.getTestMethod().ifPresent(method -> { + versions.addAll(versionsFromAnnotation(method)); + applyFilter(versions, method); + }); + + return versions; + } + + private static Set configuredVersions(ExtensionContext context) { + return new LinkedHashSet<>(context.getConfigurationParameter(GRADLE_VERSIONS_CONFIG_PARAM) + .map(param -> Splitter.on(',').splitToList(param).stream() + .map(GradleVersion::new) + .toList()) + .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " + + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?"))); + } + + private static Set versionsFromAnnotation(AnnotatedElement element) { + return AnnotationSupport.findAnnotation(element, WithGradleVersions.class).stream() + .flatMap(annotation -> Arrays.stream(annotation.value())) + .map(GradleVersion::new) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } + + private static void applyFilter(Set versions, AnnotatedElement element) { + AnnotationSupport.findAnnotation(element, WithOnlyGradleVersions.class).ifPresent(annotation -> { + Set allowed = Arrays.stream(annotation.value()) + .map(GradleVersion::new) + .collect(Collectors.toSet()); + versions.retainAll(allowed); + }); + } + + private static boolean isTestMethod(Method method) { + return AnnotationSupport.isAnnotated(method, Test.class); + } + + private GradleVersionFilter() {} +} diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index f0c04189..7058b2bd 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -16,19 +16,13 @@ package com.palantir.gradle.testing.junit; -import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; -import java.lang.reflect.Method; -import java.util.Arrays; -import java.util.LinkedHashSet; import java.util.List; -import java.util.Set; import java.util.stream.Stream; import org.junit.jupiter.api.extension.ClassTemplateInvocationContext; import org.junit.jupiter.api.extension.ClassTemplateInvocationContextProvider; import org.junit.jupiter.api.extension.Extension; import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.platform.commons.support.AnnotationSupport; final class GradleVersioningClassTemplate implements ClassTemplateInvocationContextProvider { @Override @@ -39,41 +33,7 @@ public boolean supportsClassTemplate(ExtensionContext context) { @Override public Stream provideClassTemplateInvocationContexts( ExtensionContext context) { - Set allVersions = new LinkedHashSet<>(baseVersions(context)); - - context.getTestClass().stream() - .flatMap(clazz -> Arrays.stream(clazz.getDeclaredMethods())) - .forEach(method -> allVersions.addAll(methodVersions(method))); - - // Apply class-level @WithOnlyGradleVersions filter to the matrix - context.getTestClass() - .flatMap(clazz -> AnnotationSupport.findAnnotation(clazz, WithOnlyGradleVersions.class)) - .map(WithOnlyGradleVersions::value) - .ifPresent(onlyVersions -> allVersions.retainAll(Arrays.asList(onlyVersions))); - - return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); - } - - static Set baseVersions(ExtensionContext context) { - Set versions = new LinkedHashSet<>(context.getConfigurationParameter( - "com.palantir.gradle.testing.gradle_versions_to_test") - .map(param -> Splitter.on(',').splitToList(param)) - .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " - + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?"))); - - context.getTestClass() - .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) - .map(WithGradleVersions::value) - .ifPresent(v -> versions.addAll(Arrays.asList(v))); - - return versions; - } - - static Set methodVersions(Method method) { - return AnnotationSupport.findAnnotation(method, WithGradleVersions.class) - .map(WithGradleVersions::value) - .map(v -> new LinkedHashSet<>(Arrays.asList(v))) - .orElseGet(LinkedHashSet::new); + return GradleVersionFilter.allFilteredVersions(context).stream().map(GradleVersionInvocationContext::new); } private record GradleVersionInvocationContext(GradleVersion gradleVersion) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java index 78618d0a..dd165250 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java @@ -17,14 +17,10 @@ package com.palantir.gradle.testing.junit; import com.palantir.gradle.testing.execution.GradleVersion; -import java.util.Arrays; -import java.util.LinkedHashSet; -import java.util.Optional; import java.util.Set; import org.junit.jupiter.api.extension.ConditionEvaluationResult; import org.junit.jupiter.api.extension.ExecutionCondition; import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.platform.commons.support.AnnotationSupport; /** * Execution condition that filters tests based on Gradle version. @@ -33,46 +29,27 @@ * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. * - *

When a method has {@link WithOnlyGradleVersions}, the allowed versions are filtered - * to only include versions that appear in both the normal allowed set AND the "only" filter. - * Class-level {@link WithOnlyGradleVersions} is handled in {@link GradleVersioningClassTemplate} + *

When a method has filter annotations like {@link WithOnlyGradleVersions}, the allowed versions + * are filtered accordingly. Class-level filter annotations are handled in {@link GradleVersioningClassTemplate} * to filter the test matrix upfront. */ final class WithGradleVersionsCondition implements ExecutionCondition { @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { - // Only evaluate for test methods if (context.getTestMethod().isEmpty()) { return ConditionEvaluationResult.enabled("No test method"); } GradleVersion currentVersion = GradleVersionStore.gradleVersion(context); - String currentVersionString = currentVersion.toString(); + Set allowedVersions = GradleVersionFilter.filteredVersionsForMethod(context); - Set versionsForThisMethod = new LinkedHashSet<>(GradleVersioningClassTemplate.baseVersions(context)); - context.getTestMethod() - .map(GradleVersioningClassTemplate::methodVersions) - .ifPresent(versionsForThisMethod::addAll); - - // Apply WithOnlyGradleVersions filter if present (class-level first, then method-level) - Optional> onlyFilter = getOnlyGradleVersionsFilter(context); - onlyFilter.ifPresent(versionsForThisMethod::retainAll); - - if (versionsForThisMethod.contains(currentVersionString)) { + if (allowedVersions.contains(currentVersion)) { return ConditionEvaluationResult.enabled( - "Gradle version " + currentVersionString + " is in the allowed set for this method"); + "Gradle version " + currentVersion + " is in the allowed set for this method"); } - return ConditionEvaluationResult.disabled("Gradle version " + currentVersionString - + " is not in the allowed set for this method: " + versionsForThisMethod); - } - - private Optional> getOnlyGradleVersionsFilter(ExtensionContext context) { - // Only check method-level @WithOnlyGradleVersions here. - // Class-level is handled in GradleVersioningClassTemplate to filter the matrix upfront. - return context.getTestMethod() - .flatMap(method -> AnnotationSupport.findAnnotation(method, WithOnlyGradleVersions.class)) - .map(annotation -> new LinkedHashSet<>(Arrays.asList(annotation.value()))); + return ConditionEvaluationResult.disabled("Gradle version " + currentVersion + + " is not in the allowed set for this method: " + allowedVersions); } } diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java index a118c4d2..3014c0f5 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java @@ -28,10 +28,6 @@ * available versions to only include the specified ones. If a specified version is not in the test matrix * (from configuration or {@code @WithGradleVersions}), it will simply not run. * - *

Example: If the test matrix has versions 7.6.5 and 8.0, and you annotate with - * {@code @WithOnlyGradleVersions("8.0")}, only 8.0 will run. If you annotate with - * {@code @WithOnlyGradleVersions("8.5")}, no tests will run (since 8.5 is not in the matrix). - * *

To run a specific version that isn't in the matrix, use both annotations: * {@code @WithGradleVersions("8.5")} and {@code @WithOnlyGradleVersions("8.5")}. */ From 08838e4b7f97a655f3b38c4a9c4b50b614645085 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:23:50 +0000 Subject: [PATCH 15/26] tidy up --- .../junit/GradleVersioningClassTemplate.java | 36 +------ .../gradle/testing/junit/GradleVersions.java | 101 ++++++++++++++++++ .../junit/WithGradleVersionsCondition.java | 14 +-- 3 files changed, 106 insertions(+), 45 deletions(-) create mode 100644 gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 214a3f1c..5dc2b37a 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -16,19 +16,13 @@ package com.palantir.gradle.testing.junit; -import com.google.common.base.Splitter; import com.palantir.gradle.testing.execution.GradleVersion; -import java.lang.reflect.Method; -import java.util.Arrays; -import java.util.LinkedHashSet; import java.util.List; -import java.util.Set; import java.util.stream.Stream; import org.junit.jupiter.api.extension.ClassTemplateInvocationContext; import org.junit.jupiter.api.extension.ClassTemplateInvocationContextProvider; import org.junit.jupiter.api.extension.Extension; import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.platform.commons.support.AnnotationSupport; final class GradleVersioningClassTemplate implements ClassTemplateInvocationContextProvider { @Override @@ -39,35 +33,7 @@ public boolean supportsClassTemplate(ExtensionContext context) { @Override public Stream provideClassTemplateInvocationContexts( ExtensionContext context) { - Set allVersions = new LinkedHashSet<>(baseVersions(context)); - - context.getTestClass().stream() - .flatMap(clazz -> Arrays.stream(clazz.getDeclaredMethods())) - .forEach(method -> allVersions.addAll(methodVersions(method))); - - return allVersions.stream().map(GradleVersion::new).map(GradleVersionInvocationContext::new); - } - - static Set baseVersions(ExtensionContext context) { - Set versions = new LinkedHashSet<>(context.getConfigurationParameter( - "com.palantir.gradle.testing.gradle_versions_to_test") - .map(param -> Splitter.on(',').splitToList(param)) - .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " - + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?"))); - - context.getTestClass() - .flatMap(testClass -> AnnotationSupport.findAnnotation(testClass, WithGradleVersions.class)) - .map(WithGradleVersions::value) - .ifPresent(v -> versions.addAll(Arrays.asList(v))); - - return versions; - } - - static Set methodVersions(Method method) { - return AnnotationSupport.findAnnotation(method, WithGradleVersions.class) - .map(WithGradleVersions::value) - .map(v -> new LinkedHashSet<>(Arrays.asList(v))) - .orElseGet(LinkedHashSet::new); + return GradleVersions.allVersions(context).stream().map(GradleVersionInvocationContext::new); } private record GradleVersionInvocationContext(GradleVersion gradleVersion) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java new file mode 100644 index 00000000..8a6b30cc --- /dev/null +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java @@ -0,0 +1,101 @@ +/* + * (c) Copyright 2025 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.gradle.testing.junit; + +import com.google.common.base.Splitter; +import com.palantir.gradle.testing.execution.GradleVersion; +import java.lang.reflect.AnnotatedElement; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; + +/** + * Utility class for Gradle versions based on annotations. + * + *

Provides two main methods: + *

    + *
  • {@link #allVersions} - all versions across class and methods
    • + *
  • {@link #versionsForMethod} - all versions for a specific method
    • + *
+ */ +final class GradleVersions { + + private static final String GRADLE_VERSIONS_CONFIG_PARAM = "com.palantir.gradle.testing.gradle_versions_to_test"; + + /** + * Returns all Gradle versions for the test class, including versions from all methods. + * + *

This is used to build the complete test matrix for the class. + */ + static Set allVersions(ExtensionContext context) { + Set versions = configuredVersions(context); + + context.getTestClass().ifPresent(clazz -> { + versions.addAll(versionsFromAnnotation(clazz)); + + Arrays.stream(clazz.getDeclaredMethods()) + .filter(GradleVersions::isTestMethod) + .forEach(method -> versions.addAll(versionsFromAnnotation(method))); + }); + + return versions; + } + + /** + * Returns all Gradle versions for a specific method, including class-level versions. + * + *

This is used to determine if a method should run for a given Gradle version. + */ + static Set versionsForMethod(ExtensionContext context) { + Set versions = configuredVersions(context); + + context.getTestClass().ifPresent(clazz -> versions.addAll(versionsFromAnnotation(clazz))); + + context.getTestMethod().ifPresent(method -> { + versions.addAll(versionsFromAnnotation(method)); + }); + + return versions; + } + + private static Set configuredVersions(ExtensionContext context) { + return new LinkedHashSet<>(context.getConfigurationParameter(GRADLE_VERSIONS_CONFIG_PARAM) + .map(param -> Splitter.on(',').splitToList(param).stream() + .map(GradleVersion::new) + .toList()) + .orElseThrow(() -> new RuntimeException("Not configured with the gradle versions to test against. " + + "Have you applied the `com.palantir.gradle-plugin-testing` plugin to this project?"))); + } + + private static Set versionsFromAnnotation(AnnotatedElement element) { + return AnnotationSupport.findAnnotation(element, WithGradleVersions.class).stream() + .flatMap(annotation -> Arrays.stream(annotation.value())) + .map(GradleVersion::new) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } + + private static boolean isTestMethod(Method method) { + return AnnotationSupport.isAnnotated(method, Test.class); + } + + private GradleVersions() {} +} diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java index 9056d805..7487bf48 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java @@ -17,7 +17,6 @@ package com.palantir.gradle.testing.junit; import com.palantir.gradle.testing.execution.GradleVersion; -import java.util.LinkedHashSet; import java.util.Set; import org.junit.jupiter.api.extension.ConditionEvaluationResult; import org.junit.jupiter.api.extension.ExecutionCondition; @@ -40,19 +39,14 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con } GradleVersion currentVersion = GradleVersionStore.gradleVersion(context); - String currentVersionString = currentVersion.toString(); + Set versionsForThisMethod = GradleVersions.versionsForMethod(context); - Set versionsForThisMethod = new LinkedHashSet<>(GradleVersioningClassTemplate.baseVersions(context)); - context.getTestMethod() - .map(GradleVersioningClassTemplate::methodVersions) - .ifPresent(versionsForThisMethod::addAll); - - if (versionsForThisMethod.contains(currentVersionString)) { + if (versionsForThisMethod.contains(currentVersion)) { return ConditionEvaluationResult.enabled( - "Gradle version " + currentVersionString + " is in the allowed set for this method"); + "Gradle version " + currentVersion + " is in the allowed set for this method"); } - return ConditionEvaluationResult.disabled("Gradle version " + currentVersionString + return ConditionEvaluationResult.disabled("Gradle version " + currentVersion + " is not in the allowed set for this method: " + versionsForThisMethod); } } From dffa4f5cb0a621068a92aef3af78d97e2edaec35 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:30:17 +0000 Subject: [PATCH 16/26] tidy tests --- .../palantir/gradle/testing/ete/Assertions.java | 10 +++++----- .../testing/ete/WithGradleVersionsTest.java | 17 +++++++++++------ 2 files changed, 16 insertions(+), 11 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index b313558f..cbc792d3 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -48,11 +48,11 @@ public static void assertThatRanWithCorrectGradleVersion( }); assertThat(Path.of( - "build/gradle-plugin-testing", - testClass.getSimpleName(), - testName, - gradleVersion, - "build.gradle")) + "build/gradle-plugin-testing", + testClass.getSimpleName(), + testName, + gradleVersion, + "build.gradle")) .exists(); } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java index ad3dd547..29a2b16f 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java @@ -91,12 +91,9 @@ void method_level_with_gradle_versions_only_apply_to_annotated_method() { ranWithNameAndVersion("test with method annotation", "7.6.5"), ranWithNameAndVersion("test with method annotation", "8.0"), ranWithNameAndVersion("test with method annotation", "8.5")); + // Method without annotation is skipped for 8.5 (only runs on base + class versions) - assertThat(skipped).satisfiesExactly(event -> { - assertThat(event.getTestDescriptor().getDisplayName()).contains("test without method annotation"); - assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) - .hasValue("Gradle 8.5"); - }); + assertThat(skipped).satisfiesExactly(skippedWithNameAndVersion("test without method annotation", "8.5")); } private static Consumer ranWithGradleVersion(String gradleVersion) { @@ -104,11 +101,19 @@ private static Consumer ranWithGradleVersion(String gradleVersion) { WithGradleVersionsFixtureTest.class, event, gradleVersion); } - private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { + public static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( MethodLevelWithGradleVersionsFixtureTest.class, event, gradleVersion, displayNameContains); }; } + + public static Consumer skippedWithNameAndVersion(String displayNameContains, String gradleVersion) { + return event -> { + assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); + assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) + .hasValue("Gradle " + gradleVersion); + }; + } } From 184107dd8cc3921f86d6f2afdef2965261014e45 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:31:17 +0000 Subject: [PATCH 17/26] tidy --- .../com/palantir/gradle/testing/junit/GradleVersions.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java index 8a6b30cc..6066322d 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java @@ -30,12 +30,6 @@ /** * Utility class for Gradle versions based on annotations. - * - *

Provides two main methods: - *

    - *
  • {@link #allVersions} - all versions across class and methods
    • - *
  • {@link #versionsForMethod} - all versions for a specific method
    • - *
*/ final class GradleVersions { From 1963aab7847eb0815924fd56410ce7ac0838d77a Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:43:55 +0000 Subject: [PATCH 18/26] private not public --- .../palantir/gradle/testing/ete/WithGradleVersionsTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java index 29a2b16f..bb05e4a6 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java @@ -101,7 +101,7 @@ private static Consumer ranWithGradleVersion(String gradleVersion) { WithGradleVersionsFixtureTest.class, event, gradleVersion); } - public static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { + private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( @@ -109,7 +109,7 @@ public static Consumer ranWithNameAndVersion(String displayNameContains, }; } - public static Consumer skippedWithNameAndVersion(String displayNameContains, String gradleVersion) { + private static Consumer skippedWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); assertThat(event.getTestDescriptor().getParent().map(TestDescriptor::getDisplayName)) From e66a41e9f00b758dca67904f2d29e4c7a42bfb20 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:44:39 +0000 Subject: [PATCH 19/26] spotless --- .../com/palantir/gradle/testing/ete/Assertions.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java index cbc792d3..b313558f 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/Assertions.java @@ -48,11 +48,11 @@ public static void assertThatRanWithCorrectGradleVersion( }); assertThat(Path.of( - "build/gradle-plugin-testing", - testClass.getSimpleName(), - testName, - gradleVersion, - "build.gradle")) + "build/gradle-plugin-testing", + testClass.getSimpleName(), + testName, + gradleVersion, + "build.gradle")) .exists(); } From 19087ddaedfb2309c52e9cb427aa06fca9cc2bb8 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Tue, 6 Jan 2026 11:51:06 +0000 Subject: [PATCH 20/26] tidy --- .../gradle/testing/ete/WithOnlyGradleVersionsTest.java | 8 -------- 1 file changed, 8 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java index 38c3345d..371c8153 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java @@ -43,10 +43,6 @@ void with_only_gradle_versions_filters_to_specified_version() { List finished = executionResults.testEvents().finished().stream().toList(); List skipped = executionResults.testEvents().skipped().stream().toList(); - // test_without_only_annotation runs on both base versions (7.6.5, 8.0) - // test_with_only_annotation_filtering_to_existing_version runs only on 8.0 (filtered) - // test_with_only_annotation_filtering_to_nonexisting_version is skipped on both (8.5 not in matrix) - assertThat(finished) .satisfiesExactlyInAnyOrder( // test_without_only_annotation runs on both base versions @@ -60,8 +56,6 @@ void with_only_gradle_versions_filters_to_specified_version() { "test with only annotation filtering to existing version", "8.0")); - // test_with_only_annotation_filtering_to_existing_version is skipped on 7.6.5 - // test_with_only_annotation_filtering_to_nonexisting_version is skipped on both versions assertThat(skipped).hasSize(3); assertThat(skipped) .satisfiesExactlyInAnyOrder( @@ -85,14 +79,12 @@ void with_only_and_with_gradle_versions_combined_adds_then_filters() { List finished = executionResults.testEvents().finished().stream().toList(); List skipped = executionResults.testEvents().skipped().stream().toList(); - // @WithGradleVersions("8.5") adds 8.5 to matrix, @WithOnlyGradleVersions("8.5") filters to only 8.5 assertThat(finished) .satisfiesExactly(ranWithNameAndVersion( WithOnlyAndWithGradleVersionsFixtureTest.class, "test with both annotations adding and filtering", "8.5")); - // 7.6.5 and 8.0 are skipped because @WithOnlyGradleVersions filters them out assertThat(skipped).hasSize(2); assertThat(skipped) .satisfiesExactlyInAnyOrder( From b353b8120bfbf65f1942f801f628c64aa5747409 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Fri, 9 Jan 2026 09:38:10 +0000 Subject: [PATCH 21/26] WithSpecialCaseGradleVersions --- docs/testing-guide.md | 8 ++--- .../junit/GradleVersioningClassTemplate.java | 2 +- .../gradle/testing/junit/GradleVersions.java | 2 +- ...ava => WithSpecialCaseGradleVersions.java} | 2 +- ...thSpecialCaseGradleVersionsCondition.java} | 4 +-- ...=> WithSpecialCaseGradleVersionsTest.java} | 33 ++++++++++--------- ...SpecialCaseGradleVersionsFixtureTest.java} | 8 ++--- ...SpecialCaseGradleVersionsFixtureTest.java} | 6 ++-- 8 files changed, 34 insertions(+), 31 deletions(-) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{WithGradleVersions.java => WithSpecialCaseGradleVersions.java} (97%) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{WithGradleVersionsCondition.java => WithSpecialCaseGradleVersionsCondition.java} (91%) rename gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/{WithGradleVersionsTest.java => WithSpecialCaseGradleVersionsTest.java} (79%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{MethodLevelWithGradleVersionsFixtureTest.java => MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java} (89%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{WithGradleVersionsFixtureTest.java => WithSpecialCaseGradleVersionsFixtureTest.java} (88%) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index d89c9970..d6f50c5e 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -147,14 +147,14 @@ See [Resolution of Gradle versions to test against](../README.md#resolution-of-g #### Adding Versions for Specific Tests -Use `@WithGradleVersions` to add extra Gradle versions for a specific test class or individual test methods. +Use `@WithSpecialCaseGradleVersions` to add extra Gradle versions for a specific test class or individual test methods. > **Note:** This annotation is intended for exceptional cases where a specific test needs additional versions. > For configuring Gradle versions across your entire test suite, prefer setting versions in the `gradle/gradle-test-versions.yml` file. ```java @GradlePluginTests -@WithGradleVersions({"7.6.5", "8.0"}) +@WithSpecialCaseGradleVersions({"7.6.5", "8.0"}) class CompatibilityTest { @Test void works_on_older_gradle_versions(GradleInvoker gradle, RootProject project) { @@ -162,14 +162,14 @@ class CompatibilityTest { } @Test - @WithGradleVersions("8.5") + @WithSpecialCaseGradleVersions("8.5") void test_specific_version(GradleInvoker gradle, RootProject project) { // This test runs against globally configured versions PLUS 7.6.5, 8.0 (from class), and 8.5 (from method) } } ``` -The versions from `@WithGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. +The versions from `@WithSpecialCaseGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. ## File Operations diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 5dc2b37a..28b3d44d 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -51,7 +51,7 @@ public void prepareInvocation(ExtensionContext context) { @Override public List getAdditionalExtensions() { return List.of( - new WithGradleVersionsCondition(), + new WithSpecialCaseGradleVersionsCondition(), new GradleInvokerParameterResolver(), new GradleProjectParameterResolver(), new MavenRepoParameterResolver()); diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java index 6066322d..7a574b38 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java @@ -81,7 +81,7 @@ private static Set configuredVersions(ExtensionContext context) { } private static Set versionsFromAnnotation(AnnotatedElement element) { - return AnnotationSupport.findAnnotation(element, WithGradleVersions.class).stream() + return AnnotationSupport.findAnnotation(element, WithSpecialCaseGradleVersions.class).stream() .flatMap(annotation -> Arrays.stream(annotation.value())) .map(GradleVersion::new) .collect(Collectors.toCollection(LinkedHashSet::new)); diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java similarity index 97% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java index a6af2a65..e4c52743 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java @@ -33,7 +33,7 @@ */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) -public @interface WithGradleVersions { +public @interface WithSpecialCaseGradleVersions { /** * The additional Gradle versions to test against. diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java similarity index 91% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java index 7487bf48..0b95c278 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java @@ -25,11 +25,11 @@ /** * Execution condition that filters tests based on Gradle version. * - *

When a method has its own {@link WithGradleVersions} annotation, this condition ensures + *

When a method has its own {@link WithSpecialCaseGradleVersions} annotation, this condition ensures * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. */ -final class WithGradleVersionsCondition implements ExecutionCondition { +final class WithSpecialCaseGradleVersionsCondition implements ExecutionCondition { @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java similarity index 79% rename from gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java rename to gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java index bb05e4a6..523f9799 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java @@ -18,8 +18,8 @@ import static org.assertj.core.api.Assertions.assertThat; -import com.palantir.example.MethodLevelWithGradleVersionsFixtureTest; -import com.palantir.example.WithGradleVersionsFixtureTest; +import com.palantir.example.MethodLevelWithSpecialCaseGradleVersionsFixtureTest; +import com.palantir.example.WithSpecialCaseGradleVersionsFixtureTest; import java.util.List; import java.util.function.Consumer; import org.junit.jupiter.api.Test; @@ -29,11 +29,11 @@ import org.junit.platform.testkit.engine.EngineTestKit; import org.junit.platform.testkit.engine.Event; -final class WithGradleVersionsTest { +final class WithSpecialCaseGradleVersionsTest { @Test - void with_gradle_versions_annotation_adds_versions_to_test_matrix() { + void with_special_case_gradle_versions_annotation_adds_versions_to_test_matrix() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(WithSpecialCaseGradleVersionsFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -45,17 +45,17 @@ void with_gradle_versions_annotation_adds_versions_to_test_matrix() { .satisfiesExactlyInAnyOrder( // from config parameter ranWithGradleVersion("7.6.5"), - // from @WithGradleVersions + // from @WithSpecialCaseGradleVersions ranWithGradleVersion("8.0"), - // from @WithGradleVersions + // from @WithSpecialCaseGradleVersions ranWithGradleVersion("8.5")); } @Test void duplicate_versions_are_deduplicated() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithGradleVersionsFixtureTest.class)) - // 8.0 is both in config and in @WithGradleVersions + .selectors(DiscoverySelectors.selectClass(WithSpecialCaseGradleVersionsFixtureTest.class)) + // 8.0 is both in config and in @WithSpecialCaseGradleVersions .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -64,16 +64,16 @@ void duplicate_versions_are_deduplicated() { assertThat(finished) .satisfiesExactlyInAnyOrder( - // 8.0 is in both config and @WithGradleVersions, but only runs once + // 8.0 is in both config and @WithSpecialCaseGradleVersions, but only runs once ranWithGradleVersion("8.0"), - // from @WithGradleVersions + // from @WithSpecialCaseGradleVersions ranWithGradleVersion("8.5")); } @Test - void method_level_with_gradle_versions_only_apply_to_annotated_method() { + void method_level_with_special_case_gradle_versions_only_apply_to_annotated_method() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(MethodLevelWithGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(MethodLevelWithSpecialCaseGradleVersionsFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -98,14 +98,17 @@ void method_level_with_gradle_versions_only_apply_to_annotated_method() { private static Consumer ranWithGradleVersion(String gradleVersion) { return event -> Assertions.assertThatRanWithCorrectGradleVersion( - WithGradleVersionsFixtureTest.class, event, gradleVersion); + WithSpecialCaseGradleVersionsFixtureTest.class, event, gradleVersion); } private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( - MethodLevelWithGradleVersionsFixtureTest.class, event, gradleVersion, displayNameContains); + MethodLevelWithSpecialCaseGradleVersionsFixtureTest.class, + event, + gradleVersion, + displayNameContains); }; } diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java similarity index 89% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java index be03df24..40623f1a 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java @@ -18,13 +18,13 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithGradleVersions; +import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@WithGradleVersions("8.0") -public class MethodLevelWithGradleVersionsFixtureTest { +@WithSpecialCaseGradleVersions("8.0") +public class MethodLevelWithSpecialCaseGradleVersionsFixtureTest { @Test void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { @@ -39,7 +39,7 @@ void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject roo } @Test - @WithGradleVersions("8.5") + @WithSpecialCaseGradleVersions("8.5") void test_with_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java similarity index 88% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java index 599e939d..286670ab 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java @@ -18,13 +18,13 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithGradleVersions; +import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@WithGradleVersions({"8.0", "8.5"}) -public class WithGradleVersionsFixtureTest { +@WithSpecialCaseGradleVersions({"8.0", "8.5"}) +public class WithSpecialCaseGradleVersionsFixtureTest { @Test void test_name(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" From 96b012d2ad38bb8c104796df620452ef4c488385 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Fri, 9 Jan 2026 09:53:15 +0000 Subject: [PATCH 22/26] RestrictToGradleVersionsEqualTo --- docs/testing-guide.md | 18 ++--- .../gradle/testing/junit/GradleVersions.java | 16 +++-- ...a => RestrictToGradleVersionsEqualTo.java} | 12 ++-- ...ithSpecialCaseGradleVersionsCondition.java | 2 +- ... RestrictToGradleVersionsEqualToTest.java} | 65 ++++++++++--------- ...ctToGradleVersionsEqualToFixtureTest.java} | 12 ++-- ...SpecialCaseGradleVersionsFixtureTest.java} | 10 +-- ...ctToGradleVersionsEqualToFixtureTest.java} | 17 ++--- 8 files changed, 81 insertions(+), 71 deletions(-) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{WithOnlyGradleVersions.java => RestrictToGradleVersionsEqualTo.java} (77%) rename gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/{WithOnlyGradleVersionsTest.java => RestrictToGradleVersionsEqualToTest.java} (62%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{ClassLevelWithOnlyGradleVersionsFixtureTest.java => ClassLevelRestrictToGradleVersionsEqualToFixtureTest.java} (72%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.java => RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java} (77%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{WithOnlyGradleVersionsFixtureTest.java => RestrictToGradleVersionsEqualToFixtureTest.java} (76%) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index ea46e35c..7b66b239 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -171,21 +171,21 @@ class CompatibilityTest { The versions from `@WithSpecialCaseGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. -#### Filtering to Specific Versions +#### Restricting to Specific Versions -Use `@WithOnlyGradleVersions` to filter the test matrix to only run on specific Gradle versions. Unlike `@WithSpecialCaseGradleVersions` which adds versions, this annotation restricts which versions from the matrix will actually run. +Use `@RestrictToGradleVersionsEqualTo` to restrict the test matrix to only run on specific Gradle versions. Unlike `@WithSpecialCaseGradleVersions` which adds versions, this annotation restricts which versions from the matrix will actually run. ```java @GradlePluginTests -class FilteredVersionTest { +class RestrictedVersionTest { @Test - @WithOnlyGradleVersions(value = "8.14.3", reason = "This test only applies to Gradle 8.14.3") + @RestrictToGradleVersionsEqualTo(value = "8.14.3", reason = "This test only applies to Gradle 8.14.3") void test_only_on_specific_version(GradleInvoker gradle, RootProject project) { // This test only runs on 8.14.3, even if other versions are in the matrix } @Test - @WithOnlyGradleVersions({"8.10", "8.14.3"}) + @RestrictToGradleVersionsEqualTo({"8.10", "8.14.3"}) void test_on_subset_of_versions(GradleInvoker gradle, RootProject project) { // This test only runs on 8.10 and 8.14.3 } @@ -194,20 +194,20 @@ class FilteredVersionTest { **Key differences from `@WithSpecialCaseGradleVersions`:** - `@WithSpecialCaseGradleVersions` **adds** versions to the test matrix -- `@WithOnlyGradleVersions` **filters** the existing matrix to only include specified versions +- `@RestrictToGradleVersionsEqualTo` **restricts** the existing matrix to only include specified versions **Important:** If you specify a version that isn't in the test matrix, the test simply won't run for that version. To run a specific version that isn't in the matrix, use both annotations together: ```java @Test -@WithSpecialCaseGradleVersions("8.5") // Add 8.5 to the matrix -@WithOnlyGradleVersions("8.5") // Filter to only run 8.5 +@WithSpecialCaseGradleVersions("8.5") // Add 8.5 to the matrix +@RestrictToGradleVersionsEqualTo("8.5") // Restrict to only run 8.5 void test_only_on_8_5(GradleInvoker gradle, RootProject project) { // Runs exclusively on Gradle 8.5 } ``` -The annotation can be applied at the class level to filter all tests in the class, or at the method level for individual tests. Method-level filters are applied in addition to class-level filters. +The annotation can be applied at the class level to restrict all tests in the class, or at the method level for individual tests. Method-level restrictions are applied in addition to class-level restrictions. ## File Operations diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java index fafc2bc6..50772db5 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java @@ -37,7 +37,7 @@ final class GradleVersions { /** * Returns all Gradle versions for the test class, including versions from all methods, - * with the class-level {@link WithOnlyGradleVersions} filter applied. + * with the class-level {@link RestrictToGradleVersionsEqualTo} filter applied. * *

This is used to build the complete test matrix for the class. */ @@ -59,7 +59,7 @@ static Set allFilteredVersions(ExtensionContext context) { /** * Returns all Gradle versions for a specific method, including class-level versions, - * with the method-level {@link WithOnlyGradleVersions} filter applied. + * with the method-level {@link RestrictToGradleVersionsEqualTo} filter applied. * *

This is used to determine if a method should run for a given Gradle version. */ @@ -93,11 +93,13 @@ private static Set versionsFromAnnotation(AnnotatedElement elemen } private static void applyFilter(Set versions, AnnotatedElement element) { - AnnotationSupport.findAnnotation(element, WithOnlyGradleVersions.class).ifPresent(annotation -> { - Set allowed = - Arrays.stream(annotation.value()).map(GradleVersion::new).collect(Collectors.toSet()); - versions.retainAll(allowed); - }); + AnnotationSupport.findAnnotation(element, RestrictToGradleVersionsEqualTo.class) + .ifPresent(annotation -> { + Set allowed = Arrays.stream(annotation.value()) + .map(GradleVersion::new) + .collect(Collectors.toSet()); + versions.retainAll(allowed); + }); } private static boolean isTestMethod(Method method) { diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java similarity index 77% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java index 42b75c0f..4fa0f266 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithOnlyGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java @@ -22,28 +22,28 @@ import java.lang.annotation.Target; /** - * Annotation for filtering Gradle versions to only run the specified versions. + * Annotation for restricting Gradle versions to only run the specified versions. * *

Unlike {@link WithSpecialCaseGradleVersions} which adds versions to the test matrix, this annotation filters the * available versions to only include the specified ones. If a specified version is not in the test matrix * (from configuration or {@code @WithSpecialCaseGradleVersions}), it will simply not run. * *

To run a specific version that isn't in the matrix, use both annotations: - * {@code @WithSpecialCaseGradleVersions("8.5")} and {@code @WithOnlyGradleVersions("8.5")}. + * {@code @WithSpecialCaseGradleVersions("8.5")} and {@code @RestrictToGradleVersionsEqualTo("8.5")}. */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) -public @interface WithOnlyGradleVersions { +public @interface RestrictToGradleVersionsEqualTo { /** - * The Gradle versions to filter to. + * The Gradle versions to restrict to. * @return an array of Gradle version strings (e.g., "7.6.5", "8.0") */ String[] value(); /** - * Optional reason explaining why only these specific Gradle versions should run. - * @return the reason for filtering to these specific versions + * Optional reason explaining why this test is restricted to these specific Gradle versions. + * @return the reason for restricting to these specific versions */ String reason() default ""; } diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java index 59eed78a..711efaa1 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java @@ -29,7 +29,7 @@ * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. * - *

When a method has filter annotations like {@link WithOnlyGradleVersions}, the allowed versions + *

When a method has filter annotations like {@link RestrictToGradleVersionsEqualTo}, the allowed versions * are filtered accordingly. Class-level filter annotations are handled in {@link GradleVersioningClassTemplate} * to filter the test matrix upfront. */ diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java similarity index 62% rename from gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java rename to gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java index 27a122b2..ac488434 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithOnlyGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java @@ -18,9 +18,9 @@ import static org.assertj.core.api.Assertions.assertThat; -import com.palantir.example.ClassLevelWithOnlyGradleVersionsFixtureTest; -import com.palantir.example.WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest; -import com.palantir.example.WithOnlyGradleVersionsFixtureTest; +import com.palantir.example.ClassLevelRestrictToGradleVersionsEqualToFixtureTest; +import com.palantir.example.RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest; +import com.palantir.example.RestrictToGradleVersionsEqualToFixtureTest; import java.util.List; import java.util.function.Consumer; import org.junit.jupiter.api.Test; @@ -30,12 +30,12 @@ import org.junit.platform.testkit.engine.EngineTestKit; import org.junit.platform.testkit.engine.Event; -final class WithOnlyGradleVersionsTest { +final class RestrictToGradleVersionsEqualToTest { @Test - void with_only_gradle_versions_filters_to_specified_version() { + void restrict_to_gradle_versions_equal_to_filters_to_specified_version() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithOnlyGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(RestrictToGradleVersionsEqualToFixtureTest.class)) .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -45,33 +45,40 @@ void with_only_gradle_versions_filters_to_specified_version() { assertThat(finished) .satisfiesExactlyInAnyOrder( - // test_without_only_annotation runs on both base versions + // test_without_restrict_annotation runs on both base versions ranWithNameAndVersion( - WithOnlyGradleVersionsFixtureTest.class, "test without only annotation", "7.6.5"), + RestrictToGradleVersionsEqualToFixtureTest.class, + "test without restrict annotation", + "7.6.5"), ranWithNameAndVersion( - WithOnlyGradleVersionsFixtureTest.class, "test without only annotation", "8.0"), - // test_with_only_annotation_filtering_to_existing_version only runs on 8.0 + RestrictToGradleVersionsEqualToFixtureTest.class, + "test without restrict annotation", + "8.0"), + // test_with_restrict_annotation_filtering_to_existing_version only runs on 8.0 ranWithNameAndVersion( - WithOnlyGradleVersionsFixtureTest.class, - "test with only annotation filtering to existing version", + RestrictToGradleVersionsEqualToFixtureTest.class, + "test with restrict annotation filtering to existing version", "8.0")); assertThat(skipped).hasSize(3); assertThat(skipped) .satisfiesExactlyInAnyOrder( - // 7.6.5 skipped for "only 8.0" test - skippedWithNameAndVersion("test with only annotation filtering to existing version", "7.6.5"), - // 7.6.5 skipped for "only 8.5" test (nonexistent in matrix) + // 7.6.5 skipped for "restrict to 8.0" test skippedWithNameAndVersion( - "test with only annotation filtering to nonexisting version", "7.6.5"), - // 8.0 skipped for "only 8.5" test (nonexistent in matrix) - skippedWithNameAndVersion("test with only annotation filtering to nonexisting version", "8.0")); + "test with restrict annotation filtering to existing version", "7.6.5"), + // 7.6.5 skipped for "restrict to 8.5" test (nonexistent in matrix) + skippedWithNameAndVersion( + "test with restrict annotation filtering to nonexisting version", "7.6.5"), + // 8.0 skipped for "restrict to 8.5" test (nonexistent in matrix) + skippedWithNameAndVersion( + "test with restrict annotation filtering to nonexisting version", "8.0")); } @Test - void with_only_and_with_gradle_versions_combined_adds_then_filters() { + void restrict_to_equal_to_and_with_special_case_gradle_versions_combined_adds_then_filters() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass( + RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.class)) .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -81,21 +88,21 @@ void with_only_and_with_gradle_versions_combined_adds_then_filters() { assertThat(finished) .satisfiesExactly(ranWithNameAndVersion( - WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.class, - "test with both annotations adding and filtering", + RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.class, + "test with both annotations adding and restricting", "8.5")); assertThat(skipped).hasSize(2); assertThat(skipped) .satisfiesExactlyInAnyOrder( - skippedWithNameAndVersion("test with both annotations adding and filtering", "7.6.5"), - skippedWithNameAndVersion("test with both annotations adding and filtering", "8.0")); + skippedWithNameAndVersion("test with both annotations adding and restricting", "7.6.5"), + skippedWithNameAndVersion("test with both annotations adding and restricting", "8.0")); } @Test - void class_level_with_only_gradle_versions_filters_matrix_upfront() { + void class_level_restrict_to_gradle_versions_equal_to_filters_matrix_upfront() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(ClassLevelWithOnlyGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(ClassLevelRestrictToGradleVersionsEqualToFixtureTest.class)) .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -103,12 +110,12 @@ void class_level_with_only_gradle_versions_filters_matrix_upfront() { List finished = executionResults.testEvents().finished().stream().toList(); List skipped = executionResults.testEvents().skipped().stream().toList(); - // Class-level @WithOnlyGradleVersions("8.0") filters matrix to only 8.0 + // Class-level @RestrictToGradleVersionsEqualTo("8.0") filters matrix to only 8.0 // No tests should be skipped - 7.6.5 is not even in the matrix assertThat(finished) .satisfiesExactly(ranWithNameAndVersion( - ClassLevelWithOnlyGradleVersionsFixtureTest.class, - "test runs only on filtered version", + ClassLevelRestrictToGradleVersionsEqualToFixtureTest.class, + "test runs only on restricted version", "8.0")); assertThat(skipped).isEmpty(); diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelRestrictToGradleVersionsEqualToFixtureTest.java similarity index 72% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelRestrictToGradleVersionsEqualToFixtureTest.java index 74a0bdd3..b7c534ad 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelWithOnlyGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/ClassLevelRestrictToGradleVersionsEqualToFixtureTest.java @@ -18,20 +18,20 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.junit.RestrictToGradleVersionsEqualTo; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; /** - * Test fixture for testing class-level {@link WithOnlyGradleVersions} annotation behavior. - * When applied at class level, the annotation filters the test matrix upfront. + * Test fixture for testing class-level {@link RestrictToGradleVersionsEqualTo} annotation behavior. + * When applied at class level, the annotation restricts the test matrix upfront. */ @GradlePluginTests -@WithOnlyGradleVersions("8.0") -public class ClassLevelWithOnlyGradleVersionsFixtureTest { +@RestrictToGradleVersionsEqualTo("8.0") +public class ClassLevelRestrictToGradleVersionsEqualToFixtureTest { @Test - void test_runs_only_on_filtered_version(GradleInvoker gradleInvoker, RootProject rootProject) { + void test_runs_only_on_restricted_version(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion println "GradleVersion: ${GradleVersion.current().version}" diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java similarity index 77% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java index 9e8e0fe6..d351310e 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java @@ -18,23 +18,23 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.junit.RestrictToGradleVersionsEqualTo; import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; /** - * Test fixture for testing {@link WithOnlyGradleVersions} combined with {@link WithSpecialCaseGradleVersions}. + * Test fixture for testing {@link RestrictToGradleVersionsEqualTo} combined with {@link WithSpecialCaseGradleVersions}. * This is in a separate fixture so that the {@link WithSpecialCaseGradleVersions} doesn't affect the test matrix of * other tests. */ @GradlePluginTests -public class WithOnlyAndWithSpecialCaseGradleVersionsFixtureTest { +public class RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest { @Test @WithSpecialCaseGradleVersions("8.5") - @WithOnlyGradleVersions("8.5") - void test_with_both_annotations_adding_and_filtering(GradleInvoker gradleInvoker, RootProject rootProject) { + @RestrictToGradleVersionsEqualTo("8.5") + void test_with_both_annotations_adding_and_restricting(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion println "GradleVersion: ${GradleVersion.current().version}" diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToGradleVersionsEqualToFixtureTest.java similarity index 76% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToGradleVersionsEqualToFixtureTest.java index 7369cb7f..1c3c5126 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithOnlyGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToGradleVersionsEqualToFixtureTest.java @@ -18,19 +18,19 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithOnlyGradleVersions; +import com.palantir.gradle.testing.junit.RestrictToGradleVersionsEqualTo; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; /** - * Test fixture for testing {@link WithOnlyGradleVersions} annotation behavior. + * Test fixture for testing {@link RestrictToGradleVersionsEqualTo} annotation behavior. * This fixture is designed to be run with base versions 7.6.5 and 8.0 via configuration parameter. */ @GradlePluginTests -public class WithOnlyGradleVersionsFixtureTest { +public class RestrictToGradleVersionsEqualToFixtureTest { @Test - void test_without_only_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { + void test_without_restrict_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion println "GradleVersion: ${GradleVersion.current().version}" @@ -41,8 +41,9 @@ void test_without_only_annotation(GradleInvoker gradleInvoker, RootProject rootP } @Test - @WithOnlyGradleVersions("8.0") - void test_with_only_annotation_filtering_to_existing_version(GradleInvoker gradleInvoker, RootProject rootProject) { + @RestrictToGradleVersionsEqualTo("8.0") + void test_with_restrict_annotation_filtering_to_existing_version( + GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion println "GradleVersion: ${GradleVersion.current().version}" @@ -52,8 +53,8 @@ void test_with_only_annotation_filtering_to_existing_version(GradleInvoker gradl } @Test - @WithOnlyGradleVersions("8.5") - void test_with_only_annotation_filtering_to_nonexisting_version( + @RestrictToGradleVersionsEqualTo("8.5") + void test_with_restrict_annotation_filtering_to_nonexisting_version( GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion From 0e9e9152e736be81d58899092a8f5388194c1ca4 Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 12 Jan 2026 08:41:23 +0000 Subject: [PATCH 23/26] change name --- docs/testing-guide.md | 8 ++--- ...ns.java => AdditionallyRunWithGradle.java} | 2 +- ...> AdditionallyRunWithGradleCondition.java} | 4 +-- .../junit/GradleVersioningClassTemplate.java | 2 +- .../gradle/testing/junit/GradleVersions.java | 2 +- ...ava => AdditionallyRunWithGradleTest.java} | 30 +++++++++---------- ...AdditionallyRunWithGradleFixtureTest.java} | 6 ++-- ...AdditionallyRunWithGradleFixtureTest.java} | 8 ++--- 8 files changed, 31 insertions(+), 31 deletions(-) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{WithSpecialCaseGradleVersions.java => AdditionallyRunWithGradle.java} (97%) rename gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/{WithSpecialCaseGradleVersionsCondition.java => AdditionallyRunWithGradleCondition.java} (91%) rename gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/{WithSpecialCaseGradleVersionsTest.java => AdditionallyRunWithGradleTest.java} (81%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{WithSpecialCaseGradleVersionsFixtureTest.java => AdditionallyRunWithGradleFixtureTest.java} (88%) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java => MethodLevelAdditionallyRunWithGradleFixtureTest.java} (89%) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index d6f50c5e..d0eead58 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -147,14 +147,14 @@ See [Resolution of Gradle versions to test against](../README.md#resolution-of-g #### Adding Versions for Specific Tests -Use `@WithSpecialCaseGradleVersions` to add extra Gradle versions for a specific test class or individual test methods. +Use `@AdditionallyRunWithGradle` to add extra Gradle versions for a specific test class or individual test methods. > **Note:** This annotation is intended for exceptional cases where a specific test needs additional versions. > For configuring Gradle versions across your entire test suite, prefer setting versions in the `gradle/gradle-test-versions.yml` file. ```java @GradlePluginTests -@WithSpecialCaseGradleVersions({"7.6.5", "8.0"}) +@AdditionallyRunWithGradle({"7.6.5", "8.0"}) class CompatibilityTest { @Test void works_on_older_gradle_versions(GradleInvoker gradle, RootProject project) { @@ -162,14 +162,14 @@ class CompatibilityTest { } @Test - @WithSpecialCaseGradleVersions("8.5") + @AdditionallyRunWithGradle("8.5") void test_specific_version(GradleInvoker gradle, RootProject project) { // This test runs against globally configured versions PLUS 7.6.5, 8.0 (from class), and 8.5 (from method) } } ``` -The versions from `@WithSpecialCaseGradleVersions` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. +The versions from `@AdditionallyRunWithGradle` are merged with the globally configured versions. When applied to both a class and a method, all versions are combined. Duplicate versions are automatically deduplicated. ## File Operations diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradle.java similarity index 97% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradle.java index e4c52743..905a657c 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradle.java @@ -33,7 +33,7 @@ */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) -public @interface WithSpecialCaseGradleVersions { +public @interface AdditionallyRunWithGradle { /** * The additional Gradle versions to test against. diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradleCondition.java similarity index 91% rename from gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java rename to gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradleCondition.java index 0b95c278..87dc26ec 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/WithSpecialCaseGradleVersionsCondition.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/AdditionallyRunWithGradleCondition.java @@ -25,11 +25,11 @@ /** * Execution condition that filters tests based on Gradle version. * - *

When a method has its own {@link WithSpecialCaseGradleVersions} annotation, this condition ensures + *

When a method has its own {@link AdditionallyRunWithGradle} annotation, this condition ensures * that only the method-specific versions (plus base and class-level versions) run for that method. * For methods without the annotation, only base and class-level versions run. */ -final class WithSpecialCaseGradleVersionsCondition implements ExecutionCondition { +final class AdditionallyRunWithGradleCondition implements ExecutionCondition { @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java index 28b3d44d..6f53c927 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersioningClassTemplate.java @@ -51,7 +51,7 @@ public void prepareInvocation(ExtensionContext context) { @Override public List getAdditionalExtensions() { return List.of( - new WithSpecialCaseGradleVersionsCondition(), + new AdditionallyRunWithGradleCondition(), new GradleInvokerParameterResolver(), new GradleProjectParameterResolver(), new MavenRepoParameterResolver()); diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java index 7a574b38..7b606b33 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/GradleVersions.java @@ -81,7 +81,7 @@ private static Set configuredVersions(ExtensionContext context) { } private static Set versionsFromAnnotation(AnnotatedElement element) { - return AnnotationSupport.findAnnotation(element, WithSpecialCaseGradleVersions.class).stream() + return AnnotationSupport.findAnnotation(element, AdditionallyRunWithGradle.class).stream() .flatMap(annotation -> Arrays.stream(annotation.value())) .map(GradleVersion::new) .collect(Collectors.toCollection(LinkedHashSet::new)); diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java similarity index 81% rename from gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java rename to gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java index 523f9799..7c2d1db3 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/WithSpecialCaseGradleVersionsTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java @@ -18,8 +18,8 @@ import static org.assertj.core.api.Assertions.assertThat; -import com.palantir.example.MethodLevelWithSpecialCaseGradleVersionsFixtureTest; -import com.palantir.example.WithSpecialCaseGradleVersionsFixtureTest; +import com.palantir.example.AdditionallyRunWithGradleFixtureTest; +import com.palantir.example.MethodLevelAdditionallyRunWithGradleFixtureTest; import java.util.List; import java.util.function.Consumer; import org.junit.jupiter.api.Test; @@ -29,11 +29,11 @@ import org.junit.platform.testkit.engine.EngineTestKit; import org.junit.platform.testkit.engine.Event; -final class WithSpecialCaseGradleVersionsTest { +final class AdditionallyRunWithGradleTest { @Test - void with_special_case_gradle_versions_annotation_adds_versions_to_test_matrix() { + void additionally_run_with_gradle_annotation_adds_versions_to_test_matrix() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithSpecialCaseGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(AdditionallyRunWithGradleFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -45,17 +45,17 @@ void with_special_case_gradle_versions_annotation_adds_versions_to_test_matrix() .satisfiesExactlyInAnyOrder( // from config parameter ranWithGradleVersion("7.6.5"), - // from @WithSpecialCaseGradleVersions + // from @AdditionallyRunWithGradle ranWithGradleVersion("8.0"), - // from @WithSpecialCaseGradleVersions + // from @AdditionallyRunWithGradle ranWithGradleVersion("8.5")); } @Test void duplicate_versions_are_deduplicated() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(WithSpecialCaseGradleVersionsFixtureTest.class)) - // 8.0 is both in config and in @WithSpecialCaseGradleVersions + .selectors(DiscoverySelectors.selectClass(AdditionallyRunWithGradleFixtureTest.class)) + // 8.0 is both in config and in @AdditionallyRunWithGradle .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -64,16 +64,16 @@ void duplicate_versions_are_deduplicated() { assertThat(finished) .satisfiesExactlyInAnyOrder( - // 8.0 is in both config and @WithSpecialCaseGradleVersions, but only runs once + // 8.0 is in both config and @AdditionallyRunWithGradle, but only runs once ranWithGradleVersion("8.0"), - // from @WithSpecialCaseGradleVersions + // from @AdditionallyRunWithGradle ranWithGradleVersion("8.5")); } @Test - void method_level_with_special_case_gradle_versions_only_apply_to_annotated_method() { + void method_level_additionally_run_with_gradle_only_apply_to_annotated_method() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass(MethodLevelWithSpecialCaseGradleVersionsFixtureTest.class)) + .selectors(DiscoverySelectors.selectClass(MethodLevelAdditionallyRunWithGradleFixtureTest.class)) // Base version configured via parameter .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") @@ -98,14 +98,14 @@ void method_level_with_special_case_gradle_versions_only_apply_to_annotated_meth private static Consumer ranWithGradleVersion(String gradleVersion) { return event -> Assertions.assertThatRanWithCorrectGradleVersion( - WithSpecialCaseGradleVersionsFixtureTest.class, event, gradleVersion); + AdditionallyRunWithGradleFixtureTest.class, event, gradleVersion); } private static Consumer ranWithNameAndVersion(String displayNameContains, String gradleVersion) { return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( - MethodLevelWithSpecialCaseGradleVersionsFixtureTest.class, + MethodLevelAdditionallyRunWithGradleFixtureTest.class, event, gradleVersion, displayNameContains); diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java similarity index 88% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java index 286670ab..0b79aa97 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/WithSpecialCaseGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java @@ -18,13 +18,13 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; +import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@WithSpecialCaseGradleVersions({"8.0", "8.5"}) -public class WithSpecialCaseGradleVersionsFixtureTest { +@AdditionallyRunWithGradle({"8.0", "8.5"}) +public class AdditionallyRunWithGradleFixtureTest { @Test void test_name(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java similarity index 89% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java index 40623f1a..8f38115a 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelWithSpecialCaseGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java @@ -18,13 +18,13 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; -import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; +import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; @GradlePluginTests -@WithSpecialCaseGradleVersions("8.0") -public class MethodLevelWithSpecialCaseGradleVersionsFixtureTest { +@AdditionallyRunWithGradle("8.0") +public class MethodLevelAdditionallyRunWithGradleFixtureTest { @Test void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { @@ -39,7 +39,7 @@ void test_without_method_annotation(GradleInvoker gradleInvoker, RootProject roo } @Test - @WithSpecialCaseGradleVersions("8.5") + @AdditionallyRunWithGradle("8.5") void test_with_method_annotation(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" import org.gradle.util.GradleVersion From 01b87bd06618a5115d3e903e2bb9fdf0cda4571f Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 12 Jan 2026 08:46:19 +0000 Subject: [PATCH 24/26] change name --- docs/testing-guide.md | 8 ++++---- .../testing/junit/RestrictToGradleVersionsEqualTo.java | 6 +++--- .../ete/RestrictToGradleVersionsEqualToTest.java | 8 ++++---- ...qualToAndAdditionallyRunWithGradleFixtureTest.java} | 10 +++++----- 4 files changed, 16 insertions(+), 16 deletions(-) rename gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/{RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java => RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java} (80%) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index 8c54f287..387021c1 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -173,7 +173,7 @@ The versions from `@AdditionallyRunWithGradle` are merged with the globally conf #### Restricting to Specific Versions -Use `@RestrictToGradleVersionsEqualTo` to restrict the test matrix to only run on specific Gradle versions. Unlike `@WithSpecialCaseGradleVersions` which adds versions, this annotation restricts which versions from the matrix will actually run. +Use `@RestrictToGradleVersionsEqualTo` to restrict the test matrix to only run on specific Gradle versions. Unlike `@AdditionallyRunWithGradle` which adds versions, this annotation restricts which versions from the matrix will actually run. ```java @GradlePluginTests @@ -192,15 +192,15 @@ class RestrictedVersionTest { } ``` -**Key differences from `@WithSpecialCaseGradleVersions`:** -- `@WithSpecialCaseGradleVersions` **adds** versions to the test matrix +**Key differences from `@AdditionallyRunWithGradle`:** +- `@AdditionallyRunWithGradle` **adds** versions to the test matrix - `@RestrictToGradleVersionsEqualTo` **restricts** the existing matrix to only include specified versions **Important:** If you specify a version that isn't in the test matrix, the test simply won't run for that version. To run a specific version that isn't in the matrix, use both annotations together: ```java @Test -@WithSpecialCaseGradleVersions("8.5") // Add 8.5 to the matrix +@AdditionallyRunWithGradle("8.5") // Add 8.5 to the matrix @RestrictToGradleVersionsEqualTo("8.5") // Restrict to only run 8.5 void test_only_on_8_5(GradleInvoker gradle, RootProject project) { // Runs exclusively on Gradle 8.5 diff --git a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java index 4fa0f266..8262e388 100644 --- a/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java +++ b/gradle-plugin-testing-junit/src/main/java/com/palantir/gradle/testing/junit/RestrictToGradleVersionsEqualTo.java @@ -24,12 +24,12 @@ /** * Annotation for restricting Gradle versions to only run the specified versions. * - *

Unlike {@link WithSpecialCaseGradleVersions} which adds versions to the test matrix, this annotation filters the + *

Unlike {@link AdditionallyRunWithGradle} which adds versions to the test matrix, this annotation filters the * available versions to only include the specified ones. If a specified version is not in the test matrix - * (from configuration or {@code @WithSpecialCaseGradleVersions}), it will simply not run. + * (from configuration or {@code @AdditionallyRunWithGradle}), it will simply not run. * *

To run a specific version that isn't in the matrix, use both annotations: - * {@code @WithSpecialCaseGradleVersions("8.5")} and {@code @RestrictToGradleVersionsEqualTo("8.5")}. + * {@code @AdditionallyRunWithGradle("8.5")} and {@code @RestrictToGradleVersionsEqualTo("8.5")}. */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java index ac488434..6889cc35 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java @@ -19,7 +19,7 @@ import static org.assertj.core.api.Assertions.assertThat; import com.palantir.example.ClassLevelRestrictToGradleVersionsEqualToFixtureTest; -import com.palantir.example.RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest; +import com.palantir.example.RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest; import com.palantir.example.RestrictToGradleVersionsEqualToFixtureTest; import java.util.List; import java.util.function.Consumer; @@ -75,10 +75,10 @@ void restrict_to_gradle_versions_equal_to_filters_to_specified_version() { } @Test - void restrict_to_equal_to_and_with_special_case_gradle_versions_combined_adds_then_filters() { + void restrict_to_equal_to_and_additionally_run_with_gradle_combined_adds_then_filters() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") .selectors(DiscoverySelectors.selectClass( - RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.class)) + RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.class)) .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); @@ -88,7 +88,7 @@ void restrict_to_equal_to_and_with_special_case_gradle_versions_combined_adds_th assertThat(finished) .satisfiesExactly(ranWithNameAndVersion( - RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.class, + RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.class, "test with both annotations adding and restricting", "8.5")); diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java similarity index 80% rename from gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java rename to gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java index d351310e..53dd6772 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java @@ -19,20 +19,20 @@ import com.palantir.gradle.testing.execution.GradleInvoker; import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.junit.RestrictToGradleVersionsEqualTo; -import com.palantir.gradle.testing.junit.WithSpecialCaseGradleVersions; +import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; /** - * Test fixture for testing {@link RestrictToGradleVersionsEqualTo} combined with {@link WithSpecialCaseGradleVersions}. - * This is in a separate fixture so that the {@link WithSpecialCaseGradleVersions} doesn't affect the test matrix of + * Test fixture for testing {@link RestrictToGradleVersionsEqualTo} combined with {@link AdditionallyRunWithGradle}. + * This is in a separate fixture so that the {@link AdditionallyRunWithGradle} doesn't affect the test matrix of * other tests. */ @GradlePluginTests -public class RestrictToEqualToAndWithSpecialCaseGradleVersionsFixtureTest { +public class RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest { @Test - @WithSpecialCaseGradleVersions("8.5") + @AdditionallyRunWithGradle("8.5") @RestrictToGradleVersionsEqualTo("8.5") void test_with_both_annotations_adding_and_restricting(GradleInvoker gradleInvoker, RootProject rootProject) { rootProject.buildGradle().append(""" From 7e9985a987096fe2af4442eb051c1a717dc7a4fa Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 12 Jan 2026 14:56:37 +0000 Subject: [PATCH 25/26] format --- .../gradle/testing/ete/AdditionallyRunWithGradleTest.java | 5 +---- .../testing/ete/RestrictToGradleVersionsEqualToTest.java | 4 ++-- .../example/AdditionallyRunWithGradleFixtureTest.java | 2 +- .../MethodLevelAdditionallyRunWithGradleFixtureTest.java | 2 +- ...rictToEqualToAndAdditionallyRunWithGradleFixtureTest.java | 2 +- 5 files changed, 6 insertions(+), 9 deletions(-) diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java index 7c2d1db3..e287ff10 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/AdditionallyRunWithGradleTest.java @@ -105,10 +105,7 @@ private static Consumer ranWithNameAndVersion(String displayNameContains, return event -> { assertThat(event.getTestDescriptor().getDisplayName()).contains(displayNameContains); Assertions.assertThatRanWithCorrectGradleVersion( - MethodLevelAdditionallyRunWithGradleFixtureTest.class, - event, - gradleVersion, - displayNameContains); + MethodLevelAdditionallyRunWithGradleFixtureTest.class, event, gradleVersion, displayNameContains); }; } diff --git a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java index 6889cc35..5a22a803 100644 --- a/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java +++ b/gradle-plugin-testing-junit/src/test/java/com/palantir/gradle/testing/ete/RestrictToGradleVersionsEqualToTest.java @@ -77,8 +77,8 @@ void restrict_to_gradle_versions_equal_to_filters_to_specified_version() { @Test void restrict_to_equal_to_and_additionally_run_with_gradle_combined_adds_then_filters() { EngineExecutionResults executionResults = EngineTestKit.engine("junit-jupiter") - .selectors(DiscoverySelectors.selectClass( - RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.class)) + .selectors( + DiscoverySelectors.selectClass(RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.class)) .configurationParameter("com.palantir.gradle.testing.gradle_versions_to_test", "7.6.5,8.0") .configurationParameter("com.palantir.gradle.testing.configuration_cache_enabled", "false") .execute(); diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java index 0b79aa97..39b2e0f7 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/AdditionallyRunWithGradleFixtureTest.java @@ -17,8 +17,8 @@ package com.palantir.example; import com.palantir.gradle.testing.execution.GradleInvoker; -import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; +import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java index 8f38115a..699dea61 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/MethodLevelAdditionallyRunWithGradleFixtureTest.java @@ -17,8 +17,8 @@ package com.palantir.example; import com.palantir.gradle.testing.execution.GradleInvoker; -import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; +import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; diff --git a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java index 53dd6772..03675f68 100644 --- a/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java +++ b/gradle-plugin-testing-junit/src/testFixtures/java/com/palantir/example/RestrictToEqualToAndAdditionallyRunWithGradleFixtureTest.java @@ -17,9 +17,9 @@ package com.palantir.example; import com.palantir.gradle.testing.execution.GradleInvoker; +import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; import com.palantir.gradle.testing.junit.GradlePluginTests; import com.palantir.gradle.testing.junit.RestrictToGradleVersionsEqualTo; -import com.palantir.gradle.testing.junit.AdditionallyRunWithGradle; import com.palantir.gradle.testing.project.RootProject; import org.junit.jupiter.api.Test; From 08adc6d1a02f8ff385747c126e4b7a2e83c1f7ee Mon Sep 17 00:00:00 2001 From: Finlay Williams Date: Mon, 12 Jan 2026 15:43:28 +0000 Subject: [PATCH 26/26] undo incorrect change --- docs/testing-guide.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/testing-guide.md b/docs/testing-guide.md index 387021c1..ae11fce7 100644 --- a/docs/testing-guide.md +++ b/docs/testing-guide.md @@ -619,14 +619,14 @@ For tests or test classes that are incompatible with configuration cache, use th ```java // Disable configuration cache for a specific test method @Test -@DisabledConfigurationCache(reason="task abc is incompatible with configuration cache") +@DisabledConfigurationCache("task abc is incompatible with configuration cache") void incompatible_configuration_cache_build(GradleInvoker gradle, RootProject project) { ``` Or ```java // Disable for an entire test class @GradlePluginTests -@DisabledConfigurationCache(reason="tasks abc, xyz are incompatible with configuration cache") +@DisabledConfigurationCache("tasks abc, xyz are incompatible with configuration cache") class PluginIncompatibleWithConfigCache { ```