Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/src/google/protobuf/message_unittest.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 30 matching lines @@
 #include <io.h>
 #else
 #include <unistd.h>
 #endif
 #include <sstream>
 #include <fstream>
 
 #include <google/protobuf/test_util.h>
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/generated_message_reflection.h>
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
@@ skipping 114 matching lines @@
     // EOF is reached before the expected number of bytes.
     io::ArrayInputStream stream(data.data(), data.size());
     protobuf_unittest::TestAllTypes message;
     EXPECT_FALSE(
       message.ParseFromBoundedZeroCopyStream(&stream, data.size() + 1));
   }
 }
 
 TEST(MessageTest, ParseFailsIfNotInitialized) {
   unittest::TestRequired message;
-  std::vector<string> errors;
+  vector<string> errors;
 
   {
     ScopedMemoryLog log;
     EXPECT_FALSE(message.ParseFromString(""));
     errors = log.GetMessages(ERROR);
   }
 
   ASSERT_EQ(1, errors.size());
   EXPECT_EQ("Can't parse message of type \"protobuf_unittest.TestRequired\" "
             "because it is missing required fields: a, b, c",
@@ skipping 62 matching lines @@
   }
 
   for (int i = 0; i < 2 * 1024 + 1; ++i) {
     message.add_repeated_cord()->CopyFrom(one_megabyte);
   }
 
   Cord serialized;
   EXPECT_FALSE(message.AppendToCord(&serialized));
 }
 
-TEST(MessageTest, CheckBigOverflow) {
-  unittest::TestAllTypes message;
-  // Create a message with size just over 4GB. We should be able to detect this
-  // too, even though it will make a plain "int" wrap back to a positive number.
-  const string data(1024, 'x');
-  Cord one_megabyte;
-  for (int i = 0; i < 1024; i++) {
-    one_megabyte.Append(data);
-  }
-
-  for (int i = 0; i < 4 * 1024 + 1; ++i) {
-    message.add_repeated_cord()->CopyFrom(one_megabyte);
-  }
-
-  Cord serialized;
-  EXPECT_FALSE(message.AppendToCord(&serialized));
-}
-
 #endif  // PROTOBUF_HAS_DEATH_TEST
 
 namespace {
-// An input stream that repeats a string's content for a number of times. It
-// helps us create a really large input without consuming too much memory. Used
-// to test the parsing behavior when the input size exceeds 2G or close to it.
-class RepeatedInputStream : public io::ZeroCopyInputStream {
+
+class NegativeByteSize : public unittest::TestRequired {
  public:
-  RepeatedInputStream(const string& data, size_t count)
-      : data_(data), count_(count), position_(0), total_byte_count_(0) {}
+  virtual int ByteSize() const { return -1; }
+};
 
-  virtual bool Next(const void** data, int* size) {
-    if (position_ == data_.size()) {
-      if (--count_ == 0) {
-        return false;
-      }
-      position_ = 0;
-    }
-    *data = &data_[position_];
-    *size = static_cast<int>(data_.size() - position_);
-    position_ = data_.size();
-    total_byte_count_ += *size;
-    return true;
-  }
-
-  virtual void BackUp(int count) {
-    position_ -= static_cast<size_t>(count);
-    total_byte_count_ -= count;
-  }
-
-  virtual bool Skip(int count) {
-    while (count > 0) {
-      const void* data;
-      int size;
-      if (!Next(&data, &size)) {
-        break;
-      }
-      if (size >= count) {
-        BackUp(size - count);
-        return true;
-      } else {
-        count -= size;
-      }
-    }
-    return false;
-  }
-
-  virtual int64 ByteCount() const { return total_byte_count_; }
-
- private:
-  string data_;
-  size_t count_;     // The number of strings that haven't been consuemd.
-  size_t position_;  // Position in the string for the next read.
-  int64 total_byte_count_;
-};
 }  // namespace
 
-TEST(MessageTest, TestParseMessagesCloseTo2G) {
-  // Create a message with a large string field.
-  string value = string(64 * 1024 * 1024, 'x');
-  protobuf_unittest::TestAllTypes message;
-  message.set_optional_string(value);
+TEST(MessageTest, SerializationFailsOnNegativeByteSize) {
+  NegativeByteSize message;
+  string string_output;
+  EXPECT_FALSE(message.AppendPartialToString(&string_output));
 
-  // Repeat this message in the input stream to make the total input size
-  // close to 2G.
-  string data = message.SerializeAsString();
-  size_t count = static_cast<size_t>(kint32max) / data.size();
-  RepeatedInputStream input(data, count);
-
-  // The parsing should succeed.
-  protobuf_unittest::TestAllTypes result;
-  EXPECT_TRUE(result.ParseFromZeroCopyStream(&input));
-
-  // When there are multiple occurences of a singulr field, the last one
-  // should win.
-  EXPECT_EQ(value, result.optional_string());
-}
-
-TEST(MessageTest, TestParseMessagesOver2G) {
-  // Create a message with a large string field.
-  string value = string(64 * 1024 * 1024, 'x');
-  protobuf_unittest::TestAllTypes message;
-  message.set_optional_string(value);
-
-  // Repeat this message in the input stream to make the total input size
-  // larger than 2G.
-  string data = message.SerializeAsString();
-  size_t count = static_cast<size_t>(kint32max) / data.size() + 1;
-  RepeatedInputStream input(data, count);
-
-  // The parsing should fail.
-  protobuf_unittest::TestAllTypes result;
-  EXPECT_FALSE(result.ParseFromZeroCopyStream(&input));
+  io::ArrayOutputStream coded_raw_output(NULL, 100);
+  io::CodedOutputStream coded_output(&coded_raw_output);
+  EXPECT_FALSE(message.SerializePartialToCodedStream(&coded_output));
 }
 
 TEST(MessageTest, BypassInitializationCheckOnSerialize) {
   unittest::TestRequired message;
   io::ArrayOutputStream raw_output(NULL, 0);
   io::CodedOutputStream output(&raw_output);
   EXPECT_TRUE(message.SerializePartialToCodedStream(&output));
 }
 
 TEST(MessageTest, FindInitializationErrors) {
   unittest::TestRequired message;
-  std::vector<string> errors;
+  vector<string> errors;
   message.FindInitializationErrors(&errors);
   ASSERT_EQ(3, errors.size());
   EXPECT_EQ("a", errors[0]);
   EXPECT_EQ("b", errors[1]);
   EXPECT_EQ("c", errors[2]);
 }
 
 TEST(MessageTest, ParseFailsOnInvalidMessageEnd) {
   unittest::TestAllTypes message;
 
   // Control case.
   EXPECT_TRUE(message.ParseFromArray("", 0));
 
   // The byte is a valid varint, but not a valid tag (zero).
   EXPECT_FALSE(message.ParseFromArray("\0", 1));
 
   // The byte is a malformed varint.
   EXPECT_FALSE(message.ParseFromArray("\200", 1));
 
   // The byte is an endgroup tag, but we aren't parsing a group.
   EXPECT_FALSE(message.ParseFromArray("\014", 1));
 }
 
-// Regression test for b/23630858
-TEST(MessageTest, MessageIsStillValidAfterParseFails) {
-  unittest::TestAllTypes message;
-
-  // 9 0xFFs for the "optional_uint64" field.
-  string invalid_data = "\x20\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF";
-
-  EXPECT_FALSE(message.ParseFromString(invalid_data));
-  message.Clear();
-  EXPECT_EQ(0, message.optional_uint64());
-}
-
 namespace {
 
 void ExpectMessageMerged(const unittest::TestAllTypes& message) {
   EXPECT_EQ(3, message.optional_int32());
   EXPECT_EQ(2, message.optional_int64());
   EXPECT_EQ("hello", message.optional_string());
 }
 
 void AssignParsingMergeMessages(
     unittest::TestAllTypes* msg1,
@@ skipping 130 matching lines @@
   const Descriptor* descriptor = pool.BuildFile(file)->message_type(0);
 
   // Trying to construct it should return NULL.
   EXPECT_TRUE(
     MessageFactory::generated_factory()->GetPrototype(descriptor) == NULL);
 }
 
 
 }  // namespace protobuf
 }  // namespace google