/**
 * A decorated domain object type may optionally implement this interface to dynamically expose methods 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 methods. That is, methods such as methodMissing() will be ignored.
 */
public interface MethodMixIn {
    MethodAccess getAdditionalMethods();

    .build()

private fun testClient(
  urls: List<String>,
  client: OkHttpClient,
) {
  try {
    for (url in urls) {
      sendRequest(client, url)
    }
  } finally {
    client.dispatcher.executorService.shutdownNow()
    client.connectionPool.evictAll()
  }
}

private fun buildClient(vararg specs: ConnectionSpec): OkHttpClient {
  return OkHttpClient.Builder()
    .connectionSpecs(listOf(*specs))

	// If not specified, the pod will not have a domainname at all.
	// +optional
	Subdomain string
	// If specified, the pod will be dispatched by specified scheduler.
	// If not specified, the pod will be dispatched by default scheduler.
	// +optional
	SchedulerName string
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// PodList is a list of Pods.

        file("settings.gradle") << "// empty"
        def projectdir = file("project dir").createDir()

        //requesting x failing builds creates enough stress to expose issues with unsynchronized dispatch
        50.times {
            executer.usingProjectDirectory(projectdir)
                    .withTasks("tasks")
                    .runWithFailure()
        }
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.event;

import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

import javax.annotation.Nullable;

/**

    # package for your domain name, e.g. com.example
    ; domainPackage = org.codelibs.fess

    # keywords for environment properties, same as directory name
    ; environmentList = list:{}

    # environment dispatch by lasta.env of system property?
    ; isUseLastaEnv = false

    # settings for web applications
    ; appMap = map:{
        ; fess = map:{
            ; path = ..

    private final BlockingQueue<InterHubMessage> outgoing = new LinkedBlockingQueue<>()
    private final BlockingQueue<InterHubMessage> outgoingBuffered = new LinkedBlockingQueue<>()

    @Override
    void dispatch(InterHubMessage message) {
        outgoingBuffered.put(message)
    }

    @Override
    void flush() {
        outgoingBuffered.drainTo(outgoing)
    }

    @Override
    InterHubMessage receive() {

    val headers: Headers? = part.headers()
    val body: RequestBody = part.body()
  }

  @Test @Disabled
  fun okHttpClient() {
    val client = OkHttpClient()
    val dispatcher: Dispatcher = client.dispatcher()
    val proxy: Proxy? = client.proxy()
    val protocols: List<Protocol> = client.protocols()
    val connectionSpecs: List<ConnectionSpec> = client.connectionSpecs()

        ConnectionState state = new ConnectionState(this, connection, queue);
        connections.add(state);
        return state;
    }

    /**
     * Called when all dispatch and receive has completed on the given connection.
     */
    public void finished(ConnectionState connectionState) {
        connections.remove(connectionState);
        if (stopping) {
            maybeStop();

        }
    }

    @Override
    public void dispatch(Object value) {
        SerializedPayload serializedModel = payloadSerializer.serialize(value);
        StreamedValue streamedValue = new StreamedValue(serializedModel);
        BuildEventConsumer buildEventConsumer = this.buildEventConsumer;
        sideEffectExecutor.runIsolatableSideEffect(() -> buildEventConsumer.dispatch(streamedValue));
    }