hist_stats.mutable_hist_freq()->Assign(hist_freq_.begin(),
                                         hist_freq_.begin() + real_size);

  CalibrationStatistics statistics;
  statistics.mutable_histogram_statistics()->CopyFrom(hist_stats);

  return statistics;
}

std::pair<int32_t, int32_t>
CalibrationStatisticsCollectorHistogram::ExpandHistogramIfNeeded(
    const float lower_bound, const float upper_bound) {

        when:
        withWatchFs().run("assemble", "-D${StartParameterBuildOptions.VfsVerboseLoggingOption.GRADLE_PROPERTY}=true")
        then:
        result.output =~ /VFS> Statistics since last build:/
        result.output =~ /VFS> Statistics during current build:/
        result.output =~ /Received \d+ file system events since last build while watching \d+ locations/

        this.taskIdentityFactory = taskIdentityFactory;
        this.taskFactory = taskFactory;
        this.project = project;
        this.statistics = statistics;
        this.buildOperationRunner = buildOperationRunner;
        this.crossProjectConfigurator = crossProjectConfigurator;
        this.callbackDecorator = callbackDecorator;
        this.projectRegistry = projectRegistry;
    }

    @Override

// CalibrationStatisticsCollectorMinMax. Each class collects different
// statistics based on the calibration methods.
class CalibrationStatisticsCollectorBase {
 public:
  // Collect data for calibration.
  virtual void Collect(float min, float max,
                       absl::Span<const int64_t> histogram) = 0;

  virtual void ClearData() = 0;
  // Return the statistics needed for a given calibration method.

	osInterface kubecontainer.OSInterface
}

// NewFakeHostStatsProvider provides a way to test with fake host statistics
func NewFakeHostStatsProvider() HostStatsProvider {
	return &fakeHostStatsProvider{
		osInterface: &kubecontainertest.FakeOS{},
	}
}

// NewFakeHostStatsProviderWithData provides a way to test with fake host statistics

    def fileModeAccessor = Stub(FileModeAccessor)
    def symlink = Stub(Symlink)
    def fileMetadataAccessor = Stub(FileMetadataAccessor)
    def statistics = Mock(StatStatistics.Collector)
    def fileSystemFactory = new GenericFileSystem.Factory(fileMetadataAccessor, statistics, TestFiles.tmpDirTemporaryFileProvider(temporaryFolder.testDirectory))
    def fileSystem = fileSystemFactory.create(fileModeMutator, fileModeAccessor, symlink)

#include "tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.pb.h"

namespace mlir::quant::stablehlo {

// Adds passes for static-range quantization pre-calibration. Inserts ops
// required to collect tensor statistics.
void AddPreCalibrationPasses(
    OpPassManager& pm,
    const ::stablehlo::quantization::CalibrationOptions& calibration_options,
    const ::stablehlo::quantization::QuantizationSpecs& specs,

  TF_DerivedResultTypeAttr Tout = TF_DerivedResultTypeAttr<0>;
}

def TF_CustomAggregatorOp : TF_Op<"CustomAggregator", [Pure]> {
  let summary = "Gathers min and max statistics of a given tensor.";

  let arguments = (ins
    TensorOf<[TF_Float32]>:$input,

    // The unique id of this `CustomAggregator` op.
    StrAttr:$id,
    // The integer value of the enforcing `CalibrationMethod`.

    const Tensor& input_tensor = context->input(0);

    // Use the same input for the first output.
    context->set_output(0, input_tensor);

    // Calculate min/max statistics.
    const auto input_flat = input_tensor.flat<float>();
    Tensor *min_output = nullptr, *max_output = nullptr;
    OP_REQUIRES_OK(context, context->allocate_output("min", {}, &min_output));

// static-range quantization.
//
// The resulting `ModuleOp` contains quantized StableHLO ops serialized in
// `TF::XlaCallModuleOp`s. They are quantized using the statistics collected
// after the calibration step, corresponding to each `TF::CustomAggregatorOp`s
// in the input module op.
//
// TODO: b/320607042 - Add tests for this component on the python layer.