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;
-  vector<string> errors;
+  std::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 {
+ public:
+  RepeatedInputStream(const string& data, size_t count)
+      : data_(data), count_(count), position_(0), total_byte_count_(0) {}
 
-class NegativeByteSize : public unittest::TestRequired {
- public:
-  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, SerializationFailsOnNegativeByteSize) {
-  NegativeByteSize message;
-  string string_output;
-  EXPECT_FALSE(message.AppendPartialToString(&string_output));
+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);
 
-  io::ArrayOutputStream coded_raw_output(NULL, 100);
-  io::CodedOutputStream coded_output(&coded_raw_output);
-  EXPECT_FALSE(message.SerializePartialToCodedStream(&coded_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));
 }
 
 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;
-  vector<string> errors;
+  std::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