new File(it, "transforms")
        }

        (oldCaches + newCaches).forEach {
            cleanupCacheDir(it)
        }
    }

    protected void cleanupCacheDir(File cacheDir) {
        Files.walkFileTree(cacheDir.toPath(), new FileVisitor<Path>() {
            @Override
            FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {

            }
        }
    }

    def "can be used to disable storing task in build cache"() {
        given:
        def cacheDir = createDir("cache-dir")
        settingsFile << """
            buildCache {
                local {
                    directory = file("${cacheDir.name}")
                }
            }
        """
        buildFile << """
            plugins {
                id 'java'

    @TempDir
    File cacheDir

    private final FileResolver resolver = Mock() {
        getPatternSetFactory() >> TestFiles.getPatternSetFactory()
    }
    private final TemporaryFileProvider temporaryFileProvider = new DefaultTemporaryFileProvider(() -> cacheDir);
    private final Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()

            def projectTestDir = new TestFile(projectDir)
            def cacheDir = projectTestDir.file('local-build-cache')
            def settingsFile = projectTestDir.file('settings.gradle')
            settingsFile << """
                    buildCache {
                        local {
                            directory = '${cacheDir.absoluteFile.toURI()}'
                        }
                    }

@ServiceScope(Scope.Global.class)
public interface CacheFactory {
    /**
     * Opens a cache with the given options. The caller must close the cache when finished with it.
     */
    PersistentCache open(File cacheDir, String displayName, Map<String, ?> properties, LockOptions lockOptions, @Nullable Consumer<? super PersistentCache> initializer, CacheCleanupStrategy cacheCleanupStrategy) throws CacheOpenException;

    /**

                }
            }
        """
    }

    private void withLocalBuildCache() {
        def cacheDir = createDir("cache-dir")
        settingsFile """
            buildCache {
                local {
                    directory = file("${cacheDir.name}")
                }
            }
        """
    }

    /**
     * Sets the path to the read-only dependency cache
     *
     * @param cacheDir the path to the RO dependency cache
     * @return this executer
     */
    GradleExecuter withReadOnlyCacheDir(File cacheDir);

    /**
     * Sets the path to the read-only dependency cache
     *
     * @param cacheDir the path to the RO dependency cache
     * @return this executer
     */

        Deleter deleter,
        BuildOperationRunner buildOperationRunner,
        StartParameter startParameter
    ) {
        BuildScopeCacheDir cacheDir = new BuildScopeCacheDir(userHomeDirProvider, buildLayout, startParameter);
        return new ProjectCacheDir(cacheDir.getDir(), buildOperationRunner, deleter);
    }

    @Provides

    void "cache handles manual deletion of cached artifacts"() {
        given:
        def module = ivyHttpRepo.module('group', 'projectA', '1.2').publish()

        def cacheDir = getUserHomeCacheDir().toURI()

        and:
        buildFile << """
repositories {
    ivy { url "${ivyHttpRepo.uri}" }
}
configurations { compile }
dependencies { compile 'group:projectA:1.2' }

        buildFile << defineCacheableTask()
        withBuildCache()
        succeeds "cacheable", "--info"

        expect:
        outputContains "Using local directory build cache for the root build (location = ${cacheDir}, removeUnusedEntriesAfter = 7 days)."
    }

    def "cache entry contains expected contents"() {
        buildFile << defineCacheableTask()
        when:
        withBuildCache().run("cacheable")
        then: