def "options can be set with framework before java plugin is applied"() {
        given:
        settingsFile << "rootProject.name = 'Sample'"
        buildFile.text = """
            tasks.withType(Test).configureEach {
                useJUnitPlatform() {
                    excludeTags = ["Slow"]
                }
                doFirst {
                    assert options.excludeTags.contains("Slow")
                }

| Use `withType().configureEach()` instead.

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#all-org.gradle.api.Action-[DomainObjectCollection.all()]
| Use `configureEach()` instead.

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#whenObjectAdded-org.gradle.api.Action-[DomainObjectCollection.whenObjectAdded()]
| Use `configureEach()` instead.

        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }

    tasks.withType<JavaCompile>().configureEach {
        configureCompileTask(options)
        options.compilerArgs.add("-parameters")
    }
    tasks.withType<GroovyCompile>().configureEach {
        groovyOptions.encoding = "utf-8"
        sourceCompatibility = "1.8"
        targetCompatibility = "1.8"

                    usingSourceSet(gradle7)
                    capability(project.group.toString(), project.name, project.version.toString())
                }
            }
            configurations.configureEach {
                if (canBeConsumed && name.startsWith(gradle7.name))  {
                    attributes {

        configureGroovydoc(project, groovyRuntime);
    }

    private void configureCompileDefaults(Project project, GroovyRuntime groovyRuntime) {
        project.getTasks().withType(GroovyCompile.class).configureEach(compile -> {
            compile.getConventionMapping().map(
                "groovyClasspath",
                () -> groovyRuntime.inferGroovyClasspath(compile.getClasspath())
            );

        executedAndNotSkipped ":appVisualStudioSolution"
        executedAndNotSkipped getComponentTasks("app")

        when:
        buildFile << """
            application {
                binaries.configureEach { binary ->
                    binary.compileTask.get().macros["FOO"] = null
                }
            }
        """
        run "visualStudio"

        then:

            public class SomeOtherPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().withType(SomeTask.class).configureEach(t -> {
                        t.getFlag().set(false);
                        t.getMessage().set("some other value");
                        t.getNumber().set(1.23);

        project.getTasks().withType(Jar.class).configureEach(task -> task.getDestinationDirectory().convention(basePluginExtension.getLibsDirectory()));
    }

    private void configureTest(final Project project, final JavaPluginExtension javaPluginExtension) {
        project.getTasks().withType(Test.class).configureEach(test -> configureTestDefaults(test, project, javaPluginExtension));
    }

        succeeds("test", "verifyTestOptions", "--warn")
    }

    def "setForkEvery null emits deprecation warning"() {
        given:
        buildFile << """
            tasks.withType(Test).configureEach {
                forkEvery = null
            }
        """

        when:
        executer.expectDocumentedDeprecationWarning("Setting Test.forkEvery to null. This behavior has been deprecated. " +

        given:
        componentUnderTest.writeToProject(testDirectory)
        makeSingleProject()
        buildFile << """
            ${componentUnderTestDsl}.binaries.configureEach {
                compileTask.get().compilerArgs.add('${compilerFlag}')
            }
        """

        when:
        succeeds "visualStudio"

        then: