for (Node* n : rpo) {
    if (!compile_time_const_nodes[n->id()]) {
      continue;
    }

    absl::string_view cluster_name = *GetXlaClusterForNode(*n);
    bool node_on_cluster_edge =
        absl::c_all_of(n->in_edges(), [&](const Edge* e) {
          std::optional<absl::string_view> incoming_cluster =
              GetXlaClusterForNode(*e->src());
          return !incoming_cluster || *incoming_cluster != cluster_name;

  EXPECT_TRUE(result.method().has_static_range_ptq());
}

TEST_F(QuantizationReportTest,
       InitializeWithModuleOpWithoutQuantizationMethodAttribute) {
  // A quantized dot_general op but the `CallOp` is missing the
  // `_quantization_method` attribute.
  constexpr absl::string_view
      kQuantizedDotGeneralMissingQuantizationMethodAttr = R"mlir(
    func.func @main(%arg0: tensor<1x2xf32>) -> tensor<1x3xf32> {

// CHECK: %[[CALL_0:.+]] = call @quantized_dot_general_fn(%[[UNIFORM_QUANTIZE_0]], %[[CONST_0]]) {_quantization_method = "static_range_ptq { }"} : (tensor<1x2x!quant.uniform<i8:f32, {{.*}}>>, tensor<2x3x!quant.uniform<i8<-127:127>:f32:1, {{.*}}>) -> tensor<1x3x!quant.uniform<i8:f32, {{.*}}>>
// CHECK: %[[UNIFORM_DEQUANTIZE_0:.+]] = stablehlo.uniform_dequantize %[[CALL_0]] : (tensor<1x3x!quant.uniform<i8:f32, {{.*}}>) -> tensor<1x3xf32>

  auto allowlist = GetOrCreateAllowlist();

  std::vector<string> vall_ops = XlaOpRegistry::GetAllRegisteredOps();
  absl::flat_hash_set<string> all_ops(vall_ops.begin(), vall_ops.end());
  // Check that user's provided TF operation really exists.
  for (const auto& s : allowlist) {
    if (!all_ops.contains(s)) {
      return errors::InvalidArgument(
          "The operation '", s,

    auto transpose_op = *transpose_ops.begin();
    auto result_type =
        mlir::dyn_cast_or_null<ShapedType>(transpose_op.getResult().getType());
    auto is_valid_move =
        llvm::all_of(op->getOperands(), [result_type](Value operand) -> bool {
          auto operand_type =
              mlir::dyn_cast_or_null<ShapedType>(operand.getType());
          return result_type && operand_type && result_type.hasRank() &&

  // CHECK: "tf.IfRegion"(%[[PRED]]) <{is_stateless = false}> ({
  %case_op = "tf.IfRegion"(%arg0) <{is_stateless = false}> ({
      // CHECK: %[[TA_VAL:.*]] = "tf.ReadVariableOp"(%[[TA_BUFFER]])
      // CHECK: "tf.Slice"(%[[TA_VAL]]
      // CHECK-NOT: tf.TensorArrayReadV3

  // CHECK: tf.AssignVariableOp
  %stack = "tf.StackV2"(%max_size) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  // CHECK: %[[CASE_OUTPUT:.*]] = "tf.CaseRegion"(%[[BRANCH_INDEX]]) {{.*}} ({
  %case_op = "tf.CaseRegion"(%arg0) ({
    %elem = "tf._SomeOp"() : () -> tensor<f32>
    // CHECK-NOT: tf.StackPushV2
    // CHECK: %[[BUFFER_VAL:.*]] = "tf.ReadVariableOp"(%[[BUFFER]])

    OpKernelContext* ctx) {
  std::vector<int> constant_input_indices;
  TF_RETURN_IF_ERROR(GetCompileTimeConstInputs(
      &ctx->op_kernel(), &constant_input_indices, ctx->function_library()));
  if (!absl::c_all_of(constant_input_indices, [&](int idx) {
        return ctx->input_memory_type(idx) == HOST_MEMORY;
      })) {
    return errors::Internal("Unexpected device placement for a constant input");
  }

      if (!device_list)
        return op.emitError()
               << "expects 'devices' to be a map alias and device name list.";

      bool is_device_string = llvm::all_of(device_list, [](Attribute attr) {
        return mlir::dyn_cast_or_null<StringAttr>(attr);
      });
      if (!is_device_string)
        return op.emitOpError() << "expects 'devices' to be a consists of "

TEST(XlaCompilationTest, XLALiteAllowlist) {
  auto* allowlist_table = tensorflow::GetAllowlistTable();
  absl::flat_hash_set<string> hallowlist;
  std::vector<string> vall_ops = XlaOpRegistry::GetAllRegisteredOps();
  absl::flat_hash_set<string> all_ops(vall_ops.begin(), vall_ops.end());

  // Check that all the operations in the table are existing TF operations
  for (auto pair : *allowlist_table) {