"""
        )

        withBuildScript(
            """
            plugins {
                `java-library`
            }

            allprojects {
                $repositoriesBlock
            }

            dependencies {
                api(project(":consumer"))
            }
            """
        )

        withFolders {

            "consumer" {

        server.resetExpectations()

        then:
        configurationCache.assertStateLoaded()
    }

    private String buildFileConfiguration(String repositoriesBlock) {
        buildFile """
            apply plugin: 'ivy-publish'

            group = 'group'
            version = '1.0'

            def mainComponent = new TestComponent()

                println("org.acme.plugins.my-init applied!")
                """
            )
        }

        val repositoriesBlock = repositoriesBlockFor(repository)

        withSettings(
            """
            pluginManagement {
                $repositoriesBlock
            }
            """
        )

        withBuildScript(
            """
            plugins {

    def "settings script has type-safe accessors on the classpath"() {
        given:
        withDefaultSettingsIn("included")
        withBuildScriptIn("included", """
            plugins { `kotlin-dsl` }
            $repositoriesBlock
        """)
        file("included/src/main/kotlin/SettingsExtension.kt") << """
            import org.gradle.api.provider.*
            interface SettingsExtension {
                val myProperty: Property<Int>

    def "kotlin-dsl project with pre-compiled script plugins should import without errors"() {

        given:
        withBuildScript """
            plugins { `kotlin-dsl` }
            $repositoriesBlock
        """
        file("src/main/kotlin/myplugin.gradle.kts") << ''

        when:
        def model = loadValidatedToolingModel(KotlinDslScriptsModel) {
            setModelParameters(it, false)
        }

        withBuildScript(
            """
            plugins {
                `kotlin-dsl`
                id("org.gradle.kotlin-dsl.ktlint-convention") version "0.9.0"
            }

            $repositoriesBlock
            """
        )

        withPrecompiledKotlinScript(
            "plugin-without-package.gradle.kts",
            """
            plugins {
                org.gradle.base
            }

    fun `kotlin resolution and inference issue KT-44303`() {
        withBuildScript("""
            import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

            plugins { `embedded-kotlin` }
            $repositoriesBlock
            dependencies {
                implementation(gradleKotlinDsl())
            }
            tasks.withType<KotlinCompile>().configureEach {

            """
        )
        withKotlinDslPlugin().appendText(
            """
                subprojects {
                    apply(plugin = "org.gradle.kotlin.kotlin-dsl")
                    $repositoriesBlock
                }
                project(":consumer") {
                    dependencies {
                        implementation(project(":producer"))
                    }
                }
            """

        withFile(
            "build.gradle.kts",
            """

            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock
            """
        )
    }

    @Test
    fun `can configure publishing extension`() {

        withBuildScript(
            """

            plugins {

        storeTimeRepo == loadTimeRepo
        def loadTimeMetadata = metadataFile.text
        storeTimeMetadata == loadTimeMetadata
    }

    private String buildFileConfiguration(String repositoriesBlock) {
        """
            apply plugin: 'maven-publish'

            group = 'group'
            version = '1.0'

            def mainComponent = new TestComponent()