//		If printed, the result of the index operation is the string
//		"<no value>".
//	"missingkey=zero"
//		The operation returns the zero value for the map type's element.
//	"missingkey=error"
//		Execution stops immediately with an error.
func (t *Template) Option(opt ...string) *Template {
	t.init()
	for _, s := range opt {
		t.setOption(s)
	}
	return t
}

func (t *Template) setOption(opt string) {
	if opt == "" {

     * @return The proxy.
     */
    <T> T getProxy(Class<T> type);

    /**
     * Stops accepting new method calls, and blocks until all method calls have been executed by the target object.
     *
     * @throws DispatchException When there were any failures dispatching method calls to the target object.
     */
    @Override
    void stop() throws DispatchException;

	return Option{
		InitialInterval: defaultInitialInterval,
		MaxInterval:     defaultMaxInterval,
	}
}

// NewExponentialBackOff creates an istio wrapped ExponentialBackOff.
// By default, it never stops.
func NewExponentialBackOff(o Option) BackOff {
	b := ExponentialBackOff{}
	b.exponentialBackOff = backoff.NewExponentialBackOff()
	b.exponentialBackOff.InitialInterval = o.InitialInterval

# Test that when the coordinator experiences an I/O error communicating
# with a worker, the coordinator stops the worker and reports the error.
# The coordinator should not record a crasher.
#
# We simulate an I/O error in the test by writing garbage to fuzz_out.
# This is unlikely, but possible. It's difficult to simulate interruptions
# due to ^C and EOF errors which are more common. We don't report those.
[short] skip
[!fuzz] skip
env GOCACHE=$WORK/cache

//		If printed, the result of the index operation is the string
//		"<no value>".
//	"missingkey=zero"
//		The operation returns the zero value for the map type's element.
//	"missingkey=error"
//		Execution stops immediately with an error.
func (t *Template) Option(opt ...string) *Template {
	t.text.Option(opt...)
	return t
}

// checkCanParse checks whether it is OK to parse templates.
// If not, it returns an error.

    long getLogLineCount() {
        return daemonLog.lines().withCloseable { lines -> lines.count() }
    }

    DaemonFixture becomesIdle() {
        waitForState(Idle)
        this
    }

    DaemonFixture stops() {
        waitForState(Stopped)
        this
    }

    @Override
    void assertIdle() {
        assertHasState(Idle)
    }

    @Override
    void assertBusy() {
        assertHasState(Busy)

        when:
        addSnapshot(snapshotRegularFile(fileInWatchableHierarchy))
        then:
        1 * watcher.startWatching({ equalIgnoringOrder(it, [watchableHierarchy]) })
    }

    def "starts and stops watching hierarchies to watch"() {
        def watchableHierarchies = ["first", "second", "third"].collect { file(it).createDir() }

        when:
        registerWatchableHierarchies(watchableHierarchies)
        then:

}

// ResultChan returns a channel which will receive filtered events.
func (fw *filteredWatch) ResultChan() <-chan Event {
	return fw.result
}

// Stop stops the upstream watch, which will eventually stop this watch.
func (fw *filteredWatch) Stop() {
	fw.incoming.Stop()
}

// loop waits for new values, filters them, and resends them.
func (fw *filteredWatch) loop() {
	defer close(fw.result)

        watchingVirtualFileSystem.afterBuildFinished()
        then:
        0 * _

        watchingVirtualFileSystem.root == emptySnapshotHierarchy
    }

    def "stops the watchers before the build when watching is disabled"() {
        when:
        watchingVirtualFileSystem.afterBuildStarted(WatchMode.ENABLED, VfsLogging.NORMAL, WatchLogging.NORMAL, buildOperationRunner)
        then:

	# At that point, we expect the subprocess to print 'stdin closed'
	# and periodically log to stderr until the WaitDelay expires.
	#
	# Once the WaitDelay expires, the copying goroutine for 'go test' stops and
	# closes the read side of the stderr pipe, and the subprocess will eventually
	# exit due to a failed write to that pipe.

stdout '^--- PASS: TestOrphanCmd .*\nPASS\nstdin closed'