resolver.resolve("buildscript-$LockFileReaderWriter.UNIQUE_LOCKFILE_NAME") >> tmpDir.file("buildscript-$LockFileReaderWriter.UNIQUE_LOCKFILE_NAME")
        lockFileReaderWriter = new LockFileReaderWriter(resolver, context, lockFile, listener)
        lockFileReaderWriter.writeUniqueLockfile([a: ['foo', 'bar'], b: ['foo'], c: []])

        then:

    private final static List<String> MANAGED_SCALAR_COLLECTION_TYPES = ['List', 'Set']

    def "rule can mutate a managed type with a #type of scalar read-only property"() {
        given:
        buildScript """

        @Managed
        interface Container {
            $type<String> getItems()
        }

        class Rules extends RuleSource {
            @Model

    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)

class InterfaceBackedManagedTypeIntegrationTest extends AbstractIntegrationSpec {

    def "rule method can define a managed model element backed by an interface"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            @Managed
            interface Names {

        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)

            extraDir { file 'extra.txt' }
            dir1 {
                file 'extra.txt'
                extraDir { file 'extra.txt' }
            }
            someOtherEmptyDir {}
        }

        buildScript '''
            task sync(type: Sync) {
                into 'dest'
                from 'source'
            }
        '''.stripIndent()

        when:
        run 'sync'

        then:

    }

    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 {