// Remove
        empty.add(listener).remove(listener).empty
        empty.add(listener).removeAll([listener, listener]).empty
        empty.add(other1).add(listener).remove(listener).remove(other1).empty
        empty.add(other1).add(listener).removeAll([listener, listener]).remove(other1).empty
        empty.add(other1).add(other2).add(listener).remove(listener).removeAll([other1, other2]).empty

        0 * _._
    }

    def 'listener can add another listener'() {
        given:
        TestListener listener1 = Mock()
        TestListener listener2 = Mock()
        TestListener listener3 = Mock()
        broadcast.add(listener1)
        broadcast.add(listener2)

        when:
        broadcast.source.event1("event")

        then:
        1 * listener1.event1("event") >> { args ->

        def failure3 = new RuntimeException()
        def listener1 = Mock(BuildScopeListener)
        def listener2 = Mock(BuildScopeListener)
        def listener3 = Mock(BuildScopeListener)
        manager.addListener(listener1)
        manager.addListener(listener2)
        def child = manager.createChild(Scope.Build)
        child.addListener(listener3)
        def broadcast = child.getBroadcaster(BuildScopeListener.class)

        listener3.getPath() >> b.path

        when:
        graph.add(a)
        graph.addListener(listener1)
        graph.add(b)

        then:
        1 * listener1.onDiscovered(graph.root)
        1 * listener1.onDiscovered(a) >> { graph.addListener(listener2); false }
        1 * listener1.onDiscovered(b) >> { graph.addListener(listener3); false }
        1 * listener2.onDiscovered(b)

        then:
        1 * listenerManager.addListener(listener1)
        1 * listenerManager.addListener(listener2)
        1 * buildOperationListenerManager.addListener(listener1)
        1 * buildOperationListenerManager.addListener(listener2)

        then:
        1 * delegate.execute(buildAction, buildSessionContext)

        then:
        1 * listenerManager.removeListener(listener1)
        1 * listenerManager.removeListener(listener2)

        ITestListener differentListener = factory.createAdapter(otherListener);

        then:
        listener1.equals(listener2) && listener1.hashCode() == listener2.hashCode()
        !listener1.equals(listener)
        !listener1.equals(differentListener)
        !listener1.equals(null)
    }

    /**
     * covered by {@code org.gradle.testing.testng.TestNGIntegrationTest}
     */

        and:
        def streamedModels2 = listener2.models
        streamedModels2.size() == 2
        (streamedModels2[0] as GradleProject).name == "hello-world"
        (streamedModels2[1] as EclipseProject).gradleProject.name == "hello-world"
    }

    def "models are streamed on phased build action cache hit"() {
        def listener1 = new TestStreamedValueListener()
        def listener2 = new TestStreamedValueListener()

        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskSkippedResult })
        0 * listener._
    }

    def "listener can receive build operation finish events"() {
        def listener = Mock(BuildOperationListener)
        def provider = Providers.of(listener)
        def descriptor = descriptor()
        def finishEvent = operationFinishEvent()

    def "only handlers that implement RejectedMessageListener are notified of rejected outgoing messages"() {
        RejectedMessageListener listener1 = Mock()
        RejectedMessageListener listener2 = Mock()

        given:
        hub.addHandler("channel", listener1)
        hub.addHandler("channel", listener2)
        hub.addHandler("channel", new Object())
        hub.getOutgoing("channel", String).dispatch("discarded")

        when:

            }

            // Do not inline listener, or it weakens the test.
            // We try to create the shared services registry first to have it handle buildFinished earlier.
            def listener = gradle.sharedServices.registerIfAbsent('listener', BlockingListener)
            def registry = project.services.get(BuildEventsListenerRegistry)
            registry.onTaskCompletion(listener)

            tasks.register("a")