// Send a couple events after closing the broadcast channel.
	t.Log("Sending event")

	err := m.Action(event.Type, event.Object)
	assert.EqualError(t, err, "broadcaster already stopped", "ActionOrDrop should report error id broadcaster is shutdown")

	sendOnClosed, err := m.ActionOrDrop(event.Type, event.Object)
	assert.Equal(t, sendOnClosed, false, "ActionOrDrop should return false if broadcaster is already shutdown")

    // Check that the i'th operand is a broadcast.
    auto broadcast = llvm::dyn_cast_or_null<TF::BroadcastToOp>(
        op->getOpOperand(i).get().getDefiningOp());
    if (!broadcast) continue;

    // Check that the operand of the broadcast has fully defined shape.
    auto broadcast_arg_type = mlir::dyn_cast_or_null<RankedTensorType>(
        broadcast.getInput().getType());

            val broadcast = listenerManager.getBroadcaster(TaskExecutionAccessListener::class.java)
            return when {
                !modelParameters.isConfigurationCache -> TaskExecutionAccessCheckers.TaskStateBased(broadcast, workExecutionTracker)
                configurationCacheStartParameter.single().taskExecutionAccessPreStable -> TaskExecutionAccessCheckers.TaskStateBased(broadcast, workExecutionTracker)

      return rewriter.notifyMatchFailure(
          binary_op, "Operands should have exactly one BroadcastInDim op.");
    }
    // When the operand other than the broadcast op is not a const op, we
    // should not fold broadcast op.
    auto binary_op_const_operand =
        (lhs_bcast_op ? rhs : lhs).template getDefiningOp<mhlo::ConstantOp>();
    if (!binary_op_const_operand) return failure();

        when:
        broadcast.started(d1, new OperationStartEvent(0))
        broadcast.started(d2, null)

        broadcast.started(d3, new OperationStartEvent(0))
        broadcast.finished(d3, new OperationFinishEvent(-1, -1, null, null))

        broadcast.started(d4, new OperationStartEvent(0))
        broadcast.started(d5, new OperationStartEvent(0))
        broadcast.started(d6, new OperationStartEvent(0))

           "clEnumValN(MoveTransposeDirection::kEnd, \"end\", \"end of the block\"))">
  ];
}

def BroadcastFoldPass : Pass<"tf-broadcast-fold", "mlir::func::FuncOp"> {
  let summary = "Fold explicit broadcasts into the following operations if they "
           "support implicit broadcasting on their operand.";
  let constructor = "TF::CreateBroadcastFoldPass()";
}

  auto cst_attr = rewriter.getI64TensorAttr(values);
  return rewriter.create<TF::ConstOp>(location, cst_attr.getType(), cst_attr);
}

// Rewrites broadcast->reshape to a reshape->broadcast that reduces
// the rank of the input and output of the broadcast.
class SimplifyBroadcastReshape : public OpRewritePattern<BroadcastToOp> {
  using OpRewritePattern<BroadcastToOp>::OpRewritePattern;

  friend class internal::NoExecDeathTest;
  friend class internal::TestEventListenersAccessor;
  friend class internal::UnitTestImpl;

  // Returns repeater that broadcasts the TestEventListener events to all
  // subscribers.
  TestEventListener* repeater();

  // Sets the default_result_printer attribute to the provided listener.

  friend class internal::NoExecDeathTest;
  friend class internal::TestEventListenersAccessor;
  friend class internal::UnitTestImpl;

  // Returns repeater that broadcasts the TestEventListener events to all
  // subscribers.
  TestEventListener* repeater();

  // Sets the default_result_printer attribute to the provided listener.

// Check if broadcast dimensions match Tensorflow convention.
def IsTFStyleBroadcast : Constraint<CPred<"IsTFStyleBroadcast($0, $1)">,
    "new dimensions are added as prefix">;

def IsNotWithinScatterRegion : Constraint<CPred<"!IsWithinOpRegion<mhlo::ScatterOp>($0)">,
    "binary ops within scatter regions are not converted">;

// Check if broadcast dimensions do not match Tensorflow convention.