def taskMatcher(String nodeId, String taskIdentityPath, List<String> dependencyNodeIds) {
        new NodeMatcher(
            nodeId: nodeId,
            nodeType: TASK,
            identityPredicate: { joinPaths(it.buildPath, it.taskPath) == taskIdentityPath },
            dependencyNodeIds: dependencyNodeIds
        )
    }

    def transformStepMatcher(
        String nodeId,

  void ValidateAssets(const string& export_dir,
                      const SavedModelBundle& bundle) {
    const string asset_directory =
        io::JoinPath(export_dir, kSavedModelAssetsDirectory);
    const string asset_filename = "foo.txt";
    const string asset_filepath = io::JoinPath(asset_directory, asset_filename);
    TF_EXPECT_OK(Env::Default()->FileExists(asset_filepath));

    std::vector<Tensor> path_outputs;
    TF_ASSERT_OK(

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

//go:build wasip1

package syscall

func JoinPath(dir, file string) string {
	return joinPath(dir, file)

  void ValidateAssets(const string& export_dir,
                      const SavedModelBundleLite& bundle) {
    const string asset_directory =
        io::JoinPath(export_dir, kSavedModelAssetsDirectory);
    const string asset_filename = "foo.txt";
    const string asset_filepath = io::JoinPath(asset_directory, asset_filename);
    TF_EXPECT_OK(Env::Default()->FileExists(asset_filepath));

    std::vector<Tensor> path_outputs;
    TF_ASSERT_OK(

  const std::string export_dir = io::JoinPath(
      testing::TensorFlowSrcRoot(), "cc/saved_model/testdata", "bert1");

  TF_ASSERT_OK_AND_ASSIGN(SavedModel saved_model_pb,
                          ReadSavedModel(export_dir));
  TF_ASSERT_OK_AND_ASSIGN(FingerprintDef fingerprint_def,
                          CreateFingerprintDef(export_dir));

  const std::string export_dir2 = io::JoinPath(

tensorflow::StatusOr<TFPackage> TFPackage::Load(const std::string& path) {
  // Load the proto
  TFPackage tf_package;
  const string saved_model_pb_path = io::JoinPath(path, kSavedModelFilenamePb);
  const string saved_model_pbtxt_path =
      io::JoinPath(path, kSavedModelFilenamePbTxt);
  if (Env::Default()->FileExists(saved_model_pb_path).ok()) {
    TF_RETURN_IF_ERROR(ReadBinaryProto(Env::Default(), saved_model_pb_path,

      tsl::io::JoinPath(test_dir_,
                        "dump_0001_tensorflow::quantization::mlir_dump_test"
                        "::NoOpPass_before.mlir")));
  TF_EXPECT_OK(tsl::Env::Default()->FileExists(
      tsl::io::JoinPath(test_dir_, "dump_0002_Canonicalizer_before.mlir")));
  TF_EXPECT_OK(tsl::Env::Default()->FileExists(
      tsl::io::JoinPath(test_dir_, "dump_0002_Canonicalizer_after.mlir")));

    }
    *dump_dir = tsl::io::JoinPath(path_, files[0]);
    return absl::OkStatus();
  }

  std::string path_;
  mlir::MLIRContext context_;
  mlir::OwningOpRef<mlir::ModuleOp> module_;

 private:
  std::string GetOutputPath() {
    const auto* const test_info =
        testing::UnitTest::GetInstance()->current_test_info();
    return tsl::io::JoinPath(
        getenv("TEST_UNDECLARED_OUTPUTS_DIR"),

namespace {

string TestDataPbTxt() {
  return io::JoinPath("tensorflow", "cc", "saved_model", "testdata",
                      "half_plus_two_pbtxt", "00000123");
}

string TestDataSharded() {
  return io::JoinPath("tensorflow", "cc", "saved_model", "testdata",
                      "half_plus_two", "00000123");
}

string ChunkedSavedModel() {
  return io::JoinPath("tensorflow", "cc", "saved_model", "testdata",

  Env *env = Env::Default();
  string golden_dir = io::JoinPath(testing::TensorFlowSrcRoot(),
                                   controller_config.tf_output_dir);

  string generated_header = generator.HeaderFileContents().Render();
  string generated_source = generator.SourceFileContents().Render();
  string expected_header;
  string header_file_name = io::JoinPath(golden_dir, "testing_ops.h.golden");