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

/**
 * A general purpose sink for a stream of messages.
 *
 * <p>Implementations are not required to be thread-safe.
 */
public interface Dispatch<T> {
    /**
     * Dispatches the next message. Blocks until the messages has been accepted but generally does not wait for the

        expect:
        def dispatch1 = BroadcastDispatch.empty(TestListener)
        dispatch1.removeAll([]).is(dispatch1)
        dispatch1.removeAll([listener2, listener3]).is(dispatch1)

        def dispatch2 = dispatch1.add(listener1)
        dispatch2.removeAll([]).is(dispatch2)
        dispatch2.removeAll([listener2, listener3]).is(dispatch2)

        def dispatch3 = dispatch2.add(listener2)

        then:
        1 * dispatch1.dispatch(invocation)
        then:
        1 * dispatch2.dispatch(invocation)
        0 * _._
    }

    def 'visit listeners does not visit dispatch instances'() {
        def dispatch = Mock(Dispatch)
        def visitor = Mock(Action)

        given:
        broadcast.add(dispatch)

        when:
        broadcast.visitListeners(visitor)

        then:

        then:
        1 * clientHandler.dispatch("message 1") >> { clientDispatch.dispatch("[message 1]") }
        1 * clientHandler.dispatch("message 2") >> { clientDispatch.dispatch("[message 2]") }
        1 * clientHandler.dispatch("message 3")
        1 * clientHandler.dispatch("message 4")
        1 * clientHandler.dispatch("message 5")
        1 * clientHandler.dispatch("message 6")

import org.gradle.internal.dispatch.AsyncDispatch;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.ExceptionTrackingFailureHandler;
import org.gradle.internal.dispatch.FailureHandlingDispatch;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;

 * limitations under the License.
 */

package org.gradle.internal.dispatch;

public class ContextClassLoaderDispatch<T> implements Dispatch<T> {
    private final Dispatch<? super T> dispatch;
    private final ClassLoader contextClassLoader;

    public ContextClassLoaderDispatch(Dispatch<? super T> dispatch, ClassLoader contextClassLoader) {
        this.dispatch = dispatch;
        this.contextClassLoader = contextClassLoader;
    }

        when:
        dispatch.dispatch("message")

        then:
        1 * target.dispatch("message")
    }

    def "notifies handler on failure"() {
        def failure = new RuntimeException()

        when:
        dispatch.dispatch("message")

        then:
        1 * target.dispatch("message") >> { throw failure }
        1 * handler.dispatchFailed("message", failure)
    }

        and:
        queue.dispatch(message1)
        queue.dispatch(message2)
        queue.dispatch(message3)

        when:
        def endpoint = queue.newEndpoint()
        def messages = []
        endpoint.take(messages)

        then:
        messages == [message1, message2, message3]
    }

    def "does not dispatch anything to endpoint that has stopped"() {
        given:

package org.gradle.internal.event;

import com.google.common.collect.ImmutableList;
import org.gradle.internal.Cast;
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.service.scopes.EventScope;
import org.gradle.internal.service.scopes.ListenerService;

        1 * connection.dispatch({it instanceof Stop})
        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        1 * connection2.dispatch({it instanceof Stop})
        1 * connection2.receive() >> new Success(null)
        1 * connection2.dispatch({it instanceof Finished})
        1 * connection2.stop()