std::vector<char> out;
  TF_EXPECT_OK(ReadCache(&cache1, want_filename, want_offset, want_n, &out));
  EXPECT_EQ(calls, 1);
  TF_EXPECT_OK(ReadCache(&cache2, want_filename, want_offset, want_n, &out));
  EXPECT_EQ(calls, 2);
  TF_EXPECT_OK(ReadCache(&cache3, want_filename, want_offset, want_n, &out));
  EXPECT_EQ(calls, 3);
  TF_EXPECT_OK(ReadCache(&cache4, want_filename, want_offset, want_n, &out));

    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()

	WriteConfig(file string, old, new []byte) error

	// ReadCache reads and returns the content of the named cache file.
	// Any returned error will be treated as equivalent to the file not existing.
	// There can be arbitrarily many cache files, such as:
	//	serverName/lookup/pkg@version
	//	serverName/tile/8/1/x123/456
	ReadCache(file string) ([]byte, error)

	// WriteCache writes the named cache file.

		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)

	return time.Since(c.startTime).Round(1 * time.Second)
}

// readCache creates a combined corpus from seed values and values in the cache
// (in GOCACHE/fuzz).
//
// TODO(fuzzing): need a mechanism that can remove values that
// aren't useful anymore, for example, because they have the wrong type.
func (c *coordinator) readCache() error {
	if _, err := c.addCorpusEntries(false, c.opts.Seed...); err != nil {

For example you may want to pass in a specific property value to control runtime behavior just for this one invocation of the build.
Properties in a build script can easily become a maintenance headache and convolute the build script logic.
The `gradle.properties` helps with keeping properties separate from the build script and should be explored as viable option.