def timeProvider = Stub(BuildCommencedTimeProvider)
    def readCache = Mock(AbstractArtifactsCache)
    def writeCache = Mock(AbstractArtifactsCache)
    def key = Stub(ArtifactsAtRepositoryKey)

    @Subject
    TwoStageArtifactsCache twoStageArtifactsCache = new TwoStageArtifactsCache(timeProvider, readCache, writeCache)

    def "reads first in write cache then in read cache"() {
        when:

        0 * readCache._
    }

    def "reading from write cache then read cache"() {
        when:
        twoStageCache.get(key)

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

        when:
        twoStageCache.get(key)

        then:
        1 * writeCache.get(key) >> metadata
        0 * readCache._
    }

    File artifact = Stub(File)
    HashCode hashCode = Stub(HashCode)
    def key = Stub(ArtifactAtRepositoryKey)

    def readCache = Mock(ModuleArtifactCache)
    def writeCache = Mock(ModuleArtifactCache)

    @Subject
    def twoStageCache = new TwoStageModuleArtifactCache(readOnlyPath, readCache, writeCache)

    def "storing delegates to the write index"() {
        when:
        twoStageCache.store(key, artifact, hashCode)

    def timeProvider = Stub(BuildCommencedTimeProvider)
    def readCache = Mock(AbstractModuleVersionsCache)
    def writeCache = Mock(AbstractModuleVersionsCache)
    def key = Stub(ModuleAtRepositoryKey)
    def entry = Stub(ModuleVersionsCacheEntry)

    @Subject
    def twoStageCache = new TwoStageModuleVersionsCache(timeProvider, readCache, writeCache)

    def "writing delegates to write cache"() {
        when:

	cmd.Stderr = os.Stderr
	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
	return cmd.Run()
}

// readCache repeatedly globs for go.mod files in the given cache, then opens
// those files for reading. When the done chan is closed, readCache closes
// files and returns.
func readCache(gopath string, done <-chan struct{}) {
	files := make(map[string]*os.File)
	defer func() {
		for _, f := range files {
			f.Close()

		return err
	}
	if _, err := f.Write(new); err != nil {
		return err
	}
	return f.Close()
}

// ReadCache reads cached lookups or tiles from
// GOPATH/pkg/mod/cache/download/sumdb,
// which will be deleted by "go clean -modcache".
func (*dbClient) ReadCache(file string) ([]byte, error) {
	targ := filepath.Join(cfg.GOMODCACHE, "cache/download/sumdb", file)
	data, err := lockedfile.Read(targ)