def oldCacheDir = createVersionSpecificCacheDir(oldVersion, NOT_USED_WITHIN_30_DAYS)
        def oldDist = createDistributionChecksumDir(oldVersion).parentFile
        def currentDist = createDistributionChecksumDir(currentVersion).parentFile

        when:
        cleanupService.cleanup()

        then:
        oldCacheDir.assertDoesNotExist()
        oldDist.assertDoesNotExist()

        forceCleanup(gcFile)

        and:
        writeLastFileAccessTimeToJournal(resource.parentFile, daysAgo(DEFAULT_MAX_AGE_IN_DAYS_FOR_DOWNLOADED_CACHE_ENTRIES + 1))
        writeLastFileAccessTimeToJournal(files[0].parentFile, daysAgo(DEFAULT_MAX_AGE_IN_DAYS_FOR_DOWNLOADED_CACHE_ENTRIES + 1))
        writeLastFileAccessTimeToJournal(files[1].parentFile, daysAgo(DEFAULT_MAX_AGE_IN_DAYS_FOR_DOWNLOADED_CACHE_ENTRIES + 1))

        and:

        [included1, included2].each { File file ->
            file.parentFile.mkdirs()
            file.text = 'some text'
        }

        expect:
        fileTree.contains(included1)
        fileTree.contains(included2)
        !fileTree.contains(testDir)
        !fileTree.contains(included1.parentFile)
        !fileTree.contains(included2.parentFile)
        !fileTree.contains(new File(testDir, 'does not exist'))

        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._

        when:
        def cachedClasspath2 = transformer.transform(classpath, BuildLogic)

        then:
        cachedClasspath2.asFiles == [cachedFile]

        and:
        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._
    }

        }

        def currentCacheDir = createVersionSpecificCacheDir(GradleVersion.current(), daysToTriggerCleanup)
        def currentDist = createDistributionChecksumDir(GradleVersion.current()).parentFile

        when:
        succeeds("help")

        then:
        oldButRecentlyUsedGradleDist.assertAllDirsExist()
        oldNotRecentlyUsedGradleDist.assertAllDirsDoNotExist()

    def fixture = new ConfigurationCacheFixture(this)

    def "restores task fields whose value is a #kind Java lambda"() {
        given:
        file("buildSrc/src/main/java/my/LambdaTask.java").tap {
            parentFile.mkdirs()
            text = """
                package my;

                import org.gradle.api.*;
                import org.gradle.api.tasks.*;

                public class LambdaTask extends DefaultTask {

        assertEquals('..', baseDirConverter.resolveAsRelativePath(baseDir.parentFile))
        assertEquals('..', baseDirConverter.resolveAsRelativePath('..'))

        assertEquals('..', baseDirConverter.resolveForDisplay(baseDir.parentFile))
    }

    @Test public void testAncestorToRelativePath() {
        def ancestor = baseDir.parentFile.parentFile

        for (SourceFolder folder : externalSourceFolders) {
            folder.trim();
            File parentFile = folder.getDir().getParentFile();
            while (givenSources.contains(folder.getName()) && parentFile != null) {
                folder.trim(parentFile.getName());
                parentFile = parentFile.getParentFile();
            }
            givenSources.add(folder.getName());

configurations {
    conf
}
dependencies {
    conf 'org.test:dep1:1.0'
}

configurations.conf.incoming.beforeResolve { resolvableDependencies ->
    project.dependencies.add('conf', 'org.test:dep2:1.0')
}

task printFiles {
    def conf = configurations.conf
    doLast {
        def files = conf.collect { it.name }
        println files
        assert files == ['dep1-1.0.jar', 'dep2-1.0.jar']
    }
}

        given:
        def jarDir = new File(getProject().getProjectDir(), "lib")
        jarDir.mkdirs()
        def parentFile = expectedTargetWrapperJar.getParentFile()

        expect:
        parentFile.isDirectory() || parentFile.mkdirs()
        expectedTargetWrapperJar.createNewFile()

        when:
        def unjarDir = temporaryFolder.createDir("unjar")
        execute(wrapper)