and:
        file('settings.gradle.kts') << '''
            include(":app")
            rootProject.name = "customBuildConfigField"
        '''

        file('build.gradle.kts') << """
            buildscript {
                $repositoriesBlock
                dependencies {
                    classpath("com.android.tools.build:gradle:$agpVersion")

    }

    def "#desc can handle symlinks"() {
        def buildScript = file("build.gradle")
        def baseDir = file('build')
        baseDir.file('file').text = 'some contents'
        def symlinked = baseDir.file('symlinked')
        symlinked.text = 'target of symlink'
        baseDir.file('symlink').createLink(symlinked)

        buildScript << """
            def baseDir = new File("${escapeString(baseDir)}")

/**
 * A mutator that cleans up the artifact transform cache directory, but leaves folders with the instrumented jars.
 *
 * Since buildscript classpath instrumentation also uses artifact transforms, we can avoid
 * re-instrumenting jars by applying this mutator.
 *
 * In other words, this mutator can be applied to a scenario that tests performance of artifact transforms,

val expectedCompileClasspathJreVersion =
  expectedReducedRuntimeClasspathJreVersion + setOf("j2objc-annotations-3.0.0.jar")

val extraLegacyDependencies = setOf("google-collections-1.0.jar")

buildscript {
  val agpVersion = if (gradle.gradleVersion.startsWith("5.")) "3.6.4" else "7.0.4"
  repositories {
    google()
    mavenCentral()
  }
  dependencies {

            connection.action(new LoadEclipseModel()).run()
        }

        then:
        collectProjects(model).collect({ it.name }).contains("a")
    }

    def "buildscript names are deduplicated"() {
        when:
        EclipseProject model = withConnection { connection ->
            connection.action(new LoadEclipseModel(eclipseWorkspace([externalProject("explicitName")]))).run()

        assertMetadataExists()
        hasModules(["test-plugin:test-plugin.gradle.plugin", "com:myplugin"])
    }

    def "writes checksums of plugins using buildscript block"() {
        given:
        addPlugin()
        buildFile << """
          buildscript {
             repositories {
                maven { url "${pluginRepo.uri}" }
             }
             dependencies {

                    $agpNightlyRepositoryDeclaration
                    gradlePluginPortal()
                }
            }
            allprojects {
                buildscript {
                    repositories {
                        $agpNightlyRepositoryDeclaration
                    }
                }
                repositories {

import kotlin.reflect.KClass
import kotlin.reflect.KProperty


/**
 * Configures the build script classpath for this project.
 */
fun Project.buildscript(action: ScriptHandlerScope.() -> Unit): Unit =
    ScriptHandlerScopeInternal(project, buildscript).action()


/**
 * Sets the default tasks of this project. These are used when no tasks names are provided when
 * starting the build.
 */

     * <p>
     * An example of hooking into the projectsLoaded to configure buildscript classpath from the init script.
     * <pre class='autoTested'>
     * //init.gradle
     * gradle.projectsLoaded {
     *   rootProject.buildscript {
     *     repositories {
     *       //...
     *     }
     *     dependencies {
     *       //...
     *     }

        val shortScriptDisplayName = Describables.of("short display name")
        val longScriptDisplayName = Describables.of("long display name")

        val text = """

            buildscript {
                require(Thread.currentThread().contextClassLoader === this@Settings_gradle.javaClass.classLoader)
                println("stage 1")
            }