ASSERT_EQ(errors::OK, s.code()) << s.message();
    s = dyn_cast<tracing::TracingContext>(ctx.get())->AddParameter(
        DT_FLOAT, shape, &x_raw);
    ASSERT_EQ(errors::OK, s.code()) << s.message();
    x.reset(x_raw);
  }

  PartialTensorShape shape;
  Status s = x->Shape(&shape);
  ASSERT_EQ(errors::OK, s.code()) << s.message();

  auto s = GetValue(t, &analytical_tensor);
  ASSERT_EQ(errors::OK, s.code()) << s.message();

  int64_t num_elem_analytical = 1;
  auto num_dims_analytical = TF_NumDims(analytical_tensor);
  ASSERT_EQ(dims.size(), num_dims_analytical);
  for (int j = 0; j < num_dims_analytical; j++) {
    auto dim_analytical = TF_Dim(analytical_tensor, j);
    ASSERT_EQ(dims[j], dim_analytical);
    num_elem_analytical *= dim_analytical;

  TFE_Execute(func, &retvals[0], &num_retvals, status);
  ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  ASSERT_EQ(1, num_retvals);
  TF_Tensor* t = TFE_TensorHandleResolve(retvals[0], status);
  ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_DeleteTensorHandle(retvals[0]);
  float sum = 0;
  ASSERT_EQ(sizeof(sum), TF_TensorByteSize(t));
  memcpy(&sum, TF_TensorData(t), TF_TensorByteSize(t));

    status_ = StatusFromTF_Status(status.get());
    ASSERT_EQ(errors::OK, status_.code()) << status_.message();

    {
      AbstractContext* ctx_raw = nullptr;
      status_ =
          BuildImmediateExecutionContext(std::get<1>(GetParam()), &ctx_raw);
      ASSERT_EQ(errors::OK, status_.code()) << status_.message();
      immediate_execution_ctx_.reset(ctx_raw);
    }

  std::stringstream stream;
  stream << x;
  ASSERT_EQ(stream.str(), "42");
}

TEST(OStreamTest, TestFloat32) {
  Float32 x(0.375);  // Exactly representable as a float.
  std::stringstream stream;
  stream << x;
  ASSERT_EQ(stream.str(), "0.375");
}

TEST(OStreamTest, TestString) {
  String s("foo");
  std::stringstream stream;
  stream << s;
  ASSERT_EQ(stream.str(), "foo");
}

                          &numerical_grad_raw);
    ASSERT_EQ(errors::OK, s.code()) << s.message();
    numerical_grad.reset(numerical_grad_raw);
  }

  TF_Tensor* numerical_tensor;
  s = GetValue(numerical_grad.get(), &numerical_tensor);
  ASSERT_EQ(errors::OK, s.code()) << s.message();
  auto num_elem_numerical = TF_TensorElementCount(numerical_tensor);
  ASSERT_EQ(num_elem_numerical, num_grad);

      checker_->FindUncompilableNodes(*uncompilable_op, flib_runtime);
  ASSERT_EQ(1, uncompilable_nodes.size());
  auto node_info_it =
      uncompilable_nodes.find(NameAttrList().ShortDebugString());
  ASSERT_NE(uncompilable_nodes.end(), node_info_it);
  const auto& uncompilable_nodes_inside_function = node_info_it->second.second;
  ASSERT_EQ(1, uncompilable_nodes_inside_function.size());

          tensorflow::unwrap(saved_model));
  tensorflow::Variable* uninitialized_variable;
  ASSERT_EQ(absl::OkStatus(), model_api->GetVariable("uninitialized_variable",
                                                     &uninitialized_variable));
  ASSERT_EQ(tensorflow::DT_FLOAT, uninitialized_variable->dtype());

  ASSERT_EQ(absl::OkStatus(),
            model_api->GetVariable("sub_module.uninitialized_variable",

  TF_GraphCopyFunction(func_graph_, func_, nullptr, s_);
  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);

  EXPECT_EQ(TF_GraphNumFunctions(func_graph_), 1);
  EXPECT_EQ(TF_GraphGetFunctions(func_graph_, funcs, 1, s_), 1);
  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);

  TF_GraphRemoveFunction(func_graph_, func_name_, s_);
  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);

#include "tensorflow/core/platform/test.h"

namespace mlir {
namespace TFL {
namespace {

TEST(SizeUtilTest, TestConvertsSize) {
  ASSERT_EQ(ConvertToTfliteSize(1), 1);
  ASSERT_EQ(ConvertToTfliteSize(-1), -1);
  ASSERT_EQ(ConvertToTfliteSize(mlir::ShapedType::kDynamic), -1);
}

}  // namespace
}  // namespace TFL