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:

	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 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.

//
//
// The Expand/Squeeze combination is used to adapt a 3D array (such as in
// WaveNet) to the 4D arrays that Conv2D requires. Padding and BiasAdd are
// thrown in just for the extra headache. Padding adapts non-conforming input
// sizes, and can be discarded. The bias is necessary, so is kept.
template <typename Conv2dOpTy>
class ConvertTFDilatedConvOp : public OpRewritePattern<Conv2dOpTy> {
 private:

	// resulting executable under GDB, set a breakpoint in
	// "main.singleInstruction", then verify that GDB displays the
	// correct line/file information.  Given the headache and flakiness
	// associated with GDB-based tests these days, a direct read of
	// the line table seems more desirable.
	rows := []dwarf.LineEntry{}
	dw, err := f.DWARF()
	if err != nil {