then:
        subprojectDir.file("build.gradle.kts").assertExists()

        and:
        targetDir.file("/buildSrc/src/main/kotlin/buildlogic.kotlin-common-conventions.gradle.kts").assertContents(containsString("junit.jupiter"))

        when:
        run("build")

        then:

import org.gradle.initialization.SettingsPreparer;
import org.gradle.initialization.SettingsProcessor;
import org.gradle.initialization.buildsrc.BuildSourceBuilder;
import org.gradle.initialization.buildsrc.BuildSrcBuildListenerFactory;
import org.gradle.initialization.buildsrc.BuildSrcProjectConfigurationAction;
import org.gradle.initialization.layout.BuildLayout;
import org.gradle.initialization.layout.BuildLayoutConfiguration;

import java.util.stream.Stream

class TestTaskPropertiesServiceIntegrationTest extends AbstractIntegrationSpec {

    def "provides task configuration to plugin"() {
        given:
        new PluginBuilder(file("buildSrc")).with {
            addPlugin("""
                def objects = project.objects
                def outputFile = project.file("\${project.buildDir}/testTaskProperties.json")

                    """
            }
        }
    }

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

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

            public class ProcessGroovyMethodsExecute {

}
task doStuff
'''
        inTestDirectory().withTasks('doStuff').run()
    }

    private TestFile createBuildSrc() {
        return testFile('buildSrc/src/main/java/BuildSrcClass.java') << '''
            public class BuildSrcClass { }
'''
    }

    private def createExternalJar() {
        ArtifactBuilder builder = artifactBuilder()

        assertTransformed()
    }

    def "buildSrc output may require transform output"() {
        withColorVariants(mavenRepo.module("test", "test", "12")).publish()

        createDirs("buildSrc/producer")
        file("buildSrc/settings.gradle") << """
            include 'producer'
        """
        def buildSrcBuildFile = file("buildSrc/build.gradle")

        run("impl:bar")

        then:
        fixture.assertProjectsConfigured(":", ":impl", ":api")
        result.assertTasksExecutedInOrder(":api:foo", ":impl:bar")
    }

    def "supports buildSrc"() {
        file("buildSrc/src/main/java/FooTask.java") << """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;

            public class FooTask extends DefaultTask {

    }

    /**
     * Get the elapsed time (in mSec) between the buildStarted event and the settingsEvaluated event.
     * Note that this will include processing of buildSrc as well as the settings file.
     */
    public long getElapsedSettings() {
        return valueOrBuildStartedTimeIfNotInitialized(settingsEvaluated) - valueOrBuildStartedTimeIfNotInitialized(buildStarted);
    }

     */
    boolean isLoadsFromConfigurationCacheAfterStore();

    /**
     * Returns true if this version runs tests when building `buildSrc`
     */
    boolean isRunsBuildSrcTests();

    /**
     * Returns true if it as a Gradle version that supports Kotlin scripts
     */
    boolean isSupportsKotlinScript();

    /**

    "linux" : 211
  }, {
    "testProject" : "withVerboseTestNG",
    "linux" : 200
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.inception.BuildSrcApiChangePerformanceTest.buildSrc abi change",
  "durations" : [ {
    "testProject" : "largeJavaMultiProject",
    "linux" : 606
  }, {
    "testProject" : "largeJavaMultiProjectKotlinDsl",
    "linux" : 999
  }, {