def "tracks access to looked up files"() {
        given:
        def cachedFile = temporaryFolder.createFile("foo.txt")

        when:
        cachedIndex.storeInternal("foo", cachedItem(cachedFile))
        def item = cachedIndex.lookup("foo")

        then:
        item.cachedFile == cachedFile
        1 * fileAccessTracker.markAccessed(cachedFile)
    }

    def "clears entries for deleted files"() {
        given:

    private final File cachedFile;
    private final long cachedAt;
    private final ExternalResourceMetaData externalResourceMetaData;

    public DefaultCachedExternalResource(File cachedFile, long cachedAt, ExternalResourceMetaData externalResourceMetaData) {
        this.cachedFile = cachedFile;
        this.cachedAt = cachedAt;

        def cachedFile = testDir.file("cached/beb67f2a57f2bd7d23946b93b19440d3/thing.jar")

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

        then:
        cachedClasspath.asFiles == [cachedFile]
        cachedFile.assertIsFile()

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

        cachedFile.absolutePath.startsWith(cacheDir.absolutePath)

        when:
        def loaded = cache.load(key) { input ->
            assert input.text == "foo"
        }
        then:
        1 * fileAccessTracker.markAccessed(cachedFile)
        loaded
    }

    def "handles storing twice"() {
        File cachedFile = null

        given:

            return source;
        }

        // Copy the file into the cache
        File cachedFile = new File(cacheDir, "o_" + sourceSnapshot.getHash().toString() + '/' + source.getName());
        if (!cachedFile.isFile()) {
            // Just copy the jar
            GFileUtils.copyFile(source, cachedFile);
        }
        return cachedFile;
    }

    @Override
    public ClasspathFileHasher getFileHasher() {

public class DefaultCachedArtifact implements CachedArtifact, Serializable {
    private final File cachedFile;
    private final long cachedAt;
    private final HashCode descriptorHash;
    private final List<String> attemptedLocations;

    public DefaultCachedArtifact(File cachedFile, long cachedAt, HashCode descriptorHash) {
        this.cachedFile = cachedFile;
        this.cachedAt = cachedAt;
        this.descriptorHash = descriptorHash;

        localCandidate.file >> candidate
        cached.cachedFile >> cachedFile
        0 * _._

        and:
        1 * fileStore.moveIntoCache(tempFile) >> localResource
        1 * index.store("thing", cachedFile, remoteMetaData)
        1 * fileRepository.resource(cachedFile, location.uri, remoteMetaData) >> resultResource
        0 * _._
    }

        """
        when:
        succeeds("extract")
        then:
        file("build/extract/hello.txt").text == "hello"
        cachedFile.assertExists()
        otherFile.assertDoesNotExist()

        when:
        // write into the directory used by the extracted zip file
        cachedFile.text = "some incorrect pre-existing pre-expanded content"
        otherFile.touch()

        and:
        succeeds "extract"

        _ * cachedArtifact.missing >> false
        File cachedFile = Stub(File) {
            exists() >> true
        }
        cachedArtifact.getCachedFile() >> cachedFile

        when:
        def fromCache = index.lookup(key)

        then:
        fromCache == cachedArtifact
        !fromCache.isMissing()
        fromCache.cachedFile == cachedArtifact.cachedFile
    }

        and:
        cached != null
        cached.cachedFile == artifactFile
        cached.cachedAt == 1234L
        cached.externalResourceMetaData == null
    }

    def "stores missing entry"() {
        when:
        index.storeMissing("key")

        then:
        def cached = index.lookup("key")

        and:
        cached != null
        cached.cachedFile == null
        cached.cachedAt == 1234L