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;

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

    public DefaultCachedExternalResource(long cachedAt) {
        this.cachedAt = cachedAt;

        this.cachedFile = null;
        this.externalResourceMetaData = null;

        then:
        def cached = index.lookup(key)

        and:
        cached != null
        cached.cachedFile == artifactFile
        cached.cachedAt == 1234L
        cached.externalResourceMetaData != null
        cached.externalResourceMetaData.lastModified == lastModified
        cached.externalResourceMetaData.location == new URI("abc")
        cached.externalResourceMetaData.contentType == contentType

            File cachedFile = null;
            if (decoder.readBoolean()) {
                cachedFile = denormalizeAndResolveFilePath(decoder.readString());
            }
            long cachedAt = decoder.readLong();
            ExternalResourceMetaData metaData = null;
            if (decoder.readBoolean()) {
                URI uri = new URI(decoder.readString());
                long lastModified = 0;

        then:
        1 * cacheAccessCoordinator.useCache(_) >> { Runnable action -> action.run() }
        1 * timeProvider.currentTime >> 123
        1 * persistentIndexedCache.put(key, _) >> { k, v ->
            assert v.cachedAt == 123
            assert v.descriptorHash == TestHashCodes.hashCodeFrom(10)
            assert v.cachedFile == testFile
        }
    }

    def "lookup key must not be null"() {
        when:

        then:
        result == resultResource

        and:
        1 * index.lookup("thing") >> cached
        timeProvider.currentTime >> 24000L
        cached.cachedAt >> 23999L
        cached.externalResourceMetaData >> cachedMetaData
        1 * repository.resource(location, true) >> remoteResource
        1 * remoteResource.metaData >> remoteMetaData

 * whose result must be cached even (or specially) at serialization time.
 *
 * @param <T> the resulting type
 */
public abstract class Cached<T> {

    public static <T> Cached<T> of(Callable<T> computation) {
        return new Deferred<>(computation);
    }

    public abstract T get();

    private static class Deferred<T> extends Cached<T> implements java.io.Serializable {

        urlIterator.remove()
      }
    }
```

### Troubleshooting

1. Valid cacheable responses are not being cached

Make sure you are reading responses fully as unless they are read fully, cancelled or stalled Responses will not be cached.

### Overriding normal cache behaviour

first-non-cached-task.png...

fully-cached-task-execution.png...