/*scale=*/1.0, /*zero_point=*/0);

  EXPECT_TRUE(quantized_type.getExpressedType().isF32());
}

TEST_F(CreateI8F32UniformQuantizedTypeTest, SignedQuantizedTypeSucceeds) {
  const UniformQuantizedType quantized_type =
      CreateI8F32UniformQuantizedType(UnknownLoc::get(&ctx_), ctx_,
                                      /*scale=*/1.0, /*zero_point=*/0);

  EXPECT_TRUE(quantized_type.isSigned());
}

  UniformQuantizedValueConverter(double scale, double zero_point,
                                 double clamp_min, double clamp_max,
                                 uint32_t storage_bit_width, bool is_signed)
      : scale_(scale),
        zero_point_(zero_point),
        clamp_min_(clamp_min),
        clamp_max_(clamp_max),
        scale_double_(scale),
        zero_point_double_(zero_point),
        clamp_min_double_(clamp_min),

  EXPECT_THAT(pack_input0->quantization->zero_point[0],
              Eq(pack_input1->quantization->zero_point[0]));
  EXPECT_THAT(pack_input1->quantization->zero_point[0],
              Eq(pack_input2->quantization->zero_point[0]));

  EXPECT_THAT(pack_input1->quantization->scale[0],
              FloatEq(pack_output->quantization->scale[0]));
  EXPECT_THAT(pack_input1->quantization->zero_point[0],

                                                     double scale,
                                                     int64_t zero_point,
                                                     bool narrow_range = false);

// Creates a `UniformQuantizedType` with the given `scale` and `zero_point`
// values. The produced type has f32 as its expressed type and i32 as its

                                                     const int64_t zero_point,
                                                     const bool narrow_range) {
  return UniformQuantizedType::getChecked(
      loc, /*flags=*/QuantizationFlags::Signed,
      /*storageType=*/IntegerType::get(&context, /*width=*/8),
      /*expressedType=*/FloatType::getF32(&context), scale, zero_point,
      /*storageTypeMin=*/llvm::minIntN(8) + (narrow_range ? 1 : 0),

//   maximum quantized values.
QuantizedRange CalculateQuantizedRange(double scale, int32_t zero_point,
                                       std::optional<double> rmin,
                                       std::optional<double> rmax, int32_t qmin,
                                       int32_t qmax) {
  auto quantize = [scale, zero_point](float f) {
    return zero_point + static_cast<int32_t>(std::round(f / scale));
  };

// CHECK-NEXT:         zero_point: [ 0 ]
// CHECK-NEXT:       },
// CHECK-NEXT:       has_rank: true
// CHECK-NEXT:     }, {
// CHECK-NEXT:       shape: [ 2048, 528 ],
// CHECK-NEXT:       type: INT8,
// CHECK-NEXT:       buffer: 3,
// CHECK-NEXT:       name: "arg2",
// CHECK-NEXT:       quantization: {
// CHECK-NEXT:         scale: [ 0.031926 ],
// CHECK-NEXT:         zero_point: [ 0 ]
// CHECK-NEXT:       },

// CHECK-NEXT:        zero_point: [ 151 ]
// CHECK-NEXT:      },
// CHECK-NEXT:      has_rank: true
// CHECK-NEXT:    }, {
// CHECK-NEXT:      shape: [ 32 ],
// CHECK-NEXT:      type: INT32,
// CHECK-NEXT:      buffer: 5,
// CHECK-NEXT:      name: "tfl.pseudo_qconst1",
// CHECK-NEXT:      quantization: {
// CHECK-NEXT:        scale: [ 0.000171 ],
// CHECK-NEXT:        zero_point: [ 0 ]
// CHECK-NEXT:      },

    int32_zero_points.push_back(zero_points[i]);
  }
  scale = rewriter.create<TF::ConstOp>(
      loc, scale_type, DenseFPElementsAttr::get(scale_type, float_scales));
  zero_point = rewriter.create<TF::ConstOp>(
      loc, zero_point_type,
      DenseIntElementsAttr::get(zero_point_type, int32_zero_points));
  return success(scale && zero_point);
}

# CHECK-NEXT:          zero_point: [ 128 ]
# CHECK-NEXT:        },
# CHECK-NEXT:        has_rank: true
# CHECK-NEXT:      }, {
# CHECK-NEXT:        shape: [ 4 ],
# CHECK-NEXT:        type: UINT8,
# CHECK-NEXT:        buffer: 2,
# CHECK-NEXT:        name: "input1",
# CHECK-NEXT:        quantization: {
# CHECK-NEXT:          scale: [ 0.023529 ],
# CHECK-NEXT:          zero_point: [ 128 ]
# CHECK-NEXT:        },