// quantized and unquantized layers. The unquantized layer's input come from
    // the previous unquantized layer (Please note that this part is different
    // part from DEBUGGER_TYPE_INT_PER_LAYER). Each layer in the debugging model
    // has a DumpTensor, and it is used to save the entire value of outputs from
    // both the quantized and unquantized layer.
    DEBUGGER_TYPE_FLOAT_PER_LAYER = 3;
  }

    Value result = op->getResult(0);
    rewriter.setInsertionPointAfterValue(result);

    // In Whole model, we first need to set file_name as
    // unquantized_tensor_data.pb as it is used by unquantized dump model.
    // After saving unquantized dump model, the file name will be changed to
    // quantized_tensor_data.pb.
    // Since this process doesn't happen for per layer, we need to set file_name
    // as quantized_tensor_data.pb here.

                    "values. Parts of the graph are not quantized. "
                 << status;
  }

  // Saves the current model to the `unquantized_dump_model_path` if the
  // debugger type is `DEBUGGER_TYPE_WHOLE_MODEL`. This is required
  // because in whole-model debugging mode the `DumpTensor` ops for the
  // unquantized tensors are only inserted in the unquantized model

// (e.g. matmul) has both quantized and unquantized inputs by dequantizing
// the quantized inputs, performing the operation in the expressed type, then
// requantizing if a quantized output is required.
//
// The motivation behind these changes is for Dialects that assume only float
// or quantized computation, and do not support a mixture of these types on

//
//   1. Replaces quantized `TF::XlaCallModuleOp` with a `func::CallOp`.
//   2. Quantizes the callee function.
//
// The inputs of this pattern assumes an invalid IR, where even if a
// `TF::XlaCallModuleOp` is quantized the callee remains unquantized. Step (2)
// not only replaces the input and output tensor types into quantized ones, but
// also rewrites the body with a quantized equivalent.
//

  const QuantizationResults& results = report.GetQuantizationResults();
  // The quantized call op without the _quantization_method attribute is not
  // captured as a `QuantizationResult`.
  ASSERT_THAT(results.results(), IsEmpty());
}

TEST_F(QuantizationReportTest, InitializeWithModuleOpWithInvalidCalleeName) {
  // A quantized dot_general op but the callee function has an invalid name. It

        dilations=[1, 1, 1, 1],
        padding='SAME',
        data_format='NHWC',
    )

    return {'output': out}


# TODO(b/280208261): Add unit tests for comparing unquantized and
# quantized results
@test_util.run_all_in_graph_and_eager_modes
class QuantizationOptionsTest(quantize_model_test_base.QuantizedModelTest):
  """Test cases regarding the use of QuantizationOptions proto.

    METHOD_UNSPECIFIED = 0;  // go/do-include-enum-unspecified

    // Apply default weight-only quantization. Weights are quantized during
    // conversion, then dequantized during inference.
    // Activation: f32, Weight: qi8, Bias: f32
    WEIGHT_ONLY = 1;

    // Apply default dynamic range quantization. Quantized tensor value's
    // ranges are determined during graph runtime.
    // Activation: f32, Weight: qi8, Bias: f32

// RUN: odml-to-stablehlo-opt --compose-uniform-quantized-type \
// RUN:     --split-input-file --verify-diagnostics %s | FileCheck %s

module {
// CHECK-LABEL: quantized_conv_op
// CHECK-SAME: %[[ARG:.*]]: tensor<1x3x3x4xf32>
  func.func @quantized_conv_op(%arg0: tensor<1x3x3x4xf32>) -> tensor<1x3x3x4xf32> {
    %1 = stablehlo.constant dense<1.000000e+03> : tensor<1x1x1x1xf32>  // Input inverse scale.

// CHECK: return %[[CONV2D]] : tensor<1x3x2x2x!quant.uniform<i8:f32, 4.000000e+00>>

// -----

// Tests static range quantized dot_general with asymmetric quantized input.

func.func @dot_general_upstream_srq_asym_input(%arg0: tensor<1x2x3x4x!quant.uniform<i8:f32, 1.000000e+0:-100>>) -> tensor<1x2x3x5x!quant.uniform<i8:f32, 4.000000e+0>> {