}

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()
      if (call.request.url.toString() == url) {
        i.remove()
        dispatcherTest.dispatcher.finishedAccessor(call)
        return
      }
    }
    throw AssertionError("No such job: $url")
  }

  override fun shutdown() {
    shutdown = true
  }

 *
 * @since 8.6
 */
public interface InternalStreamedValueRelay {
    /**
     * Asynchronously sends an object back to the client application.
     *
     * @since 8.6
     */
    void dispatch(Object value);

/**
 * A decorated domain object type may optionally implement this interface to dynamically expose properties in addition to those declared statically on the type.
 *
 * Note that when a type implements this interface, dynamic Groovy dispatch will not be used to discover opaque properties. That is, methods such as propertyMissing() will be ignored.
 */
public interface PropertyMixIn {
    PropertyAccess getAdditionalProperties();

    private val writeContext: DefaultWriteContext
) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks
        // in case there was still an event being dispatched at closing time.
        synchronized(writeContext) {
            unsafeWrite(null)
            writeContext.close()
        }
    }

    fun write(value: T, trace: PropertyTrace? = null) {

	Queues                     []QueueDump
	QueuelessExecutingRequests []RequestDump
	Waiting                    int
	Executing                  int
	SeatsInUse                 int
	SeatsWaiting               int
	Dispatched                 int
	Rejected                   int
	Timedout                   int
	Cancelled                  int
}

// QueueDump is an instant dump of one queue in a queue-set.
type QueueDump struct {

 * **CipherSuite**: javaName
 * **ConnectionSpec**: cipherSuites, supportsTlsExtensions, tlsVersions
 * **Cookie**: domain, expiresAt, hostOnly, httpOnly, name, path, persistent, value
 * **Dispatcher**: executorService
 * **FormBody**: size
 * **Handshake**: cipherSuite, localCertificates, localPrincipal, peerCertificates, peerPrincipal,
   tlsVersion
 * **HandshakeCertificates**: keyManager, trustManager

	fcrequest "k8s.io/apiserver/pkg/util/flowcontrol/request"
)

// NewNoRestraintFactory makes a QueueSetFactory that produces
// QueueSets that exert no restraint --- every request is dispatched
// for execution as soon as it arrives.
func NewNoRestraintFactory() fq.QueueSetFactory {
	return noRestraintFactory{}
}

type noRestraintFactory struct{}

type noRestraintCompleter struct{}

        .singleOrNull()
}

/**
 * Implicit dispatch receiver is present when an extension function declared in object
 * is imported somewhere else and used without directly referencing the object instance
 * itself:
 *
 * ```kt
 * import Foo.bar
 *
 * object Foo { fun String.bar() {} }
 *
 * fun usage() {
 *   "hello".bar() // this call has implicit 'Foo' dispatch receiver
 * }
 * ```
 */

        super(buildController, adapter, modelMapping, gradleVersion, rootDir);
        this.relay = (InternalStreamedValueRelay) buildController;
    }

    @Override
    public <T> void send(T value) {
        relay.dispatch(value);
    }

        Provider<T> p = scope((Key<T>) k, up);
        return p::get;
    }

    @SuppressWarnings("unchecked")
    private <T> T createProxy(Key<T> key, Provider<T> unscoped) {
        InvocationHandler dispatcher = (proxy, method, args) -> {
            method.setAccessible(true);
            try {
                return method.invoke(getScopeState().scope(key, unscoped).get(), args);