}
        """
        file("src/main/scala/Foo.scala") << """
            class Foo
        """
        expect:
        succeeds("assemble")
        succeeds("dependencyInsight", "--configuration", "zinc", "--dependency", "zinc")
    }

    @Issue("gradle/gradle#19300")
    def 'show that log4j-core, if present, is 2_17_1 at the minimum'() {
        given:

        and:
        buildFile << """
            apply plugin: 'cpp-application'
         """

        and:
        succeeds "assemble"
        app.applyChangesToProject(testDirectory)

        expect:
        succeeds "assemble"
        result.assertTasksExecuted(tasks.debug.allToInstall, ":assemble")
        result.assertTasksNotSkipped(tasks.debug.allToInstall, ":assemble")

            'org:testA:3' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDeps'
        outputContains("Listing versions for module testA")
        resetExpectations()

        when:
        succeeds 'checkDeps'

        then:
        outputDoesNotContain("Listing versions for module testA")
        resetExpectations()

        when:

        expect:
        succeeds(task)
        executedAndNotSkipped(task)

        and:
        succeeds(task)
        skipped(task)
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @ToBeFixedForConfigurationCache
    def "task not up to date when enabled set changes"() {
        expect:
        succeeds(task)
        executedAndNotSkipped(task)

        when:

            }
            project(':b') {
                dependencies {
                    compile project(':a')
                }
            }
        """

        expect:
        succeeds "b:checkDeps"
        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: 'foo', type: '')

    def setup() {
        buildFile << """
        plugins {
            id 'project-report'
        }
        """
    }

    def "produces report files"() {
        when:
        succeeds("projectReport")

        then:
        file("build/reports/project/dependencies.txt").assertExists()
        file("build/reports/project/properties.txt").assertExists()

    def "test succeeds if a test was executed"() {
        createBuildFileWithJUnitJupiter()

        file("src/test/java/SomeTest.java") << """
            public class SomeTest {
                @org.junit.jupiter.api.Test
                public void foo() { }
            }
        """

        expect:
        succeeds("test")
    }

            plugins {
                alias(libs.plugins.orgExample)
            }
        """

        when:
        succeeds(":pluginTask")

        then:
        output.contains("from plugin")

        when:
        succeeds(":subproject:pluginTask")

        then:
        output.contains("from plugin")
    }

                apply plugin: 'swift-library'
            }
        """
        app.library.writeToProject(file("greeter"))
        app.executable.writeToProject(file("app"))

        expect:
        succeeds ":app:assemble"
        result.assertTasksExecuted(":greeter:compileDebugSwift", ":greeter:linkDebug", ":app:compileDebugSwift", ":app:linkDebug", ":app:installDebug", ":app:assemble")

    }

    def "forks build when JVM args are requested"() {
        requireJvmArg('-Xmx64m')

        file('build.gradle') << "println 'hello world'"

        when:
        succeeds()

        then:
        wasForked()

        and:
        daemons.daemon.stops()
    }

    def "forks build when default client VM memory is used and user didn't specify a different limit"() {