expect:
        broadcast.empty
        broadcast.size() == 0

        when:
        broadcast.add(listener1)

        then:
        !broadcast.empty
        broadcast.size() == 1

        when:
        broadcast.add(listener2)
        broadcast.add(listener3)

        then:
        !broadcast.empty
        broadcast.size() == 3

        when:

        def messages = []
        endpoint.take(messages)

        then:
        messages == [message]
    }

    def "forwards queued broadcast messages to all endpoints"() {
        given:
        def message1 = unicast()
        def message2 = broadcast()
        def message3 = unicast()
        def endpoint1 = queue.newEndpoint()
        def endpoint2 = queue.newEndpoint()

        and:

    private final AnonymousListenerBroadcast<ScriptFileResolvedListener> broadcast;

    public DefaultScriptFileResolverListeners(ListenerManager listenerManager) {
        this.broadcast = listenerManager.createAnonymousBroadcaster(ScriptFileResolvedListener.class);
    }

    @Override
    public void addListener(ScriptFileResolvedListener scriptFileResolvedListener) {
        broadcast.add(scriptFileResolvedListener);
    }

    @Override

//
// T z = x / y
// return (z * y != x && (x < 0) != (y < 0)) ? z - 1 : z
//
// BroadcastToDimensions is used to compute the broadcast attr to higher
// dimensions. This computes the broadcast of 'l' to broadcast('l', 'r')
// without returning the broadcast of 'r' to broadcast('l', 'r').
def : Pat<(TF_FloorDivOp AnyTensor:$l, AnyTensor:$r),
      (MHLO_SelectOp
       (CHLO_BroadcastAndOp
        (CHLO_BroadcastCompareOp

    private final AnonymousListenerBroadcast<FileChangeListener> broadcaster;

    public DefaultFileChangeListeners(ListenerManager listenerManager) {
        this.broadcaster = listenerManager.createAnonymousBroadcaster(FileChangeListener.class);
    }

    @Override
    public void addListener(FileChangeListener listener) {
        broadcaster.add(listener);
    }

    @Override

Eugene Burmako <******@****.***> 1671166704 -0800

    private final AnonymousListenerBroadcast<ClassLoaderScopeRegistryListener> broadcaster;

    public ClassLoaderScopeRegistryListenerManager(ListenerManager manager) {
        broadcaster = manager.createAnonymousBroadcaster(ClassLoaderScopeRegistryListener.class);
    }

    public ClassLoaderScopeRegistryListener getBroadcaster() {
        return broadcaster.getSource();
    }

  // 'ab...c' and shape of rank 10; the range [3:-1] denotes the broadcasted
  // axes.
  int bx_start, by_start;
  absl::optional<int> bx_end, by_end;
  std::tie(bx_start, bx_end) = EinsumGetBcastSubshape(x_subs);
  std::tie(by_start, by_end) = EinsumGetBcastSubshape(y_subs);

  // Sum the gradient across the broadcasted axes.
  auto args = internal::BroadcastGradientArgs(

        then:
        messages1 == [message1, message2]
        messages2 == [message2]
    }

    def "forwards most recent stateful broadcast messages to all new queues"() {
        def id1 = new ChannelIdentifier("channel1")
        def message1 = broadcast()
        def message2 = broadcast()
        def message3 = new EndOfStream()

        given:
        queue.queue(message1)
        queue.queue(message2)

    private final AnonymousListenerBroadcast<FileSystemDefaultExcludesListener> broadcast;

    public DefaultFileSystemDefaultExcludesProvider(ListenerManager listenerManager) {
        broadcast = listenerManager.createAnonymousBroadcaster(FileSystemDefaultExcludesListener.class);

        listenerManager.addListener(new RootBuildLifecycleListener() {