'input_shape_dynamic': False,
          'enable_per_channel_quantization': False,
      },
      {
          'testcase_name': 'dilation',
          'activation_fn': None,
          'has_bias': False,
          'has_batch_norm': False,
          'target_opset': quant_opts_pb2.TF,
          'input_shape_dynamic': False,
          'enable_per_channel_quantization': False,
          'dilations': [1, 2, 2, 1],

        quantization_method,
    bool enable_per_channel_quantization);

LogicalResult FillAttributesForUniformQuantizedConvolutionOp(
    PatternRewriter& rewriter, Operation* op,
    llvm::StringMap<Attribute>& identifier_to_attr,
    tensorflow::quantization::QuantizationMethod::PresetMethod
        quantization_method,
    bool enable_per_channel_quantization);

LogicalResult FillAttributesForUniformQuantizedAddOp(

LogicalResult FillAttributesForUniformQuantizedDotOp(
    PatternRewriter& rewriter, Operation* op,
    llvm::StringMap<Attribute>& identifier_to_attr,
    QuantMethod quantization_method, bool enable_per_channel_quantization) {
  NamedAttrList attrs;

  if (quantization_method ==
      tensorflow::quantization::QuantizationMethod::METHOD_DYNAMIC_RANGE_INT8) {
    // Fill quantization related attributes for Hybrid op.

                            bool enable_per_channel_quantization) {
    op_set_ = op_set;
    quantization_method_ = quantization_method;
    enable_per_channel_quantization_ = enable_per_channel_quantization;
  }

  PreprocessOpPass(const PreprocessOpPass& other) {
    op_set_ = other.op_set_;
    quantization_method_ = other.quantization_method_;
    enable_per_channel_quantization_ = other.enable_per_channel_quantization_;
  }

    target_opset_ = target_opset;
    enable_per_channel_quantization_ = enable_per_channel_quantization;
  }

  QuantizeCompositeFunctionsPass(const QuantizeCompositeFunctionsPass& other) {
    quantization_method_ = other.quantization_method_;
    target_opset_ = other.target_opset_;
    enable_per_channel_quantization_ = other.enable_per_channel_quantization_;

      tensorflow::quantization::QuantizationMethod::METHOD_STATIC_RANGE_INT8;
  auto res = FillAttributesForUniformQuantizedAddOp(
      test_peer.rewriter_, op, identifier_to_attr, quantization_method,
      /*enable_per_channel_quantization=*/false);
  ASSERT_TRUE(succeeded(res));
  ASSERT_EQ(2147483647, op.getLhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getLhsQuantizationMinValAttr().getInt());

  // applicable
  pm.addPass(mlir::quant::CreateQuantizeCompositeFunctionsPass(
      quantization_options.quantization_method().preset_method(),
      quantization_options.op_set(),
      quantization_options.enable_per_channel_quantization(),
      quantization_options.min_num_elements_for_weights(),
      quantization_options.enable_legacy_weight_only(), mlir_dump_file_prefix));
  pm.addPass(mlir::createSymbolDCEPass());

                                   OpSet op_set,
                                   bool enable_per_channel_quantization)
      : OpRewritePattern<arith::ConstantOp>(context),
        quant_specs_(quant_specs),
        op_set_(op_set),
        enable_per_channel_quantization_(enable_per_channel_quantization) {}

  LogicalResult matchAndRewrite(arith::ConstantOp op,

  BitType bit_type = 3;

  // Defines whether quantization is done in narrow range.
  bool enable_narrow_range = 4;

  // Defines whether quantiation is done per-channel.
  bool enable_per_channel_quantization = 5;

  // Defines whether quantization is done symmetrically.
  bool enable_symmetric = 6;

std::unique_ptr<OperationPass<ModuleOp>> CreateQuantizeCompositeFunctionsPass(
    tensorflow::quantization::QuantizationMethod::PresetMethod
        quantization_method,
    tensorflow::quantization::OpSet target_opset,
    bool enable_per_channel_quantization, int min_num_elements_for_weights,
    bool enable_legacy_weight_only = false,
    std::optional<const absl::string_view> mlir_dump_file_prefix =
        std::nullopt);