out2 = file("file2.txt")
            }
            tasks.register("b", InputFileTask) {
                def projectLayout = project.layout
                inFile = provider.map { projectLayout.projectDir.file(it.out1.absolutePath) }
                outFile = file("out.txt")
            }
        """

        when:
        run("b")

        then:
        result.assertTasksExecuted(":a", ":b")

        compile.sourceCompatibility == project.sourceCompatibility.toString()

        def test = project.task('customTest', type: Test.class)
        test.workingDir == project.projectDir
        test.reports.junitXml.outputLocation.get().asFile == new File(project.testResultsDir, 'customTest')
        test.reports.html.outputLocation.get().asFile == new File(project.testReportDir, 'customTest')

${artifactTransform("AarDebug", "debug")}
${artifactTransform("AarClasses", "classes")}

def buildType = Attribute.of('buildType', String)
def artifactType = Attribute.of('artifactType', String)

projectDir.mkdirs()
def jar1 = file('lib1.jar')
jar1.text = 'some text'

configurations {
    compile
}

dependencies {
    attributesSchema {
        attribute(buildType)
    }

class ProjectScope(
    private val basePath: String
) {
    fun subproject(projectName: String) {
        include(projectName)
        project(":$projectName").projectDir = file("$basePath/$projectName")
    }
}

class ElementId(val id: String) : Serializable {
    override fun toString(): String {
        return id
    }
}

sealed class ArchitectureElement(

    def setup() {
        def problemEmitter = Stub(ProblemEmitter)
        def problems = new DefaultProblems(problemEmitter)

        File testProjectDir = tmpDir.createDir("projectDir")
        importsReader = Stub(ImportsReader.class)
        scriptCompilationHandler = new DefaultScriptCompilationHandler(
            TestFiles.deleter(),
            importsReader
        ) {

"${<obj>.<name>}"           // Same as previous (embedded value)

[source,groovy]
.Examples
----
version = '1.0.1'
myCopyTask.description = 'Copies some files'

file("$projectDir/src")
println "Destination: ${myCopyTask.destinationDir}"
----

				if err != nil {
					errlist = append(errlist, err)
					continue
				}
			} else {
				errlist = append(errlist, fmt.Errorf("ClusterTrustBundle projection requires either name or signerName to be set"))
				continue
			}

			mode := *s.source.DefaultMode
			if mounterArgs.FsUser != nil || mounterArgs.FsGroup != nil {
				mode = 0600
			}

        delegate.properties

    override fun absoluteProjectPath(path: String): String =
        delegate.absoluteProjectPath(path)

    override fun getProjectDir(): File =
        delegate.projectDir

    override fun files(vararg paths: Any?): ConfigurableFileCollection =
        delegate.files(*paths)

    override fun files(paths: Any, configureClosure: Closure<*>): ConfigurableFileCollection =

            doLast {
                outputFile.parentFile.mkdirs()
                outputFile.text = "OK"
            }
        }

        task a {
            dependsOn before
            inputs.dir projectDir
            outputs.files "build/output"
            doLast {}
        }
        """

        expect:
        succeeds("a")
        executedAndNotSkipped(":a")

        when:

                throw new IllegalArgumentException(identityPath.getPath() + " not found.");
            }
            return projectState;
        }
    }

    @Override
    public BuildProjectRegistry projectsFor(BuildIdentifier buildIdentifier) throws IllegalArgumentException {
        synchronized (lock) {
            BuildProjectRegistry registry = projectsByBuild.get(buildIdentifier);
            if (registry == null) {