}

    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "Usage with Configuration Cache is tested separately, because not all versions are supported")
    def "can use plugin #version"() {
        given:
        def versionNumber = VersionNumber.parse(version)

        when:
        usePluginVersion version

        then:

                    "The Provider.forUseAtConfigurationTime method has been deprecated. " +
                        "This is scheduled to be removed in Gradle 9.0. " +
                        "Simply remove the call. " +
                        "Consult the upgrading guide for further information: " +
                        "https://docs.gradle.org/current/userguide/upgrading_version_7.html#for_use_at_configuration_time_deprecation")

            return input.isPrimitive();
        }
    };

    static <T> DescribedPredicate<Collection<T>> thatAll(DescribedPredicate<T> predicate) {
        return new DescribedPredicate<Collection<T>>("that all %s", predicate.getDescription()) {
            @Override
            public boolean test(Collection<T> input) {
                return input.stream().allMatch(predicate);
            }
        };
    }

        return getCompileBuildFileOperationsCount(buildOperations)
    }

    int getCompileBuildFileOperationsCount(BuildOperationTreeQueries buildOperations) {
        return buildOperations.all(CompileScriptBuildOperationType).size()
    }

    DaemonsFixture getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

    void hasScript(String path, List<ClassDetails> scripts) {

        return useIncubatingAPIs;
    }

    /**
     * Java version to be used by generated Java projects.
     *
     * When set, Gradle will use the provided value as the target major Java version
     * for all relevant generated projects.  Gradle will validate the number to ensure
     * it is a valid and supported major version.
     *
     * @return the java version number supplied by the user
     * @since 8.5
     */

    }

    public void transform(Transformer t) {
        logger.lifecycle("transform(Transformer)")
    }
}

task print(type: MyTask) {
    transform(Impl) // should call transform(Class)
}
        """

        expect:
        succeeds("print")
        outputContains("transform(Class)")
    }

    def failsWhenTryingToCallMethodWithClassValue() {

     * If the callable returns null, then the returned Try instance will hold null as its value.
     */
    public static <U> Try<U> ofFailable(Callable<U> failable) {
        try {
            return Try.successful(failable.call());
        } catch (Exception e) {
            return Try.failure(e);
        }
    }

    /**
     * Construct a {@code Try} representing a successful execution.

If the `--overwrite` option is provided, Gradle will overwrite any existing files in the directory where the `init` task runs. By default, `init` will prompt the user to continue if Gradle finds any files in the directory.

All build types also set up <<gradle_wrapper.adoc#gradle_wrapper_reference, Gradle Wrapper>> in the build.

[[sec:build_init_types]]
== Build init types


[[sec:pom_maven_conversion]]

import spock.lang.Issue

import java.nio.file.Paths

import static org.gradle.api.internal.DocumentationRegistry.BASE_URL
import static org.gradle.api.internal.DocumentationRegistry.RECOMMENDATION

// TODO: Move all of these tests to AbstractJavaCompilerIntegrationSpec
// so that we can verify them for forking, in-process, and cli compilers.
class JavaCompileIntegrationTest extends AbstractIntegrationSpec {

    @Rule

* For new features, the feature should be mentioned in the [Release Notes](platforms/documentation/docs/src/docs/release/notes.md).

Your code needs to run on [all versions of Java that Gradle supports](platforms/documentation/docs/src/docs/userguide/releases/compatibility.adoc) and across all supported operating systems (macOS, Windows, Linux). The [Gradle CI system](http://builds.gradle.org/) will verify this, but here are some pointers that will avoid surprises: