processLauncher = NativeServices.getInstance().get(ProcessLauncher.class);
        shutdownHookAction = new ExecHandleShutdownHookAction(this);
        broadcast = new ListenerBroadcast<ExecHandleListener>(ExecHandleListener.class);
        broadcast.addAll(listeners);
    }

    @Override
    public File getDirectory() {
        return directory;
    }

    @Override
    public String getCommand() {

    /**
     * Creates a child {@code ListenerManager}.
     * <p>
     * All events broadcast in the child will be received by the listeners registered in the parent.
     * However, the reverse is not true:
     * events broadcast in the parent are not received by the listeners in the children.
     * The child inherits the loggers of its parent, though these can be replaced.
     *

  %cst0 = mhlo.constant dense<[1, 2, 3, 4]> : tensor<4xi32>
  // CHECK: %[[BROADCAST:.*]] = "mhlo.broadcast_in_dim"(%[[CONST]]) <{broadcast_dimensions = dense<3> : tensor<1xi64>}> : (tensor<4xi32>) -> tensor<1x1x2x4xi32>
  %0 = "mhlo.broadcast_in_dim"(%cst0) <{broadcast_dimensions = dense<3> : tensor<1xi64>}> : (tensor<4xi32>) -> tensor<1x1x2x4xi32>
  // CHECK: %[[MUL:.*]] = mhlo.multiply %[[BROADCAST]], %[[ARG]] : tensor<1x1x2x4xi32>

        }
        try {
            BuildTreeLifecycleListener broadcaster = services.get(ListenerManager.class).getBroadcaster(BuildTreeLifecycleListener.class);
            broadcaster.afterStart();
            try {
                return services.get(BuildTreeActionExecutor.class).execute(action, this);
            } finally {
                broadcaster.beforeStop();
            }
        } finally {
            completed = true;

    private final FeatureFlagListener broadcaster;

    public DefaultFeatureFlags(InternalOptions options, ListenerManager listenerManager) {
        this.options = options;
        this.broadcaster = listenerManager.getBroadcaster(FeatureFlagListener.class);
    }

    @Override
    public boolean isEnabled(FeatureFlag flag) {
        broadcaster.flagRead(flag);
        if (flag.getSystemPropertyName() != null) {

      return failure();
    }
    filter = conv_op.getRhs().getDefiningOp<mhlo::ConstantOp>();
    if (filter == nullptr) {
      return failure();
    }
    // Try to match static broadcast or dynamic broadcast.
    bcast_or_const_op = rhs.getDefiningOp();
    bool is_dynamic_broadcast =
        isa<mhlo::DynamicBroadcastInDimOp>(bcast_or_const_op);
    multiplier = isa<mhlo::ConstantOp>(bcast_or_const_op)

 */
public class OutputEventListenerManager {
    private final OutputEventListener renderer;
    private OutputEventListener other;

    private final OutputEventListener broadcaster = new OutputEventListener() {
        @Override
        public void onOutput(OutputEvent event) {
            renderer.onOutput(event);

            OutputEventListener otherRef = other;

    private final ListenerBroadcast<TestListenerInterface> broadcast = new ListenerBroadcast<TestListenerInterface>(TestListenerInterface.class)
    private final RemoteExceptionListener exceptionListener = new RemoteExceptionListener(broadcast.source)

    public void setup() {
        broadcast.add(listenerMock)
    }

    @Requires(UnitTestPreconditions.NotWindows)

            if (broadcaster != null) {
                broadcaster.add(listener);
            }
        }

        void addListener(Dispatch<MethodInvocation> listener) {
            subscribedListeners.add(listener);
            if (broadcaster != null) {
                broadcaster.add(listener);
            }
        }

        void removeListener(Object listener) {
            subscribedListeners.remove(listener);

        def broadcaster = buildOperationListenerManager.broadcaster

        when:
        registry.onOperationCompletion(provider)

        then:
        registry.subscriptions.size() == 1
        0 * listener._

        when:
        async {
            broadcaster.started(descriptor, startOperationEvent())