namespace {

// Returns the ops that should use node name if shared_name is empty.
const llvm::StringSet<>& GetOpsUsingNodeName() {
  static auto* const ops =
      new llvm::StringSet<>({"VariableV2", "Variable", "BatchFunction"});
  return *ops;
}

// Returns the set of ops that we want to generate shared_names for them if
// empty.
const llvm::StringSet<>& GetSharedNameGenerationCompatibleOps() {
  return GetOpsUsingNodeName();
}

    }
  )mlir";

  const OwningOpRef<ModuleOp> module_op =
      ParseModuleOpString(kQuantizedDotGeneral);
  ASSERT_TRUE(module_op);

  const QuantizationReport report(*module_op);

  const std::string dst_file_path =
      absl::StrCat(TempDir(), "/quantization_report.txtpb");
  const absl::Status save_status = report.Save(dst_file_path);

    fprintf(stderr, "Read '%s' resulted in empty\n", name);
    return false;
  }
  *buf = s;
  return true;
}

bool ParseFile(flatbuffers::Parser *parser, const std::string &filename,
               const std::string &contents) {
  std::vector<const char *> include_directories;
  auto local_include_directory = flatbuffers::StripFileName(filename);
  include_directories.push_back(local_include_directory.c_str());

  MOCK_METHOD(Status, TryToPersistExecutable,
              (uint64, const std::string&, const XlaCompiler::Options&,
               const XlaCompiler::CompilationResult&,
               const xla::LocalExecutable&,
               (DeviceCompilerClient<xla::LocalExecutable, xla::LocalClient>*)),
              (const, override));
};

class MockDeviceCompilationProfiler : public DeviceCompilationProfiler {

    // the cloning.
    if (src_arg.use_empty()) continue;

    const unsigned main_arg_idx = main_func_op.getNumArguments();

    const DictionaryAttr main_arg_attr =
        src_func_op.getArgAttrDict(src_arg_idx);

    main_func_op.insertArgument(main_arg_idx, src_arg.getType(), main_arg_attr,
                                src_arg.getLoc());

    const std::string new_input_name =

}

int64_t DeviceCompilationProfiler::GetNumOngoingAsyncCompilations() const {
  mutex_lock lock(mu_);
  return num_ongoing_compilations_;
}

std::string DeviceCompilationProfiler::DebugString() const {
  std::string debug_string =
      "DeviceCompilationProfiler {\ncluster_compile_stats: {\n";
  {
    mutex_lock lock(mu_);

    for (const auto& [key, stats] : cluster_compile_stats_) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package unix

import "syscall"

const unlinkatTrap uintptr = syscall.SYS_UNLINKAT
const openatTrap uintptr = syscall.SYS_OPENAT
const fstatatTrap uintptr = syscall.SYS_FSTATAT

const (
	AT_EACCESS          = 0x1
	AT_FDCWD            = -0x64
	AT_REMOVEDIR        = 0x08
	AT_SYMLINK_NOFOLLOW = 0x02

	UTIME_OMIT = -0x1

  }

  Status Listen(const XlaOptimizationRemark& optimization_remark) override {
    return absl::OkStatus();
  }

  ~TestListener() override {}

  const XlaAutoClusteringActivity& auto_clustering_activity() const {
    return auto_clustering_activity_;
  }
  const XlaJitCompilationActivity& jit_compilation_activity() const {
    return jit_compilation_activity_;
  }

 private:

type IpAddrString struct {
	Next      *IpAddrString
	IpAddress IpAddressString
	IpMask    IpMaskString
	Context   uint32
}

const MAX_ADAPTER_NAME_LENGTH = 256
const MAX_ADAPTER_DESCRIPTION_LENGTH = 128
const MAX_ADAPTER_ADDRESS_LENGTH = 8

type IpAdapterInfo struct {
	Next                *IpAdapterInfo
	ComboIndex          uint32

  // Returns `QuantizationResults` that are registered in this report.
  const ::stablehlo::quantization::QuantizationResults& GetQuantizationResults()
      const {
    return quantization_results_;
  }

  // Returns a human-readable string representation of this report.
  std::string ToString() const;

  // Prints a human-readable report to stdout.
  void Print() const;

  // Saves the report to `file_path`. The textproto representation of