func() (string, error) { return "createdBy", nil },
			map[string]string{
				GCPProject:       "env_pid",
				GCPProjectNumber: "env_pn",
				GCPCluster:       "env_cluster",
				GCPLocation:      "env_location",
			},
			map[string]string{
				GCPProject: "env_pid", GCPProjectNumber: "env_pn", GCPLocation: "env_location", GCPCluster: "env_cluster",
			},
		},
		{
			"use env variable without fill",

			uintptr(unsafe.Pointer(&argvp[0])),
			uintptr(unsafe.Pointer(&envvp[0])))
	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
		// Similarly on Darwin.
		err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
	} else if runtime.GOOS == "openbsd" && runtime.GOARCH != "mips64" {
		// Similarly on OpenBSD.
		err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
	} else {
		_, _, err1 = RawSyscall(SYS_EXECVE,

 protected:
  SaveVariablesToCheckpointTest() : env_(Env::Default()) {
    ctx_.loadDialect<mlir::func::FuncDialect, mlir::TF::TensorFlowDialect,
                     mlir::tf_saved_model::TensorFlowSavedModelDialect>();
  }

  absl::StatusOr<std::string> MakeTempDir() {
    std::string tmp_dir{};
    if (!env_->LocalTempFilename(&tmp_dir)) {
      return absl::InternalError("Failed to create temp file.");

 public:
  LowerClusterToRuntimeOpsTest() {
    mlir::RegisterCommonToolingDialects(registry_);
    context_.appendDialectRegistry(registry_);
    context_.loadAllAvailableDialects();

    env_ = Env::Default();
    test_group_name_ = "TestGroup";
    test_dir_ = testing::TmpDir();
    setenv("TF_DUMP_GRAPH_PREFIX", test_dir_.c_str(), /*overwrite=*/1);
  }

                public Process exec(String command, String[] envp) { return null; }
                public Process exec(String command, String[] envp, File file) { return null; }
                public Process exec(String command, List<?> envp, File file) { return null; }
                public Process exec(String[] command) { return null; }
                public Process exec(String[] command, String[] envp) { return null; }

        externalProcessStarted(command, consumer);
        return runtime.exec(command, envp);
    }

    public static Process exec(Runtime runtime, String[] command, String[] envp, String consumer) throws IOException {
        externalProcessStarted(command, consumer);
        return runtime.exec(command, envp);
    }

    // Delete files in the test directory.
    std::vector<std::string> files;
    TF_ASSERT_OK(
        env_->GetMatchingPaths(tsl::io::JoinPath(test_dir_, "*"), &files));
    for (const std::string& file : files) {
      TF_ASSERT_OK(env_->DeleteFile(file));
    }
  }

  tsl::Env* env_;
  std::string test_dir_;
  std::unique_ptr<mlir::MLIRContext> ctx_;
};

      const string file_name = absl::Substitute("api_def_$0.pbtxt", op.name());
      const string file_path = io::JoinPath(dir, file_name);
      if (env_->FileExists(file_path).ok()) {
        TF_CHECK_OK(api_def_map_->LoadFile(env_, file_path)) << file_path;
      } else {
        // API defs are currently used for only optional pieces.
      }
    }
  }

  }

  DialectRegistry registry_;
  MLIRContext context_;
  OwningOpRef<mlir::ModuleOp> mlir_module_;
  Env* env_;
  std::string test_dir_;
  std::string test_group_name_;
};

TEST_F(LoggingHooksTest, DumpsPassData) {
  std::vector<std::string> files;
  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());

  TF_ASSERT_OK(CreateMlirModule("dead_const.mlir"));

	contextMu    sync.Mutex
	contextNames sets.String

	suiteLabels label.Set

	dumpCount *atomic.Uint64

	traceContext context.Context
	traces       sync.Map
}

func newSuiteContext(s *resource.Settings, envFn resource.EnvironmentFactory, labels label.Set) (*suiteContext, error) {
	scopeID := fmt.Sprintf("[suite(%s)]", s.TestID)

	workDir := path.Join(s.RunDir(), "_suite_context")