builder_.create<mlir::stablehlo::ConstantOp>(
          builder_.getUnknownLoc(), builder_.getI32IntegerAttr(0));
  EXPECT_TRUE(IsStablehloOp(*constant_op));
}

TEST_F(StablehloTypeUtilsTest, IsStablehloOpFailsWithArithOp) {
  const OwningOpRef<mlir::arith::ConstantOp> constant_op =
      builder_.create<mlir::arith::ConstantOp>(builder_.getUnknownLoc(),
                                               builder_.getI32IntegerAttr(0));

    context_.loadAllAvailableDialects();

    mlir::OpBuilder builder(&context_);
    module_ = builder.create<mlir::ModuleOp>(builder.getUnknownLoc());

    builder.setInsertionPointToStart(module_->getBody());
    auto func = builder.create<mlir::func::FuncOp>(  //
        builder.getUnknownLoc(), "main", builder.getFunctionType({}, {}));
    func->setAttr("tfl.func", builder.getUnitAttr());

        builder.getUnknownLoc(), storage_type_width, effective_mins[0],
        effective_maxs[0], narrow_range, converter.expressed_type, is_signed);
    if (legacy_float_scale) {
      quantized_element_type =
          DownCastScale(quantized_element_type, effective_mins[0],
                        effective_maxs[0], builder.getUnknownLoc());
    }
  } else if (min.size() == max.size()) {

      return UniformQuantizedType::getChecked(
          Sign, storage_type, result_type.getElementType(), scale, ZeroPoint,
          StorageTypeMin, StorageTypeMax, builder.getUnknownLoc());
    }
  };
};

// This class provides the API for ops that has input as bias. This is used
// as a trait like this:
//
//   class Conv2DOp

  mlir::PassManager pm = {&ctx};
  pm.addPass(CreateParentPass());

  EnableIrPrinting(pm, "dump");

  mlir::OpBuilder builder(&ctx);
  auto module_op = builder.create<mlir::ModuleOp>(builder.getUnknownLoc());
  // Destroy by calling destroy() to avoid memory leak since it is allocated
  // with malloc().
  const absl::Cleanup module_op_cleanup = [module_op] { module_op->destroy(); };

        RankedTensorType type = RankedTensorType::get(
            {}, TF::StringType::get(builder.getContext()));
        auto const_op = builder.create<TF::ConstOp>(
            builder.getUnknownLoc(),
            DenseStringElementsAttr::get(type, {filename}));

        it = const_ops.insert({asset.getSymName(), const_op}).first;
      }

      argument.replaceAllUsesWith(it->second.getOutput());

      builder.getFunctionType(input_types, return_types);

  std::string function_name = absl::StrCat("func_", subgraph.subgraph_id_);

  func::FuncOp new_func = func::FuncOp::create(builder.getUnknownLoc(),
                                               function_name, function_type);
  new_func.setVisibility(func::FuncOp::Visibility::Private);
  new_func.addEntryBlock();

                builder->getNamedAttr(key, conv_dimension_numbers_attr);
            attrs.push_back(named_attr);
          }
          break;
        }
        default: {
          emitWarning(builder->getUnknownLoc(),
                      "seralization not supported for : ")
              << key;
          break;
        }
      }
    }
    return attrs;
  }
};

  rewriter.setInsertionPointToStart(&new_func.getBody().front());

  auto one_val = DenseElementsAttr::get(type, kOne);
  auto one_cst =
      rewriter.create<stablehlo::ConstantOp>(rewriter.getUnknownLoc(), one_val);

  auto half_val = DenseElementsAttr::get(type, kHalf);
  auto half_cst =
      rewriter.create<stablehlo::ConstantOp>(one_cst.getLoc(), half_val);

}

quant::QuantParams DefaultQuantParamsPass::GetDefaultQuantParams(
    Builder builder) {
  if (!default_quant_params_) {
    default_quant_params_ = quantfork::fakeQuantAttrsToType(
        builder.getUnknownLoc(),
        /*numBits=*/8, default_min_, default_max_, /*narrowRange=*/false,
        builder.getF32Type(), is_signed_);
  }
  return default_quant_params_;
}