};

TEST(Dump, TextualIrToFileSuccess) {
  Graph graph(OpRegistry::Global());
  Node* node;
  TF_CHECK_OK(NodeBuilder("A", "NoOp").Finalize(&graph, &node));

  setenv("TF_DUMP_GRAPH_PREFIX", testing::TmpDir().c_str(), 1);
  UseMlirForGraphDump(MlirDumpConfig());
  string ret = DumpGraphToFile("tir", graph);
  ASSERT_EQ(ret, io::JoinPath(testing::TmpDir(), "tir.mlir"));

  string actual;

    context_.loadAllAvailableDialects();
    env_ = Env::Default();

    test_group_name_ = "TestGroup";
    test_dir_ = testing::TmpDir();
    setenv("TF_DUMP_GRAPH_PREFIX", test_dir_.c_str(), 1);
  }

  absl::Status CreateMlirModule(std::string mlir_module_filename) {
    std::string mlir_module_path = TestDataPath() + mlir_module_filename;
    mlir_module_ =

    QCHECK(tensorflow::Flags::Parse(argc, *argv, flags)) << usage;  // Crash OK

    // Initialize any TensorFlow support, parsing boilerplate flags (e.g. logs)
    tensorflow::port::InitMain(usage.c_str(), argc, argv);

    // Validate flags
    if (help_) {
      LOG(QFATAL) << usage;  // Crash OK
    }

    QCHECK(!source_dir_.empty()) << usage;  // Crash OK

				req.AddCookie(c)
			}

			got := req.CookiesNamed(tt.filter)

			if !reflect.DeepEqual(got, tt.want) {
				asStr := func(v any) string {
					blob, _ := json.MarshalIndent(v, "", "  ")
					return string(blob)
				}
				t.Fatalf("Result mismatch\n\tGot: %s\n\tWant: %s", asStr(got), asStr(tt.want))
			}
		})
	}
}

const (
	fileaContents = "This is a test file."

  for (const auto& device : component_devices) {
    ImmediateTensorHandlePtr handlePtr;
    TF_RETURN_IF_ERROR(internal::CreateUninitializedResourceVariable(
        ctx, dtype, shape, device.empty() ? nullptr : device.c_str(),
        &handlePtr));
    if (!tensorflow::isa<TensorHandle>(handlePtr.get())) {
      return errors::Internal("Returned replica handle has unsupported type.");
    }

    Set(rhs);
    return *this;
  }

  void Set(const FilePath& rhs) {
    pathname_ = rhs.pathname_;
  }

  const std::string& string() const { return pathname_; }
  const char* c_str() const { return pathname_.c_str(); }

  // Returns the current working directory, or "" if unsuccessful.
  static FilePath GetCurrentDir();

  // Given directory = "dir", base_name = "test", number = 0,

    std::cerr << usage << "\n";
    return 0;
  }
  bool parsed_flags_ok = tensorflow::Flags::Parse(&argc, argv, flag_list);
  QCHECK(parsed_flags_ok) << "\n" << usage;

  tensorflow::port::InitMain(usage.c_str(), &argc, &argv);
  QCHECK(argc == 1) << "\nERROR: This command does not take any arguments "
                       "other than flags. See --help.\n\n";
  tensorflow::Status status = tensorflow::tfcompile::Main(flags);

const char* TF_OperationName(TF_Operation* oper) {
  return oper->node.name().c_str();
}

const char* TF_OperationOpType(TF_Operation* oper) {
  return oper->node.type_string().c_str();
}

const char* TF_OperationDevice(TF_Operation* oper) {
  return oper->node.requested_device().c_str();
}

int TF_OperationNumOutputs(TF_Operation* oper) {
  return oper->node.num_outputs();

  TFE_OpSetAttrInt(op.get(), "instance_key", 0);
  const std::string merge_op("Add");
  TFE_OpSetAttrString(op.get(), "merge_op", merge_op.c_str(),
                      merge_op.length());
  const std::string final_op("Id");
  TFE_OpSetAttrString(op.get(), "final_op", final_op.c_str(),
                      final_op.length());
  TFE_OpSetAttrIntList(op.get(), "subdiv_offsets", nullptr, 0);

        if ((!tag.empty()) && !tags.insert(tag).second) {
          std::ostringstream err;
          err << "Duplicate tag " << tag << " found in summary inputs ";
          TF_SetStatus(status.get(), TF_INVALID_ARGUMENT, err.str().c_str());
          TF_OpKernelContext_Failure(ctx, status.get());
          return;
        }
        *s.add_value() = summary_in.value(v);
      }
    }
  }
  Safe_TF_TensorPtr summary_tensor(TF_AllocateOutput(