}
}

void TestEncodeDecode(int line, const std::vector<string>& data) {
  const int64_t n = data.size();
  Status status;
  for (const std::vector<int64_t>& dims :
       std::vector<std::vector<int64_t>>{{n}, {1, n}, {n, 1}, {n / 2, 2}}) {
    // Create C++ Tensor
    Tensor src(tensorflow::DT_STRING, TensorShape(dims));
    for (int64_t i = 0; i < src.NumElements(); ++i) {
      src.flat<tstring>()(i) = data[i];
    }

                             TF_DataType dtype, const int64_t* dims,
                             int num_dims, size_t len, TF_Status* status) {
  TF_SetStatus(status, TF_OK, "");
  auto* cc_ctx = reinterpret_cast<::tensorflow::OpKernelContext*>(context);
  tensorflow::gtl::ArraySlice<const int64_t> dimarray(
      reinterpret_cast<const int64_t*>(dims), num_dims);
  tensorflow::Tensor* tensor;

    return absl::OkStatus();
  }

  DialectRegistry registry_;
  MLIRContext context_;
  OwningOpRef<mlir::ModuleOp> mlir_module_;
};

TEST_F(TensorflowDialectToExecutorTest, ConvertsToExecutor) {
  CellReader<int64_t> compilation_status(kExportStreamzName);

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

  TF_EXPECT_OK(ExportFromTensorflowDialectToExecutor(*mlir_module_));

#ifndef TENSORFLOW_C_TF_FILE_STATISTICS_H_
#define TENSORFLOW_C_TF_FILE_STATISTICS_H_

#include <stdint.h>

typedef struct TF_FileStatistics {
  // The length of the file in bytes.
  int64_t length;
  // The last modified time in nanoseconds.
  int64_t mtime_nsec;
  // Whether the name refers to a directory.
  bool is_directory;
} TF_FileStatistics;

// TODO(b/139060984): `tensorflow::FileStatistics` from

                                                     MLIRContext& context,
                                                     double scale,
                                                     int64_t zero_point,
                                                     bool narrow_range = false);

// Creates a `UniformQuantizedType` with the given `scale` and `zero_point`

  func->setAttr("tf._implements", attr_value);
  return func;
}

func::FuncOp createMaxUnpoolingFunc(
    mlir::Builder* builder, const SmallVector<int64_t, 4>& input_shape,
    const SmallVector<int64_t, 4>& output_shape) {
  auto input_type = RankedTensorType::get(input_shape, builder->getF32Type());
  auto indices_type = RankedTensorType::get(input_shape, builder->getI64Type());

}

ConstantOp GetScalarConstOfType(Type ty, Location loc, int64_t raw_value,
                                OpBuilder* builder);

ConstantOp GetScalarNegZeroOfType(Type ty, Location loc, OpBuilder* builder);

// Converts an ArrayAttr to a 1D 64-bit dense elements attribute.
DenseIntElementsAttr GetI64ElementsAttr(ArrayAttr attr);
DenseIntElementsAttr GetI64ElementsAttr(llvm::ArrayRef<int64_t> values,

  // Scan the elements of the dense elements attributes and quantize them by
  // using the right quantization parameters.
  int64_t flatten_index = 0;
  auto shape = type.getShape();
  int64_t chunk_size =
      std::accumulate(std::next(shape.begin(), quantization_dim_ + 1),
                      shape.end(), 1, std::multiplies<int64_t>());
  Type new_element_type =
      IntegerType::get(attr.getContext(), storage_bit_width_);

                    const TFE_OpAttrs* attributes, int expected_max_outputs,
                    CancellationManager& cancellation_manager,
                    absl::optional<int64_t> step_id = absl::nullopt);
  // Block until the previous `StartExecute` operation has executed. Forwards
  // the status from `TFE_Execute` and returns outputs if the status is OK.

 private:
  ParallelTensor(const ParallelDevice& device,
                 std::vector<TensorHandlePtr> tensors,
                 absl::Span<const int64_t> shape, const TF_DataType dtype)
      : device_(device),
        tensors_(std::move(tensors)),
        shape_(std::vector<int64_t>(shape.begin(), shape.end())),
        dtype_(dtype) {}
  ParallelTensor(const ParallelDevice& device,