EXPECT_FALSE(IsOpFullyQuantized(*add_op_itr));
}

TEST_F(IsOpFullyQuantizedTest, FalseIfOpPartiallyQuantized) {
  constexpr absl::string_view kQuantizeOp = R"mlir(
    func.func @quantize(%arg0: tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32, 1.000000e+00:0>> {
      %0 = stablehlo.uniform_quantize %arg0 : (tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32, 1.000000e+00:0>>

  // of `quantized_type`.
  if (new_value_type == nullptr) return;

  auto quantize =
      builder_.create<quantfork::QuantizeCastOp>(loc, new_value_type, value);
  auto dequantize = builder_.create<quantfork::DequantizeCastOp>(
      loc, expressed_type, quantize.getResult());

  // This attribute is set to distinguish the quantize ops being added by the
  // quantization pass. These ops can be removed without losing original

  // Whether the func contains Quantize ops. This is used to determine whether
  // to use the quantization parameters from the fixed output range property.
  bool ContainsQuantizeOps(func::FuncOp func);

  QuantizationSpecs quant_specs_;

  Option<bool> enable_post_training_quantize_{
      *this, "post-training-quantize", llvm::cl::init(false),

    // 1. Collect quantizable ops.
    QuantizationUnits quantizable_ops = GetQuantizableOps(op);
    if (quantizable_ops.empty()) {
      return failure();
    }

    // 2. Quantize collected ops.
    if (!QuantizeOps(rewriter, op, quantizable_ops)) {
      return failure();
    }

    // 3. Complete the Q-DQ pair for each inference type.
    if (!ConvertToFloat16Constant(rewriter, op)) {

#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/lib/monitoring/counter.h"

//===----------------------------------------------------------------------===//
// The prepare-quantize Pass.
//
namespace mlir {
namespace TFL {

namespace {
#define GEN_PASS_DEF_PREPAREQUANTIZEPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/types.h"

// NOLINTNEXTLINE
//===----------------------------------------------------------------------===//
// The prepare-dynamic-range-quantize Pass.
//
namespace mlir {
namespace TFL {

namespace {
#define GEN_PASS_DEF_PREPAREDYNAMICRANGEQUANTIZEPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

              new_q_op.getResult());
          assign_variable_op->replaceAllUsesWith(new_assign_variable_op);
        }
        assign_variable_op.erase();
        dq_op.erase();
      } else {
        // Add quantize op.
        builder.setInsertionPoint(assign_variable_op);
        auto new_q_op = builder.create<QuantizeOp>(
            assign_variable_op.getLoc(), ref_qtype,

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-propagate-quantize-type";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Propagate quantized type through allowed ops.";
  }

  void runOnOperation() override;
};

  //                      quantization.
  //   * Non-convolution ops: All
  //
  // Default value: true
  bool enable_per_channel_quantized_weight = 2 [deprecated = true];

  // Whether to quantize all quantizable ops or only compute-heavy ops.
  bool enable_full_int_quantization = 3;
}

// Applies int8 per-channel weight-only post-training quantization for all
// dot_general and convolution ops.

// parameters in `tensor_type`. Returns empty Attribute if the
// `tensor_type` is not a QuantizedType or the quantization fails.
ElementsAttr Quantize(Attribute real_value, Type tensor_type);

// Quantizes the elements in "legacy mode", where it calls TOCO's methods to
// to quantize values with float scale.
ElementsAttr QuantizeLegacy(Attribute real_value, Type tensor_type);