class PolymorphicManagedTypeIntegrationTest extends AbstractIntegrationSpec {

    def "rule can provide a managed model element backed by an abstract class that implements interfaces"() {
        when:
        buildScript '''
            @Managed
            interface Named {
                String getName()
            }

            @Managed
            abstract class Person implements Named {

    def "rules are detected when model path is a straight property reference chain - #path"() {
        given:
        def normalisedPath = path.replace('"', '').replaceAll("'", "")

        when:
        buildScript """
            @Managed
            interface Item {
                String getValue()
                void setValue(String value)
            }

            @Managed
            interface A extends Item {

    @Issue(['GRADLE-1506'])
    def "create Jar with metadata encoded using UTF-8 when platform default charset is not UTF-8"() {
        given:
        buildScript """
            task jar(type: Jar) {
                from file('test')
                destinationDirectory = file('dest')
                archiveFileName = 'test.jar'
            }
        """.stripIndent()

                    });
                }
            }
        '''

        buildScript '''
            apply type: RulePlugin
        '''

        then:
        succeeds "check"
    }

    def "can set/get properties of all supported scalar types using Groovy"() {
        when:
        buildScript '''
            @Managed
            interface AllSupportedUnmanagedTypes {

import org.gradle.api.internal.GradleInternal
import org.gradle.kotlin.dsl.registering

val gradleInternal = gradle as GradleInternal
val problems = gradleInternal.services.get(Problems::class.java)

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

Gradle.class.classLoader.loadClass('${implClassName}')
try {
    buildscript.classLoader.loadClass('${implClassName}')
    assert false: 'should fail'
} catch (ClassNotFoundException e) {
    // expected
} finally {
    if (buildscript.classLoader instanceof Closeable) {
        buildscript.classLoader.close()
    }
}

try {
    buildscript.classLoader.loadClass('BuildSrcClass')
    assert false: 'should fail'

    }

    protected ExecutionResult runTask(taskName, settingsScript = "rootProject.name = 'root'", buildScript) {
        def settingsFile = file("settings.gradle")
        settingsFile << settingsScript

        def buildFile = file("build.gradle")
        buildFile << buildScript

        return executer.withTasks(taskName).run()
    }

    protected TestFile getFile(Map options, String filename) {

class InvalidManagedModelRuleIntegrationTest extends AbstractIntegrationSpec {

    def "provides a useful error message when setting an incompatible type on a managed instance in Groovy"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                int getThumbCount()
                void setThumbCount(int c)
            }

            class RulePlugin extends RuleSource {

class TestKitDependencyClassVisibilityIntegrationTest extends AbstractIntegrationSpec {

    def "test kit dependency is not implicitly put on the test compile classpath"() {
        when:
        buildScript """
            plugins { id "org.gradle.java" }
        """

        file("src/test/java/Test.java") << """
            import $GradleRunner.name;
            class Test {}
        """

        then:

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

    def "rule source can be applied to ModelMap element"() {
        when:
        buildScript '''
            class MessageTask extends DefaultTask {
                @Internal
                String message = "default"

                @TaskAction
                void printMessages() {