package org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts;

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.resource.cached.CachedItem;

import java.util.List;

public interface CachedArtifact extends CachedItem {
    HashCode getDescriptorHash();

    List<String> attemptedLocations();

        given:
        Serializer<CachedArtifact> valueSerializer = new DefaultModuleArtifactCache.CachedArtifactSerializer(commonRootPath)
        def encoder = Mock(Encoder)
        def cachedArtifact = Mock(CachedArtifact)

        when:
        valueSerializer.write(encoder, cachedArtifact)

        then:
        2 * cachedArtifact.isMissing() >> false
        1 * cachedArtifact.cachedAt >> 42L

        }
    }

    @Nullable
    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {
        CachedArtifact cachedArtifact = inMemoryCache.get(key);
        if (cachedArtifact == null && delegate != null) {
            cachedArtifact = delegate.lookup(key);
            if (cachedArtifact != null) {
                inMemoryCache.put(key, cachedArtifact);
            }
        }
        return cachedArtifact;
    }

        storeInternal(key, createMissingEntry(attemptedLocations, descriptorHash));
    }

    private CachedArtifact createMissingEntry(List<String> attemptedLocations, HashCode descriptorHash) {
        return new DefaultCachedArtifact(attemptedLocations, timeProvider.getCurrentTime(), descriptorHash);
    }

    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {
        assertKeyNotNull(key);

        writableCache.storeMissing(key, attemptedLocations, descriptorHash);
    }

    @Nullable
    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {
        CachedArtifact lookup = writableCache.lookup(key);
        if (lookup != null) {
            return lookup;
        }
        return readOnlyCache.lookup(key);
    }

    @Override

        operationShouldNotHaveBeenCalled();
    }

    @Override
    protected void storeInternal(ArtifactAtRepositoryKey key, CachedArtifact entry) {
        operationShouldNotHaveBeenCalled();
    }

    @Override
    public void clear(ArtifactAtRepositoryKey key) {

import org.gradle.internal.hash.HashCode;

import java.io.File;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;

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

        then:
        1 * writeCache.lookup(key) >> null
        1 * readCache.lookup(key)

        when:
        twoStageCache.lookup(key)

        then:
        1 * writeCache.lookup(key) >> Stub(CachedArtifact)
        0 * readCache._
    }

    def "clearing delegates to the writable cache"() {
        when:
        twoStageCache.clear(key)

        then:
        1 * writeCache.clear(key)

     *
     * @param key The key to search the index for
     * @return The cached artifact resolution if one exists, otherwise null.
     */
    @Nullable
    CachedArtifact lookup(ArtifactAtRepositoryKey key);

    /**
     * Remove the entry for the given key if it exists.
     *
     * @param key The key of the item to remove.
     */
    void clear(ArtifactAtRepositoryKey key);

import org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts.ArtifactAtRepositoryKey;
import org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts.CachedArtifact;
import org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts.CachedArtifacts;
import org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts.ModuleArtifactCache;