$additionalTransformImpl
                    }
                }
            """
        }
    }

    def withJavaLibrarySubproject(TestFile projectDir) {
        projectDir.create {
            file("build.gradle") << """
                plugins { id("java-library") }
            """

            file("src/main/java/Foo.java") << """
                public class Foo {}

            Provider<List<Directory>> dirsFromFilteredFcMappedElements(FileCollection fc, Directory projectDir) {
                def root = layout.projectDirectory.asFile
                fc.filter { File f ->
                    f.isDirectory()
                }.elements.map {
                    it.collect { fileSystemLocation ->
                        projectDir.dir(fileSystemLocation.asFile.absolutePath)
                    }
                }

    }

    /**
     * Returns the default distribution to use for the specified project.
     */
    public Distribution getDefaultDistribution(File projectDir, boolean searchUpwards) {
        BuildLayout layout = new BuildLayoutFactory().getLayoutFor(projectDir, searchUpwards);
        WrapperExecutor wrapper = WrapperExecutor.forProjectDirectory(layout.getRootDirectory());
        if (wrapper.getDistribution() != null) {

     * Installs the distribution and returns the result.
     */
    public File install(File userHomeDir, File projectDir, WrapperConfiguration wrapperConfiguration, Map<String, String> systemProperties) throws Exception {
        Install install = new Install(new Logger(false), new AsyncDownload(systemProperties), new PathAssembler(userHomeDir, projectDir));
        return install.createDist(wrapperConfiguration);
    }

    /**

        prop = objects.directoryProperty()
    }
}

extensions.create('custom', SomeExtension)
custom.prop = layout.projectDir.dir("dir1")
assert custom.prop.get().asFile == file("dir1")

custom.prop = providers.provider { layout.projectDir.dir("dir2") }
assert custom.prop.get().asFile == file("dir2")

custom.prop = layout.buildDir.dir("dir3")
assert custom.prop.get().asFile == file("build/dir3")

    @ToBeFixedForConfigurationCache
    def "compiling project variant doesn't imply execution of other variants build tasks"() {
        testDirectory.mkdirs()
        def projectDir = new FileTreeBuilder(testDirectory)
        given:
        projectDir {
            VariantAwareResolutionWithConfigurationAttributesIntegrationTest.withVariants(buildFile)

        given:
        projectDir.createFile('settings.gradle') << """
            include ':sub1'
            include ':sub2'
        """
        projectDir.createFile('build.gradle')

        [projectDir.createDir('sub1'), projectDir.createDir('sub2')].eachWithIndex { TestFile it, def index ->
            it.file('build.gradle') << """

                }
            }

            task ok(type: SomeTask) {
                value = layout.projectDir.dir("dir1")
                propValue = layout.projectDir.dir("dir2")
            }
        """

        when:
        configurationCacheRun "ok"
        configurationCacheRun "ok"

        then:

        }
        if (specification.hasProperty("caughtGradleConnectionException")) {
            specification.caughtGradleConnectionException = null
        }
        if (specification.hasProperty("projectDir")) {
            specification.projectDir.listFiles().each {
                if (!FILES_TO_PRESERVE.contains(it.name)) {
                    it.deleteDir()
                }
            }

                BuildScriptBuilder moduleScriptBuilder = scriptBuilderFactory.scriptForMavenConversion(dsl, buildContentGenerationContext, RelativePathUtil.relativePath(workingDir.getAsFile(), projectDir(module)) + "/build", useIncubatingAPIs, insecureProtocolOption);

                moduleScriptBuilder.plugin(null, conventionPluginId);

                if (!module.getGroupId().equals(rootProject.getGroupId())) {