import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.initialization.BuildLoader;
import org.gradle.initialization.DependenciesAccessors;
import org.gradle.initialization.buildsrc.BuildSourceBuilder;
import org.gradle.internal.buildtree.BuildInclusionCoordinator;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.classpath.Instrumented;

        given:
        def distro1 = createDistribution(1)
        def distro2 = createDistribution(2)

        and:
        file("buildSrc/build.gradle") << """
            println "buildSrc: runtime gradle home: \${gradle.gradleHomeDir}"
        """
        buildFile << """
            println "main build: runtime gradle home: \${gradle.gradleHomeDir}"
        """

        and:

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization.buildsrc;

import org.gradle.internal.UncheckedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

                    // Any configuring event received from nested or buildSrc builds before the root build starts configuring is ignored
                    phaseHasMoreProgress(startEvent);
                } else if (startEvent.getBuildOperationCategory() == BuildOperationCategory.CONFIGURE_PROJECT && currentPhase == Phase.Configuring) {
                    // Any configuring event received from nested or buildSrc builds before the root build starts configuring is ignored

        }

        withArguments(arguments)
    }


private
fun buildSrcProjectDirOf(scriptFile: File, importedProjectDir: File): File? =
    importedProjectDir.resolve("buildSrc").takeIf { buildSrc ->
        buildSrc.isDirectory && buildSrc.isParentOf(scriptFile)
    }


private
fun hasProjectDependentClassPath(scriptFile: File): Boolean =
    when (kotlinScriptTypeFor(scriptFile)) {

            public BuildOperationDescriptor.Builder description() {
                //noinspection Convert2Lambda
                return BuildOperationDescriptor.displayName("Build buildSrc").
                    progressDisplayName("Building buildSrc").
                    details(
                        new BuildBuildSrcBuildOperationType.Details() {
                            @Override

Concretely, we add a _convention plugin_ in `buildSrc` to share the integration test setup between multiple subprojects:

====
include::sample[dir="kotlin",files="buildSrc/src/main/kotlin/myproject.java-conventions.gradle.kts[]"]
include::sample[dir="groovy",files="buildSrc/src/main/groovy/myproject.java-conventions.gradle[]"]
====

And apply it in an application project:

====

        this
    }

    MultiProjectBuilder buildSrc(GradleDsl projectDsl = dsl, @DelegatesTo(value = PolyglotProjectBuilder, strategy = Closure.DELEGATE_FIRST) Closure<?> config) {
        def p = projects['buildSrc']
        if (p == null) {
            p = new PolyglotProjectBuilder(projectDsl, rootProjectDirectory.createDir('buildSrc'))
            projects['buildSrc'] = p
        }
        applyConfiguration(config, p)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization.buildsrc;

import org.gradle.internal.operations.BuildOperationType;

/**
 * Building the buildSrc project.
 *
 * @since 4.3
 */

        projectDir.with {
            file('buildSrc/settings.gradle.kts') << ""
            file('buildSrc/build.gradle.kts') << KotlinDslTestUtil.kotlinDslBuildSrcScript
            file("buildSrc/src/main/kotlin/TaskWithNestedAction.kt") << """
                import org.gradle.api.DefaultTask
                import org.gradle.api.tasks.Nested