return false
        }

        1 * connection.dispatch({ it instanceof Build })
        2 * connection.receive() >>> [Stub(BuildStarted), new Failure(new DaemonStoppedException())]
        1 * connection.dispatch({ it instanceof Cancel })
        1 * connection.dispatch({ it instanceof CloseInput })
        1 * connection.dispatch({ it instanceof Finished })
        1 * cancellationToken.cancellationRequested >> true

 * using a lock, however it is dangerous to dispatch listeners while holding a lock because they
 * might run on the {@code directExecutor()} or be otherwise re-entrant (call back into your
 * object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision

 * limitations under the License.
 */

package org.gradle.listener;

import groovy.lang.Closure;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;

import java.util.Arrays;

public class ClosureBackedMethodInvocationDispatch implements Dispatch<MethodInvocation> {
    private final String methodName;
    private final Closure closure;

        "no argument"           | "Groovy dynamic dispatch" | { test() }                                | true           | "test()"
        "one argument"          | "Groovy dynamic dispatch" | { test(it) }                              | true           | "test(InterceptorTestReceiver)"
        "one null argument"     | "Groovy dynamic dispatch" | { test(null) }                            | true           | "test(InterceptorTestReceiver)"

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.BoundedDispatch;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;
import org.gradle.internal.dispatch.ReflectionDispatch;
import org.gradle.internal.dispatch.StreamCompletion;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

 */

package org.gradle.internal.actor;

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;
import org.gradle.internal.dispatch.ReflectionDispatch;

public class TestActorFactory implements ActorFactory {
    @Override
    public Actor createActor(Object target) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.queue;

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;

import java.util.ArrayDeque;
import java.util.ArrayList;

        if (event.getLogLevel() == null) {
            dispatch(event, stdoutChain);
            dispatch(event, stderrChain);
        } else if (event.getLogLevel() == LogLevel.ERROR) {
            dispatch(event, stderrChain);
        } else {
            dispatch(event, stdoutChain);
        }
    }

    protected void dispatch(OutputEvent event, OutputEventListener listener) {
        if (listener != null) {

        return daemon;
    }

    @Override
    public void dispatch(Message message) throws DaemonConnectionException {
        LOG.debug("thread {}: dispatching {}", Thread.currentThread().getId(), message.getClass());
        try {
            dispatchLock.lock();
            try {
                connection.dispatch(message);
                connection.flush();
            } finally {

 * using a lock, however it is dangerous to dispatch listeners while holding a lock because they
 * might run on the {@code directExecutor()} or be otherwise re-entrant (call back into your
 * object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision