suite("Gradle Test Executor") {
                        testClass("org.example.ComplexTests") {
                            operationDisplayName "some_name for_tests"
                            testDisplayName "some_name for_tests"

                            test("test()") {
                                operationDisplayName "test"
                                testDisplayName "test"

        String someName = "someName"
        String someVersion = "someVersion"
        String someConfiguration = "someConfiguration"
        DefaultResolvedDependency resolvedDependency = new DefaultResolvedDependency(someConfiguration, newId(someGroup, someName, someVersion), buildOperationProcessor)

        then:
        resolvedDependency.name == someGroup + ":" + someName + ":" + someVersion

    if log-dump-ssh "${node_name}" "command -v journalctl" &> /dev/null; then
        if [[ "${on_master}" == "true" ]]; then
          log-dump-ssh "${node_name}" "sudo journalctl --output=short-precise -u kube-master-installation.service" > "${dir}/kube-master-installation.log" || true

constexpr std::string_view kQuantizationUnitSuffix = ")";

// Concatenates node name and func name with a "@" separator.
std::string ConcatNodeAndFuncName(std::string_view node_name,
                                  std::string_view func_name) {
  return absl::StrCat(node_name, "@", func_name);
}

// Generate a string to represent the QuantizationUnit.
std::string GenerateQuantizationUnitString(

  // Check for a few expected nodes
  const char* node_name = "test_loop/cond/scalar";
  EXPECT_TRUE(TF_GraphOperationByName(graph_, node_name) != nullptr);
  node_name = "test_loop/body/add";
  EXPECT_TRUE(TF_GraphOperationByName(graph_, node_name) != nullptr);
  node_name = "test_loop/body/inner_loop/body/one";
  EXPECT_TRUE(TF_GraphOperationByName(graph_, node_name) != nullptr);
  node_name = "test_loop/body/inner_loop/cond/less_than";

  }

  // Builds TF operation and sets all the attributes.
  std::string node_name = "unnamed";
  if (const StringAttr attr = inst->getAttrOfType<StringAttr>("name")) {
    node_name = std::string(attr.getValue());
  }
  absl::StatusOr<std::unique_ptr<tensorflow::NodeDef>> node_def =
      tensorflow::ConvertTFDialectOpToNodeDef(
          inst, node_name.c_str(), /*ignore_unregistered_attrs=*/true);

      return StringRef();
    }
  }

  StringRef result;
  for (Attribute class_attr : classes_attr) {
    StringRef node_name = mlir::cast<StringAttr>(class_attr).getValue();
    if (!node_name.starts_with(kLocationPrefix)) {
      continue;
    }
    if (!result.empty()) {
      // Invalid case since there are multiple loc:@ attributes.
      op->emitOpError()

  llvm::SmallVector<Value> returning_values(output_count, Value());
  for (const auto& node_name : node_to_output_map.keys()) {
    auto node_output_tensors = node_to_output_map[node_name];

    NameLoc new_loc = NameLoc::get(builder.getStringAttr(node_name));
    int32_t max_tensor_index = 0;
    absl::c_for_each(node_output_tensors,

      }

      op.setAttr(tensorflow::kXlaTokenInputNodesAttrName,
                 ArrayAttr::get(ctx, {token}));

      auto node_name = StringAttr::get(ctx, name_mapper.GetUniqueName(&op));
      op.setAttr(tensorflow::kXlaOriginalOutsideCompilationNodeName, node_name);
      token = node_name;
    }
  }
  return success();
}

void PrepareTpuComputationForTfExportPass::runOnOperation() {

  }

 private:
  void runOnOperation() override;
};

// TF graph nodes are imported with one of following location patterns:
//   FusedLoc[NameLoc(op_type:), ..., NameLoc(node_name@func_name)] or
//   FusedLoc[NameLoc(op_type:), ..., CallSiteLoc(node_name@func_name)]. See
// tensorflow/compiler/mlir/tensorflow/translate/import_model.cc for more
// details.
bool IsImportLocPattern(FusedLoc loc) {