new BuildLogicChangeFixture(projectDir, language, kind)
        }
    }

    enum Language {
        JAVA,
        GROOVY,
        KOTLIN

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

        settingsFile << ""
        buildFile << """
            plugins {
                id("java")
            }
            ${mavenCentralRepository()}
            dependencies { testImplementation("junit:junit:4.13") }
            println("script log statement")
        """
        file("src/test/java/my/MyTest.java") << """
            package my;
            import org.junit.Test;
            public class MyTest {

            }
        }
    }

    void generateClassesWithClashingMethods() {
        def sourceFolder = testDirectory.createDir("buildSrc/src/main/java")

        sourceFolder.file("ProcessGroovyMethodsExecute.java") << """
            import java.io.*;
            import java.util.*;

            public class ProcessGroovyMethodsExecute {

                public static Process execute(String command) { return null; }

                String value

                @Override
                void writeExternal(java.io.ObjectOutput oos) {
                    oos.writeUTF("42")
                }

                @Override
                void readExternal(java.io.ObjectInput ois) {
                    value = ois.readUTF()
                }
            }

            import ${Plugin.name}

            class SomePlugin: Plugin<Project> {
                override fun apply(project: Project) {
                    project.tasks.register("producer", ProducerTask::class.java) {
                        outFile.set(project.layout.buildDirectory.file("intermediate.txt"))
                    }
                }
            }
        """
        taskDefinition()
    }

    @Override

import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import japicmp.util.Optional
import javassist.CtClass
import me.champeau.gradle.japicmp.report.Violation

import java.util.regex.Pattern

abstract class AbstractSuperClassChangesRule extends AbstractGradleViolationRule {

    private final List<Pattern> publicApiPatterns

    AbstractSuperClassChangesRule(Map<String, Object> params) {

        typeName = type.name
    }

    void withConventionMappingForPropertyOfType(Class type, String value) {
        final String typeName = type.name
        file('buildSrc/src/main/java/my/ConventionPlugin.java') << """
            package my;
            public class ConventionPlugin implements ${Plugin.name}<${Project.name}> {
                @Override
                public void apply(${Project.name} project) {

import com.microsoft.playwright.Page
import com.microsoft.playwright.Playwright
import org.gradle.test.fixtures.Flaky
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

import java.util.function.Consumer

import static org.gradle.integtests.fixtures.configurationcache.ConfigurationCacheProblemsFixture.resolveConfigurationCacheReport

        then:
        outputContains("Hello")

        where:
        [snippetsFactory, task] << [
            [
                exec("getExecOperations()").java,
                javaexec("getExecOperations()").java,
                processBuilder().java
            ],
            [
                "resolveCollection",
                "resolveProviders"
            ]
        ].combinations()
    }

            abstract class IsCi : $ValueSource.name<String, Params> {
                override fun obtain(): String? = parameters.value.orNull
            }

            val ciProvider = providers.of(IsCi::class.java) {
                parameters.value.set(providers.systemProperty("test_is_ci"))
            }

            val isCi = ${inputExpression}
            tasks {
                named("jar") {