File testFile = layout.buildDirectory.file(name).get().asFile
                execOperations.javaexec {
                    assert !(it instanceof ExtensionAware)
                    it.classpath(execClasspath)
                    it.mainClass = 'org.gradle.TestMain'
                    it.args layout.projectDirectory.asFile, testFile
                }

        this.delegate = Objects.requireNonNull(delegate, "delegate cannot be null");

        ArtifactRepositoryLayout layout = delegate.getLayout();
        repo = new LocalRepository(
                new File(delegate.getBasedir()),
                (layout != null) ? layout.getClass().getSimpleName() : "legacy");

        /*

import java.nio.file.Paths

// tag::simple-params[]
val collection: FileCollection = layout.files(
    "src/file1.txt",
    File("src/file2.txt"),
    listOf("src/file3.csv", "src/file4.csv"),
    Paths.get("src", "file5.txt")
)
// end::simple-params[]

file("src").mkdirs()
file("src/dir1").mkdirs()
file("src/file1.txt").mkdirs()
file("src2").mkdirs()
file("src2/dir1").mkdirs()
file("src2/dir2").mkdirs()

// tag::closure[]

                    '$buildDir.name'
                }
            }

            def service = gradle.sharedServices.registerIfAbsent('my', MyBuildService, {})
            layout.buildDirectory.set(
                layout.projectDirectory.dir(
                    service.map {
                        // intentionally capture the `project` object to force a cc failure
                        // in case this gets serialized

include::sample[dir="snippets/providers/services/groovy",files="build.gradle[tags=project-layout]"]
====

Here is an example using `javax.inject.Inject`:

====
include::sample[dir="snippets/providers/services/kotlin",files="build.gradle.kts[tags=project-layout-inject]"]
include::sample[dir="snippets/providers/services/groovy",files="build.gradle[tags=project-layout-inject]"]
====

// tag::inner-link-task-properties[]
def archivesDirPath = layout.buildDirectory.dir('archives')
// end::inner-link-task-properties[]

tasks.register('packageClasses', Zip) {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from compileJava
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register('nestedSpecs', Copy) {
    into layout.buildDirectory.dir("explodedWar")

        ArtifactRepositoryLayout layout = layouts.get(layoutId);

        checkLayout(id, layoutId, layout);

        return createArtifactRepository(id, url, layout, snapshots, releases);
    }

    private void checkLayout(String repositoryId, String layoutId, ArtifactRepositoryLayout layout)
            throws InvalidRepositoryException {
        if (layout == null) {

    testImplementation 'junit:junit:4.13'
}

// tag::configure-location-task[]
test {
    reports {
        junitXml.outputLocation = layout.buildDirectory.dir("test-junit-xml")
    }
}
// end::configure-location-task[]

// tag::configure-location-convention[]
java.testResultsDir = layout.buildDirectory.dir("junit-xml")
// end::configure-location-convention[]

// tag::configure-content[]
test {
    reports {

import org.gradle.cache.internal.CacheVersion
import org.gradle.util.GradleVersion
import spock.lang.Specification

class CacheLayoutTest extends Specification {

    def "use root layout"() {
        when:
        CacheLayout cacheLayout = CacheLayout.MODULES

        then:
        cacheLayout.name == 'modules'
        cacheLayout.key == 'modules-2'
        cacheLayout.version == CacheVersion.of(2)

plugins {
    id("gradlebuild.dependency-modules")
    kotlin("jvm")
}

// --- Enable automatic generation of API extensions -------------------
val apiExtensionsOutputDir = layout.buildDirectory.dir("generated-sources/kotlin")

val publishedKotlinDslPluginVersion = "4.4.0" // TODO:kotlin-dsl

tasks {
    val generateKotlinDependencyExtensions by registering(GenerateKotlinDependencyExtensions::class) {