}
}

func (b *B) startit() chan<- struct{} {
	stop := make(chan struct{})
	b.wg.Add(1)
	go func() {
		defer b.wg.Done()
		var v uint64
		for {
			select {
			case <-stop:
				b.v = v
				return
			case <-time.After(1 * time.Millisecond):
				r, err := b.f()
				if err != nil {
					panic("bad")
				}
				v = r
			}
		}
	}()
	return stop
}

var S, G int

//go:noinline

        when:
        handler.reservePort()
        handler.start(10, {})
        handler.stop()

        then:
        1 * factory.create(_ as String) >> lockRequestListener
        1 * factory.create(_ as String) >> releaseLockActionExecutor
        1 * lockRequestListener.stop()
        1 * releaseLockActionExecutor.stop()
    }

    def "stopping is safe even if the handler was not initialized"() {
        when:

	// The channel should not be waited on after Stop() is invoked. It is allowed
	// to cache the returned value of C() for the lifetime of the Timer.
	C() <-chan time.Time
	// Next is invoked by wait functions to signal timers that the next interval
	// should begin. You may only use Next() if you have drained the channel C().
	// You should not call Next() after Stop() is invoked.
	Next()

func Reset(sig ...os.Signal) {
	cancel(sig, disableSignal)
}

// Stop causes package signal to stop relaying incoming signals to c.
// It undoes the effect of all prior calls to [Notify] using c.
// When Stop returns, it is guaranteed that c will receive no more signals.
func Stop(c chan<- os.Signal) {
	handlers.Lock()

	h := handlers.m[c]
	if h == nil {
		handlers.Unlock()
		return

        start(cacheAccessWorker)
        async {
            thread.blockUntil.waiting
            cacheAccessWorker.stop()
        }

        then:
        def e = thrown(RuntimeException)
        e == failure

        cleanup:
        cacheAccessWorker?.stop()
    }

    def "stop rethrows action failure"() {
        def failure = new RuntimeException()
        cacheAccessWorker.enqueue { throw failure }

        when:
        redirector.redirectStandardErrorTo(stdErrListener)
        redirector.start()
        redirector.stop()
        redirector.redirectStandardOutputTo(stdOutListener)
        redirector.start()
        System.out.println('this is stdout')
        System.err.println('this is stderr')
        redirector.stop()

        then:
        1 * stdOutListener.onOutput('this is stdout' + EOL)
        0 * stdOutListener._

        when:
        connectionBuilder.addIncoming(Worker, worker)
        connectionBuilder.connect()
        connection.stop()
        connectionBuilder.stop()

        then:
        1 * worker.doStuff("param 1")
        0 * worker._

        cleanup:
        connection?.stop()
        connectionBuilder?.stop()
    }

    def "cannot add incoming message handler on established connections"() {
        def worker = Mock(Worker)

        proxy.doStuff('param')
        operation.stop {
            factory.stop()
        }

        then:
        operation.stop.end > instant.actionFinished
    }

    def cannotDispatchToBlockingActorAfterItHasBeenStopped() {
        def actor = factory.createBlockingActor(target)
        def proxy = actor.getProxy(TargetObject.class)

        given:
        actor.stop()

        when:

        0 * stdOutLoggingSystem._
        0 * stdErrLoggingSystem._

        when:
        loggingManager.stop()

        then:
        1 * stdOutLoggingSystem.restore(stdOutSnapshot)
        1 * stdErrLoggingSystem.restore(stdErrSnapshot)
    }

    public void "can start and stop with system capture enabled"() {
        loggingManager.captureSystemSources()

    private final AtomicBoolean stop;

    public DefaultFileVisitDetails(File file, RelativePath relativePath, AtomicBoolean stop, Chmod chmod, Stat stat) {
        super(file, relativePath, chmod, stat);
        this.stop = stop;
    }

    @Override
    public void stopVisiting() {
        stop.set(true);
    }