abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse {
    return MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }
  }

  open fun shutdown() {}

				return len(events) == 0
			}()
		}
	}()
	return b.delegateBackend.Run(stopCh)
}

// Shutdown blocks until stopCh passed to the Run method is closed and all
// events added prior to that moment are batched and sent to the delegate backend.
func (b *bufferedBackend) Shutdown() {
	// Wait until the routine spawned in Run method exits.
	<-b.shutdownCh

	// Wait until all sending routines exit.
	//

	envoyPrometheusPort int,
	enableProfiling bool,
	agent *istioagent.Agent,
	shutdown context.CancelFunc,
) error {
	o := options.NewStatusServerOptions(proxyArgs.IsIPv6(), proxyArgs.Type, proxyConfig, agent)
	o.EnvoyPrometheusPort = envoyPrometheusPort
	o.EnableProfiling = enableProfiling
	o.Context = ctx
	o.Shutdown = shutdown
	statusServer, err := status.NewServer(*o)
	if err != nil {
		return err
	}

        given:
        // Start a daemon
        executer.run()
        daemons.daemon.assertIdle()
        // Kill the daemon without letting it shutdown cleanly
        daemons.daemon.kill()

        // Take over the daemon's port. The daemon may take some time to finally shutdown and release the port.
        def nonDaemonProcess = new ServerSocket()
        ConcurrentTestUtil.poll {

 */
package org.codelibs.fess.job;

public abstract class JobExecutor {
    protected ShutdownListener shutdownListener;

    public abstract Object execute(String scriptType, String script);

    public void shutdown() {
        shutdownListener.onShutdown();
    }

    public void addShutdownListener(final ShutdownListener listener) {
        shutdownListener = listener;
    }

    public interface ShutdownListener {

    proceed.countDown()
    t1.join()
    assertThat(idle.get()).isTrue()
  }

  @Test
  fun executionRejectedImmediately() {
    val request = newRequest("http://a/1")
    executor.shutdown()
    client.newCall(request).enqueue(callback)
    callback.await(request.url).assertFailure(InterruptedIOException::class.java)
    assertThat(listener.recordedEventTypes())

                    textOut.style(UserInput).text(iteration).style(Normal)
                    textOut.println()
                }
            }
        }

        executor.shutdown()
        executor.awaitTermination(30, TimeUnit.SECONDS)
    }

        super(delegate, modelMapping, adapter);
    }

    @Override
    public void stop() {
        ((StoppableConnection) getDelegate()).shutdown(new ShutdownParameters() { });
    }

public interface GroovySystemLoader {
    /**
     * Invoked when this Groovy system is to be discarded, so that the Groovy system can remove any static state it may have registered in other ClassLoaders.
     */
    void shutdown();

    /**
     * Invoked when another ClassLoader is discarded, so that this Groovy system can remove state for the classes loaded from the ClassLoader
     */
    void discardTypesFrom(ClassLoader classLoader);

// namespace, and a shutdown boolean.  If not shutdown then the return
// must eventually be followed by a call on completeWork for the
// returned namespace (regardless of whether the work item list is
// empty).
func (e *quotaEvaluator) getWork() (string, []*admissionWaiter, bool) {
	ns, shutdown := e.queue.Get()
	if shutdown {
		return "", []*admissionWaiter{}, shutdown
	}

	e.workLock.Lock()