EXPECT_EQ(SavedModelWriteApi("foo").value(), 0);
  SavedModelWriteApi("foo").IncrementBy(1);
  EXPECT_EQ(SavedModelWriteApi("foo").value(), 1);

  EXPECT_EQ(SavedModelWriteCount("1").value(), 0);
  SavedModelWriteCount("1").IncrementBy(1);
  EXPECT_EQ(SavedModelWriteCount("1").value(), 1);
}

TEST(MetricsTest, TestSavedModelRead) {
  SavedModelReadApi("bar").IncrementBy(1);
  EXPECT_EQ(SavedModelReadApi("bar").value(), 1);

      dynamism_op_counter->GetCell(op->getName().getStringRef().str())
          ->IncrementBy(1);
    }

    return WalkResult::advance();
  });

  if (has_dynamic_op) {
    dynamism_function_counter->GetCell(kDynamicFunctionName)->IncrementBy(1);
  } else {
    dynamism_function_counter->GetCell(kNotDynamicFunctionName)->IncrementBy(1);
  }
}
}  // namespace

std::unique_ptr<mlir::OperationPass<mlir::func::FuncOp>>

          .IncrementBy(1);
    }
    return result;
  }

#if !defined(PLATFORM_WINDOWS) && !defined(__APPLE__)
  absl::Status result =
      tools::proto_splitter::Merger::Read(file_prefix, saved_model_proto);
  if (result.ok()) {
    metrics::SavedModelReadCount(
        saved_model::GetWriteVersion(*saved_model_proto))
        .IncrementBy(1);
  }
  return result;
#endif

//
// The code under test will have created streamz counters like this:
// auto* streamz = tensorflow::monitoring::Counter<1>::New("name",
// "description", "label");
// and then incremented that counter for various values of label:
// streamz->GetCell("label-value")->IncrementBy(1);
//
// The test code can then read and test the value of that counter:
//
// auto* reader = TFE_MonitoringNewCounterReader("name");
// test();

}

tensorflow::Status RecordStatusIfError(absl::Status status) {
  if (status.ok()) {
    return absl::OkStatus();
  }

  tf_dialect_to_executor_dialect_status->GetCell(kExportFailed)->IncrementBy(1);
  VLOG(1) << "Failed to export from TF Dialect to TF Executor Dialect. "
          << status;

  constexpr char bridge_subcomponent[] =
      "TFXLA_TF_FUNCTIONAL_TO_EXECUTOR_EXPORT_v2";

                                      saved_model_proto);
      if (result.ok()) {
        metrics::SavedModelReadCount(
            saved_model::GetWriteVersion(*saved_model_proto))
            .IncrementBy(1);
      }
      return result;
    }
  }

  const std::string saved_model_pbtxt_path =
      io::JoinPath(export_dir, kSavedModelFilenamePbTxt);
  auto saved_model_pbtxt_exists =

  if (status.ok()) {
    return absl::OkStatus();
  }

  VLOG(1) << "Failed to export from TF Dialect to TF Executor Dialect. "
          << status;
  tf_dialect_to_executor_dialect_status->GetCell(kExportFailed)->IncrementBy(1);

  constexpr char bridge_subcomponent[] =
      "TFXLA_TF_FUNCTIONAL_TO_EXECUTOR_EXPORT_v1";
  constexpr char kBridgeComponent[] = "TFXLABridge";

  tsl::OkOrSetErrorCounterPayload(

        mlir_function_pass_fallback_count->GetCell(kFailure)->IncrementBy(1);
      } else if (pass_state == MlirOptimizationPassState::Enabled) {
        return pass_status;
      }
    } else {
      if (pass_state == MlirOptimizationPassState::FallbackEnabled) {
        mlir_function_pass_fallback_count->GetCell(kSuccess)->IncrementBy(1);
      }
    }

  }

  std::string has_tpu_partitioned_call_str =
      has_tpu_partitioned_call ? "true" : "false";
  has_tpu_partitioned_call_streamz->GetCell(has_tpu_partitioned_call_str)
      ->IncrementBy(1);
}

}  // namespace

std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
CreateInferenceMetricsPass() {
  return std::make_unique<InferenceMetricsPass>();
}

}  // namespace internal

    LOG_FIRST_N(INFO, 1) << "Skipping Graph Decomposition Pass, decomposition"
                            " library was not found";
    return absl::OkStatus();
  }

  tf_core_op_expansion_graph_counter->GetCell()->IncrementBy(1);

  LOG_FIRST_N(INFO, 1) << "Run Graph Decomposition Passes";

  TF_RETURN_IF_ERROR(DecomposeGraph(module));

  LOG_FIRST_N(INFO, 1) << "Finish Graph Decomposition Passes";

  return absl::OkStatus();
}