const std::vector<std::string>& target_nodes,
    std::vector<Tensor>* outputs) {
  tensorflow::RunMetadata run_metadata;
  return Run(tensorflow::RunOptions(), inputs, output_names, target_nodes,
             outputs, &run_metadata);
}

Status FakeSession::Run(
    const tensorflow::RunOptions& run_options,
    const std::vector<std::pair<std::string, Tensor>>& inputs,

using testing::IsEmpty;

TEST(PermutationTest, PermuteEmptyArray) {
  const SmallVector<int> permutation_result =
      Permute<int>(SmallVector<int>{}, SmallVector<int64_t>{});
  EXPECT_THAT(permutation_result, IsEmpty());
}

TEST(PermutationTest, PermuteOneElement) {
  const SmallVector<int> single_element_array = {8};
  const SmallVector<int64_t> permutation = {0};

  const SmallVector<int> permutation_result =

                       Inputs(m_input_shape, Const(zero_64), Const(one_64)))),
          Out(NodeWith(Op("Slice"), AssignedDevice(kHostName),
                       Inputs(m_begin_s64, Const(zero_64), Const(one_64)))))));
  auto m_dynamic_slice_size =
      Out(NodeWith(Op("ConcatV2"), AssignedDevice(kHostName),
                   Inputs(m_slice_size_0, Const(static_cast<int64_t>(500)),
                          Const(zero_32))));

  static ResourceConstructingOps EntryState(Value value);
  bool operator==(const ResourceConstructingOps &rhs) const {
    return ops == rhs.ops;
  }

  static ResourceConstructingOps join(const ResourceConstructingOps &lhs,
                                      const ResourceConstructingOps &rhs);
  void print(raw_ostream &os) const;

  // The operation(s) which created the resource value.

// Creates a function to wrap the section between arguments and results.
SmallVector<Value, 4> LiftAsFunctionCall(
    OpBuilder& builder, const Location location,
    const FunctionCallOpType call_op_type, const StringRef func_name,
    const ArrayRef<Value> arguments, const ArrayRef<Value> results,
    const ArrayRef<NamedAttribute> attributes) {
  MLIRContext* context = builder.getContext();
  if (results.empty()) {

GraphdefToMlirTranslateFunction(
    llvm::StringRef input, const std::vector<std::string>& input_arrays,
    const std::vector<std::string>& input_dtypes,
    const std::vector<std::optional<std::vector<int>>>& input_shapes,
    const std::vector<std::string>& output_arrays,
    const std::vector<std::string>& control_output_arrays,
    const GraphdefToMlirOptions& import_options, mlir::MLIRContext* context);

ABSL_DEPRECATED(

const IPVSConnReuseModeFixedKernelVersion = "5.9"

// UserNamespacesSupportKernelVersion is the kernel version where idmap for tmpfs support was added
// (ref: https://github.com/torvalds/linux/commit/05e6295f7b5e05f09e369a3eb2882ec5b40fff20)
const UserNamespacesSupportKernelVersion = "6.3"

   public:
    DeadnessPredicate(const DeadnessPredicate&) = default;
    DeadnessPredicate(DeadnessPredicate&&) = default;

    DeadnessPredicate& operator=(const DeadnessPredicate&) = default;
    DeadnessPredicate& operator=(DeadnessPredicate&&) = default;

    bool operator==(const DeadnessPredicate& other) const {
      return other.pred_ == pred_;
    }

    bool operator!=(const DeadnessPredicate& other) const {

    }
  }
}

inline float GetSparsity(const int num_zeros, const int num_elements) {
  return (1.0 * num_zeros / num_elements);
}

float CalculateRandomSparsity(const ElementsAttr& attr,
                              const ShapedType& type) {
  int num_elements = type.getNumElements();
  int num_zeros = 0;

  if (mlir::isa<FloatType>(type.getElementType())) {
    for (const auto val : attr.getValues<APFloat>()) {

      "  void FuzzImpl($0) final {\n",
      absl::StrJoin(
          op_info.graph_op_def.input_arg(), ", ",
          [](string* out, const auto arg) {
            strings::StrAppend(out, "const Tensor& ", arg.name(), "_0");
            if (ArgIsList(arg))
              strings::StrAppend(out, ", const Tensor& ", arg.name(), "_1");
          }));

  string run_inputs_str = absl::Substitute(
      "    RunInputs({$0});\n",