Function ConstantTailTest

tensorflow/core/framework/tensor_util_test.cc:538–570

template <typename T>
void ConstantTailTest(int64 length, int64 tail_length, bool as_field) {
  using TensorProtoHelper = tensor::internal::TensorProtoHelper<T>;
  using FieldType = typename TensorProtoHelper::FieldType;
  const float kMinCompressionRatio = 2.0;
  const int64 kMinSize = 64;
  TensorProto tensor_proto =
      as_field ? CreateAsProtoField<T>(length, tail_length)
               : CreateAsProtoTensorContent<T>(length, tail_length);
  TensorProto original_tensor_proto = tensor_proto;
  int64 original_size =
      length * (as_field ? (is_complex<T>::value ? 2 : 1) * sizeof(FieldType)
                         : sizeof(T));
  int64 size_as_tensor_content = length * sizeof(T);
  int64 size_as_field = std::min(length, (length - tail_length + 1)) *
                        (is_complex<T>::value ? 2 : 1) * sizeof(FieldType);
  bool will_compress = std::min(size_as_tensor_content, size_as_field) <=
                       static_cast<int64>(original_size / kMinCompressionRatio);

  EXPECT_EQ(tensor::CompressTensorProtoInPlace(kMinSize, kMinCompressionRatio,
                                               &tensor_proto),
            will_compress);
  if (will_compress) {
    if (size_as_tensor_content < size_as_field) {
      EXPECT_EQ(TensorProtoHelper::NumValues(tensor_proto), 0);
      EXPECT_FALSE(tensor_proto.tensor_content().empty());
    } else {
      EXPECT_LE(TensorProtoHelper::NumValues(tensor_proto),
                (length - tail_length + 1));
      EXPECT_TRUE(tensor_proto.tensor_content().empty());
    }
  }
  CompareTensorValues<T>(tensor_proto, original_tensor_proto);
}

TEST(TensorProtoUtil, CompressTensorProtoConstantTail) {
  const int kLength = 64;