ASSERT_EQ(stream.str(), "None");
}

TEST(OStreamTest, TestTensorSpec) {
  std::stringstream stream;
  TensorSpec tensor_spec;
  tensor_spec.shape = tensorflow::PartialTensorShape({2});
  tensor_spec.dtype = tensorflow::DT_FLOAT;
  stream << tensor_spec;
  ASSERT_EQ(stream.str(), "TensorSpec(shape = [2], dtype = 1)");
}

}  // namespace impl
}  // namespace libtf

    self.child.z = variables.Variable(3.0, name="child_variable")
    self.child.c = ops.convert_to_tensor(5.0)

  @def_function.function(input_signature=[
      tensor_spec.TensorSpec((), dtypes.float32),
      tensor_spec.TensorSpec((), dtypes.float32)
  ])
  def compute(self, a, b):
    return (a + self.x) * (b + self.y) / (self.child.z) + self.child.c


class ReferencesParent(module.Module):

      """Basic model with addition."""

      @def_function.function(
          input_signature=[
              tensor_spec.TensorSpec(
                  shape=[10], dtype=dtypes.float32, name='x'
              ),
              tensor_spec.TensorSpec(
                  shape=[10], dtype=dtypes.float32, name='y'
              ),
          ]
      )
      def add(self, x, y):

      self.uninitialized_variable = resource_variable_ops.UninitializedVariable(
          name="uninitialized_variable", dtype=dtypes.float32)

    @def_function.function(
        input_signature=[tensor_spec.TensorSpec((), dtypes.float32)])
    def compute(self, value):
      return self.initialized_variable + value

  to_save = Module()
  saved_model.save(

#include <vector>

#include "tensorflow/c/experimental/saved_model/core/tensor_spec.h"
#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/protobuf/struct.pb.h"

namespace tensorflow {

// SignatureDefParam represents a named Tensor input or output to a
// SignatureDefFunction.
class SignatureDefParam {
 public:
  SignatureDefParam(std::string name, TensorSpec spec);

  const std::string& name() const;

namespace impl {

TEST(TensorSpecTest, TestSupportsAbslHash) {
  tensorflow::PartialTensorShape unknown_shape;
  TensorSpec ts1;
  ts1.shape = unknown_shape;
  ts1.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts2;
  ts2.shape = tensorflow::PartialTensorShape({2});
  ts2.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts3;
  ts3.shape = tensorflow::PartialTensorShape({1, 2});
  ts3.dtype = tensorflow::DT_FLOAT;

  const TaggedValueTensor& tensor() const { return get<TaggedValueTensor>(); }

  /// Retrieves underlying value from a TaggedValue with type TENSOR_SPEC.
  const TensorSpec& tensor_spec() const { return get<TensorSpec>(); }

  /// Retrieves underlying value from a TaggedValue with type CAPSULE.
  void* capsule() const { return get<impl::Capsule>().get(); }

  /// Retrieves type of TaggedValue.

#include "tensorflow/cc/experimental/libtf/impl/tensor_spec.h"

namespace tf {
namespace libtf {
namespace impl {

std::ostream& operator<<(std::ostream& o, const None& none) {
  return o << "None";
}

std::ostream& operator<<(std::ostream& o, const String& str) {
  return o << str.str();
}

std::ostream& operator<<(std::ostream& o, const TensorSpec& x) {

#include "tensorflow/c/conversion_macros.h"
#include "tensorflow/c/experimental/saved_model/core/tensor_spec.h"

typedef struct TF_TensorSpec TF_TensorSpec;

namespace tensorflow {

DEFINE_CONVERSION_FUNCTIONS(tensorflow::TensorSpec, TF_TensorSpec)

}  // namespace tensorflow

// Returns the name of the given parameter. The caller is not responsible for
// freeing the returned char*.
TF_CAPI_EXPORT extern const char* TF_SignatureDefParamName(
    const TF_SignatureDefParam* param);

// Returns the TensorSpec associated with the given parameter. The caller is
// not reponsible for freeing the returned TF_TensorSpec*.
TF_CAPI_EXPORT extern const TF_TensorSpec* TF_SignatureDefParamTensorSpec(
    const TF_SignatureDefParam* param);