namespace {

constexpr char kEntryFuncName[] = "main";

absl::Status SetupArguments(mlir::ModuleOp module,
                            std::vector<TensorShape>& arg_shapes,
                            tpu::TPUCompileMetadataProto& metadata_proto) {
  auto main_fn = module.lookupSymbol<mlir::func::FuncOp>(kEntryFuncName);
  if (!main_fn) {
    return absl::InternalError("Could not find main function in MLIR Module.");
  }

            ${mavenCentralRepository()}

            dependencies {
                implementation(localGroovy())
                testImplementation("junit:junit:4.13")
            }
        """
        file("src/main/groovy/Thing.groovy") << """
            class Thing {}
        """
        file("src/test/groovy/ThingTest.groovy") << """
            import org.junit.*
            class ThingTest {

        given:
        def configurationCache = newConfigurationCacheFixture()

        file("build.gradle") << """
            plugins {
               id("java")
            }
        """
        file("src/main/java/included/Example.java") << ""

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateStored()
        def report = findReport()

    def "using #snippetsFactory.summary in task configuration is a problem"() {
        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file("buildSrc/src/main/java/SneakyTask.java") << """
            import ${DefaultTask.name};
            import ${ExecOperations.name};
            import ${Inject.name};
            import ${TaskAction.name};
            ${snippets.imports}

    @Issue("https://github.com/gradle/gradle/issues/19047")
    def "problem is reported for Kotlin lambda expression with develocity plugin"() {
        given:
        createDir('dv-conventions') {
            file('src/main/kotlin/my/DvConventionsPlugin.kt') << """
                package my

                import org.gradle.api.*
                import org.gradle.kotlin.dsl.*

            // When not running from a Gradle distro, need the daemon main jar and the daemon server implementation plus the search path to look for other modules
            classpath = registry.getModule("gradle-daemon-server").getAllRequiredModulesClasspath();
            classpath = classpath.plus(registry.getModule("gradle-daemon-main").getImplementationClasspath());

    def "#method is instrumented in Java"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/java/SomePlugin.java") << """
            import ${Plugin.name};
            import ${Project.name};

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {

            property('input')
                .value("task ':dependencyTask'")
                .cannotBeConvertedTo(targetType)
                .candidates(
                    "a String or CharSequence path, for example 'src/main/java' or '/usr/include'",
                    "a String or CharSequence URI, for example 'file:/usr/include'",
                    "a File instance",
                    "a Path instance",

    classpath.from(configurations.integTestDistributionRuntimeClasspath)
    packageName = "org.gradle.integtests.fixtures"
    destDir = layout.buildDirectory.dir("generated/sources/language-annotations/groovy/main")
}

sourceSets.main {
    groovy.srcDir(generateLanguageAnnotations.flatMap { it.destDir })
    output.dir(prepareVersionsInfo.map { it.destFile.get().asFile.parentFile })
    output.dir(copyTestedVersionsInfo)
}

        file("buildSrc/src/main/java/SingleField.java") << """
            public record SingleField(String value) {}
        """
        file("buildSrc/src/main/java/ZeroFields.java") << """
            public record ZeroFields() {}
        """
        file("buildSrc/src/main/java/MultipleFields.java") << """