std::optional<CalibrationStatistics> statistics = collector.GetStatistics();

  EXPECT_TRUE(statistics.has_value());
  EXPECT_EQ(statistics.value().min_max_statistics().global_min(), -5.0f);
  EXPECT_EQ(statistics.value().min_max_statistics().global_max(), 10.0f);
}

TEST(CalibrationStatisticsCollectorTest, SimpleAverageMinMax) {
  auto collector = CalibrationStatisticsCollectorAverageMinMax();

  collector.Collect(

  const CalibrationStatistics& stats = statistics_map.statistics().at("1");
  ASSERT_TRUE(stats.has_min_max_statistics());
  EXPECT_FLOAT_EQ(stats.min_max_statistics().global_min(), 1.f);
  EXPECT_FLOAT_EQ(stats.min_max_statistics().global_max(), 5.f);
}

TEST_F(CalibrationStatisticsSaverTest, SimpleAverageMinMax) {
  std::vector<std::string> ids{"1"};
  std::vector<int32_t> calibration_methods{

    Returns:
      (min_value, max_value): Min and max calculated using MinMax
    """
    return (
        self._statistics.min_max_statistics.global_min,
        self._statistics.min_max_statistics.global_max,
    )


@_implements(_CalibrationMethod.CALIBRATION_METHOD_AVERAGE_MIN_MAX)
class _AverageMinMax(_CalibrationAlgorithmBase):

  // compute streams used in each XLA device. It is only used if
  // `use_global_compute_stream` in `XlaDevice::Options` is set to true.
  static mutex global_mu_;
  static std::vector<std::shared_ptr<se::Stream>>* global_compute_streams_
      TF_GUARDED_BY(global_mu_);
};

// Builds OpKernel registrations on 'device' for the JIT operators
// registered on 'jit_device'. Returns ownership of a XlaDeviceOpRegistrations

                                           const Metadata** metadata) {
  return GetMetadataFromDevice(ctx->device(), metadata);
}

/* static */ mutex XlaDevice::global_mu_(LINKER_INITIALIZED);
/* static */ std::vector<std::shared_ptr<se::Stream>>*
    XlaDevice::global_compute_streams_ =
        new std::vector<std::shared_ptr<se::Stream>>;