1 * writeIndex.store("key", artifact, metadata)
        0 * readIndex._
    }

    def "store missing delegates to the write index"() {
        when:
        twoStageIndex.storeMissing("key")

        then:
        1 * writeIndex.storeMissing("key")
        0 * readIndex._
    }

    def "lookup searches the write index then delegates to the read index"() {
        when:
        twoStageIndex.lookup("key")

            return;
        }
        writableCache.store(key, artifactFile, metaData);
    }

    @Override
    public void storeMissing(String key) {
        writableCache.storeMissing(key);
    }

    @Nullable
    @Override
    public CachedExternalResource lookup(String key) {
        CachedExternalResource lookup = writableCache.lookup(key);

            return;
        }
        writableCache.store(key, artifactFile,  moduleDescriptorHash);
    }

    @Override
    public void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash) {
        writableCache.storeMissing(key, attemptedLocations, descriptorHash);
    }

    @Nullable
    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {

        }
    }

    @Override
    public void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash) {
        inMemoryCache.put(key, new DefaultCachedArtifact(attemptedLocations, timeProvider.getCurrentTime(), descriptorHash));
        if (delegate != null) {
            delegate.storeMissing(key, attemptedLocations, descriptorHash);
        }
    }

    @Nullable

        0 * readCache._
    }

    def "store missing delegates to the write index"() {
        when:
        twoStageCache.storeMissing(key, ["abc"], hashCode)

        then:
        1 * writeCache.storeMissing(key, ["abc"], hashCode)
        0 * readCache._
    }

    def "lookup searches the write index then delegates to the read index"() {
        when:

     * @see #storeMissing(Object)
     */
    void store(K key, File artifactFile, @Nullable ExternalResourceMetaData metaData);

    /**
     * Record that the artifact with the given key was missing.
     *
     * @param key The key to cache this resolution under in the index.
     */
    void storeMissing(K key);

    /**
     * Lookup a cached resolution.
     *

     * Record that the artifact with the given key was missing.
     *  @param key The key to cache this resolution under in the index.
     * @param descriptorHash The SHA1 hash of the related moduleDescriptor
     */
    void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash);

    /**
     * Lookup a cached resolution.
     *

    }

    @Override
    public void store(ArtifactAtRepositoryKey key, File artifactFile, HashCode moduleDescriptorHash) {
        operationShouldNotHaveBeenCalled();
    }

    @Override
    public void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash) {
        operationShouldNotHaveBeenCalled();
    }

    @Override

        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

        assertArtifactFileNotNull(artifactFile);
        assertKeyNotNull(key);

        storeInternal(key, createEntry(artifactFile, externalResourceMetaData));
    }

    @Override
    public void storeMissing(K key) {
        storeInternal(key, new DefaultCachedExternalResource(timeProvider.getCurrentTime()));
    }

    @VisibleForTesting