def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        def includedBuildFile = testDirectory.file(file)
        includedBuildFile << """
            ${snippets.imports}
            plugins {
                id("groovy-gradle-plugin")
            }
            ${snippets.body}
        """
        testDirectory.file("included/src/main/groovy/test-convention-plugin.gradle") << """

import org.junit.Rule

class CppDependenciesIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {
    def app = new CppAppWithLibraries()
    @Rule
    GitFileRepository repo = new GitFileRepository(testDirectory)

    @ToBeFixedForConfigurationCache
    def "can combine C++ builds in a composite"() {
        given:
        createDirs("app", "hello", "log")
        settingsFile << """
            include 'app'

        given:
        makeSingleProject()
        settingsFile << "rootProject.name = '${componentUnderTest.projectName}'"
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << """
            ${componentUnderTestDsl} {
                targetMachines = [machines.linux, machines.macOS]
            }
        """

        expect:

import org.gradle.test.fixtures.file.TestFile

class ProjectCopySpecTest extends AbstractProjectBuilderSpec {

    TestFile getCopySource() {
        temporaryFolder.testDirectory.createDir("source")
    }

    TestFile getCopyDest() {
        temporaryFolder.testDirectory.createDir("dest")
    }

    def "copy spec is enhanced"() {
        given:
        def copySpecRootCalled = false
        def copySpecEachFileCalled = false

        hasOperationsForStoreAndLoad()
        compositeBuildsIdentified(testDirectory, buildLogicBuild, buildLogicDir)
        buildLogicBuiltAndWorkGraphCalculated(buildLogicBuild)
    }

    private void compositeBuildRootBuildWorkGraphLoaded(String childBuild = ':lib', TestFile childBuildDir = testDirectory.file('lib')) {
        hasOperationsForLoad()

class CompositeBuildBuildSrcIntegrationTest extends AbstractIntegrationSpec {

    def "included and composing builds can contain buildSrc builds"() {
        def outerBuild = new BuildTestFile(testDirectory, "root")
        def childBuild = new BuildTestFile(testDirectory.file("child"), "child")

        outerBuild.settingsFile << """
            includeBuild 'child'
        """
        outerBuild.file('buildSrc/src/main/java/Thing.java') << """

    def setup() {
        copier = new FileCopier(
                TestFiles.deleter(),
                TestFiles.directoryFileTreeFactory(),
                TestFiles.fileCollectionFactory(testDirectory),
                TestFiles.resolver(testDirectory),
                TestFiles.patternSetFactory,
                TestUtil.objectFactory(),
                TestFiles.fileSystem(),
                TestUtil.instantiatorFactory().decorateLenient(),

    def forkOptionsFactory = TestFiles.execFactory(temporaryFolder.testDirectory)
    def objectFactory = Stub(ObjectFactory) {
        fileCollection() >> { TestFiles.fileCollectionFactory().configurableFiles() }
    }
    def workerDirectoryProvider = Stub(WorkerDirectoryProvider) {
        getWorkingDirectory() >> { temporaryFolder.testDirectory }
    }
    def runnable = Mock(Runnable)

        def scriptDir = testDirectory.createDir("scriptDir")
        def script = scriptDir.createFile("swiftc")
        script << """
            #!/bin/sh
            echo "foo"
        """
        script.executable = true

        def app = new SwiftApp()
        settingsFile << "rootProject.name = '${app.projectName}'"
        app.writeToProject(testDirectory)

        when:
        buildFile << """

        System.setProperty("user.dir", temporaryFolder.testDirectory.absolutePath)
        // This prevents the ProjectBuilder from finding the Gradle build's root settings.gradle
        // and treating the root of the repository as the root of the build
        new File(temporaryFolder.testDirectory, "settings.gradle") << ""
        rootProject = TestUtil.createRootProject(temporaryFolder.testDirectory)