}
        }
    }

    void generateProjectSource(File projectDir, TestProject testProject, Map args) {
        generateProjectSource(projectDir, "java", testProject, args)
        if (groovyProject) {
            generateProjectSource(projectDir, "groovy", testProject, args)
        }
        if (scalaProject) {
            generateProjectSource(projectDir, "scala", testProject, args)
        }
    }

    def setup() {
        setupProjectInDirectory(temporaryFolder.testDirectory)
    }
    def setupProjectInDirectory(TestFile projectDir) {
        projectDir.file('settings.gradle') << localCacheConfiguration()
        projectDir.file('settings.gradle') << "rootProject.name = 'test-project'"
        projectDir.file("build.gradle") << """
            plugins {
                id 'java'
            }

        executer.requireOwnGradleUserHomeDir()

        String version = GradleVersion.current().version
        projectDir = file("project")
        projectDir.mkdirs()
        userHomeDir = executer.gradleUserHomeDir
        buildFile = projectDir.file('build.gradle')
        visitedBaseDirs = []
        artifactsCache = projectDir.file(".gradle/$version/executionHistory/executionHistory.bin")

        }
    }

    void generateProjectSource(File projectDir, TestProject testProject, Map args) {
        generateProjectSource(projectDir, "h", testProject, args)
        generateProjectSource(projectDir, "c", testProject, args)
        generateProjectSource(projectDir, "cpp", testProject, args)
        projectDir.mkdirs()
    }

    void generateProjectSource(File projectDir, String sourceLang, TestProject testProject, Map args) {

        Map<String, String> environment) {
        this.gradleProvider = gradleProvider;
        this.gradleUserHome = gradleUserHome;
        this.projectDir = projectDir;
        this.buildArgs = buildArgs;
        this.jvmArgs = jvmArgs;
        this.injectedClassPath = injectedClassPath;
        this.embedded = embedded;
        this.standardOutput = standardOutput;
        this.standardError = standardError;

plugins {
    id 'base'
}

version = 1.0

tasks.register('myZip', Zip) {
    from 'somedir'
    File projectDir = layout.projectDirectory.asFile
    doLast {
        println archiveFileName.get()
        println projectDir.relativePath(destinationDirectory.get().asFile)
        println projectDir.relativePath(archiveFile.get().asFile)
    }
}
// end::zip-task[]

// tag::zip-task-with-custom-base-name[]

    @Override
    public Model interpolateModel(
            Model model, File projectDir, ModelBuildingRequest config, ModelProblemCollector problems) {
        return interpolateModel(model, projectDir != null ? projectDir.toPath() : null, config, problems);
    }

    @Override
    public Model interpolateModel(
            Model model, Path projectDir, ModelBuildingRequest config, ModelProblemCollector problems) {

    private final String path;
    private final String identityPath;
    private final String projectDir;
    private final String buildFile;
    private final Set<BuildStructureOperationProject> children;

    public BuildStructureOperationProject(String name, String path, String identityPath, String projectDir, String buildFile, Set<BuildStructureOperationProject> children) {
        this.name = name;
        this.path = path;

configurations {
    compile
}
dependencies {
    repositories {
        ivy {
            artifactPattern projectDir.absolutePath + '/[module]-[revision].jar'
            ivyPattern projectDir.absolutePath + '/[module]-[revision]-ivy.xml'
        }
    }
    compile 'test:projectA:1.2'
}

file("projectA-1.2.jar").text = ''

        buildA.buildFile << """
            assert gradle.includedBuild("buildB").name == "buildB"
            assert gradle.includedBuild("buildB").projectDir == file('${buildB.toURI()}')
            assert gradle.includedBuild("buildC").name == "buildC"
            assert gradle.includedBuild("buildC").projectDir == file('${buildC.toURI()}')
            assert gradle.includedBuilds.name == ["buildB", "buildC"]
        """