}
        classes.baseline()
        buildScript(classes.buildScript())
    }

    @Override
    protected void moveFilesAround() {
        Files.move(file("src/main/scala").toPath(), file("src/main/new-scala").toPath())
        classes.sourceDir = 'src/main/new-scala'
        buildScript(classes.buildScript())
        // Move scala library dependency around on disk

package org.gradle.testkit.runner

class GradleRunnerArgumentsIntegrationTest extends BaseGradleRunnerIntegrationTest {

    def "can execute build without specifying any arguments"() {
        given:
        buildScript """
            help {
                doLast {
                    file('out.txt').text = "help"
                }
            }
        """

        when:
        runner().build()

        then:

    val resolvedDependencies = hashSetOf<ComponentIdentifier>()
    for (buildscript in scriptHandlers.asReversed()) {
        val unresolvedDependencies = classpathDependenciesOf(buildscript).filter { it !in resolvedDependencies }
        if (unresolvedDependencies.isNotEmpty()) {
            sourcePath += resolveSourcesUsing(buildscript.dependencies) {
                forComponents(unresolvedDependencies)
            }

        given:
        publishPlugins(MAVEN)
        requireOwnGradleUserHomeDir()
        buildScript """
            //this simulates pluginA having a dependency on the hello world plugin
            buildscript {
                dependencies {
                    classpath "org.gradle:gradle-hello-world-plugin:0.2"
                }
            }

    kotlin("android") version "1.9.23" apply false
// tag::android[]
}
// end::android[]

// tag::android-buildscript[]
buildscript {
    repositories {
        google()
        gradlePluginPortal()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:7.3.0")
    }
}

class BuildscriptRepositoryContentFilteringIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def "can exclude a module from a repository using #notation for buildscript classpath (in settings: #inSettings)"() {
        def mod = ivyHttpRepo.module('org', 'foo', '1.0').publish()

        given:
        def repositories = """
    repositories {
        maven {

import org.gradle.api.problems.Problems
import org.gradle.api.problems.Severity

def gradleInternal = gradle as GradleInternal
def problems = gradleInternal.services.get(Problems)

problems.forNamespace('buildscript').reporting {
    it.id('adhoc-script-deprecation', 'Deprecated script plugin')
        .contextualLabel("Deprecated script plugin 'demo-script-plugin'")
        .severity(Severity.WARNING)

        internalCreateLockfile(modules, configuration, lockFile)
    }

    private void internalCreateLockfile(String configuration, List<String> modules, boolean unique, boolean buildScript) {
        if (unique) {
            def fileName = buildScript ? LockFileReaderWriter.BUILD_SCRIPT_PREFIX + LockFileReaderWriter.UNIQUE_LOCKFILE_NAME : LockFileReaderWriter.UNIQUE_LOCKFILE_NAME
            def lockFile = testDirectory.file(fileName)

    }

    def "can specify plugin version"() {
        when:
        buildScript "plugins { id '$PLUGIN_ID' version '1.0' }"

        then:
        verifyPluginApplied('1.0')
    }

    def "can specify plugin version using gradle properties"() {
        when:
        file("gradle.properties") << "myPluginVersion=2.0"
        buildScript """
            plugins {
                id '$PLUGIN_ID' version "\${myPluginVersion}"

@UnsupportedWithConfigurationCache(because = "software model")
class InvalidManagedModelMutationIntegrationTest extends AbstractIntegrationSpec {

    def "mutating managed inputs of a rule is not allowed"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {