return this.java;
        }

        @Override
        public ProblemGroup groovy() {
            return this.groovy;
        }

        @Override
        public ProblemGroup groovyDsl() {
            return this.groovyDsl;
        }
    }

    private static class DefaultValidationProblemGroup extends DefaultProblemGroup implements ValidationProblemGroup {

        BuilderSupport.applyConfiguration(spec, section)
        section
    }

    T section(Supplier<String> groovyDsl, Supplier<String> kotlinDsl) {
        sections << new GenericSection(groovyDsl, kotlinDsl)
        this
    }

    T section(String groovyDsl, String kotlinDsl) {
        section({ groovyDsl }, { kotlinDsl })
    }

    String getSectionName() {
        null
    }

    @Override

    def script = file("plugin.gradle")

    @Override
    String getLocation() {
        return "Script 'plugin.gradle'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        groovyDsl(script, read)
        buildFile << """
            apply from: "plugin.gradle"
        """
    }

    @Override
    String getLocation() {
        return "Build file 'build.gradle'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        groovyDsl(buildFile, read)
    }

import groovy.transform.CompileStatic
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.test.fixtures.file.TestFile

trait GroovyPluginImplementation {
    void groovyDsl(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

            println("apply = " + ${read.groovyExpression})

        expect:
        jar != null
        jar.file == new File("$fileName")
        jar.baseName == "groovy"
        jar.version == VersionNumber.parse("$version")
        !jar.groovyAll
        !jar.indy
        jar.dependencyNotation == "$dependencyNotation"

        where:
        fileName                | version | dependencyNotation

    implementation(project(":platform-base"))
    implementation(project(":plugins-java"))
    implementation(project(":plugins-java-base"))
    implementation(project(":war"))

    implementation(libs.groovyXml)
    implementation(libs.slf4jApi)
    implementation(libs.commonsIo)


    runtimeOnly(project(":language-jvm"))
    runtimeOnly(project(":testing-base"))
    runtimeOnly(project(":testing-jvm"))

dependencies {
    api(project(":base-services"))
    api(project(":concurrent"))
    api(project(":hashing"))
    api(project(":stdlib-java-extensions"))
    api(project(":native"))

    api(libs.groovy)
    api(libs.groovyXml)
    api(libs.hamcrest)
    api(libs.hamcrestCore)
    api(libs.junit)
    api(libs.junit5JupiterApi)
    api(libs.spock)
    api(libs.spockJUnit4)

    implementation(project(":build-operations"))

     */
    boolean has(String name);

    /**
     * Returns the value for the registered property with the given name.
     *
     * When using an extra properties extension from Groovy, you can also get properties via Groovy's property syntax.
     * All of the following lines of code are equivalent.
     *
     * <pre class='autoTested'>
     * project.ext { foo = "bar" }
     *
     * assert project.ext.get("foo") == "bar"

    implementation(project(":logging"))
    implementation(project(":platform-base"))
    implementation(project(":plugins-java"))
    implementation(project(":plugins-java-base"))

    implementation(libs.groovyXml)
    implementation(libs.guava)
    implementation(libs.commonsLang)

    testImplementation(project(":base-services-groovy"))
    testImplementation(testFixtures(project(":core")))