}

        where:
        snippetsFactory             | file
        exec().groovy               | "included/settings.gradle"
        javaexec().groovy           | "included/settings.gradle"
        processBuilder().groovy     | "included/settings.gradle"
        stringArrayExecute().groovy | "included/settings.gradle"
        runtimeExec().groovy        | "included/settings.gradle"

    def setup() {
        pluginDir.file("build.gradle") << """
            plugins {
                id("groovy")
            }
            dependencies {
                implementation gradleApi()
                implementation localGroovy()
            }
        """
        pluginDir.file("src/main/groovy/Params.groovy") << """
            import ${Property.name}
            import ${Internal.name}

    }

    def "assemble on Groovy project with sources but no groovy dependency is executed and fails with a reasonable error message"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        buildFile << """
            plugins { id 'groovy' }
        """
        file("src/main/groovy/Thing.groovy") << """
            class Thing {}
        """

        buildFile("""
            plugins {
                id("groovy")
            }

            dependencies {
                implementation localGroovy()
            }
        """)

        settingsFile("""
            enableFeaturePreview("${FeaturePreviews.Feature.GROOVY_COMPILATION_AVOIDANCE.name()}")
        """)

        file("src/main/groovy/Main.groovy") << """
            class Main {}
        """

        }
    }

    enum Language {
        JAVA,
        GROOVY,
        KOTLIN

        String getFileExtension() {
            switch (this) {
                case JAVA:
                    return 'java'
                case GROOVY:
                    return 'groovy'
                case KOTLIN:
                    return 'kt'
            }
        }

        // Therefore, it is impossible to call System.getProperties() with static import there, and testing static
        // import is important because Groovy generates different code in this case.
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${CompileStatic.name}
            import ${Plugin.name}
            import ${Project.name}
            import static ${System.name}.clearProperty

            outputContains("Groovy closure in task with delegate=null, owner=$brokenObject, this=$brokenObject")
            outputContains("Groovy closure in task with custom delegate=null, owner=$brokenObject, this=$brokenObject")
            outputContains("nested Groovy closure in task with delegate=null, owner=$brokenObject, this=$brokenObject")

    @Override
    void pluginDefinesTask() {
        pluginDir.file("src/main/groovy/SomePlugin.groovy") << """
            import ${Project.name}
            import ${Plugin.name}

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.register("producer", ProducerTask) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.performance.generator.tasks

import groovy.transform.CompileStatic
import groovy.transform.TypeChecked
import groovy.transform.TypeCheckingMode
import org.gradle.api.DefaultTask
import org.gradle.api.file.FileSystemOperations
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Input

            }
        }

        where:
        snippetsFactory             | file
        exec().groovy               | "exec.init.gradle"
        javaexec().groovy           | "exec.init.gradle"
        processBuilder().groovy     | "exec.init.gradle"
        stringArrayExecute().groovy | "exec.init.gradle"
        runtimeExec().groovy        | "exec.init.gradle"
        exec().kotlin               | "exec.init.gradle.kts"