Integrate recent changes from Google-internal code tree. See CHANGES.txt

for details.

1 files changed, 59 insertions, 16 deletions

diff --git a/src/google/protobuf/wire_format_unittest.cc b/src/google/protobuf/wire_format_unittest.cc
index 5a7c6c23..1f00a93d 100644
--- a/src/google/protobuf/wire_format_unittest.cc
+++ b/src/google/protobuf/wire_format_unittest.cc
@@ -44,6 +44,7 @@
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
+#include <google/protobuf/stubs/stl_util-inl.h>
 
 namespace google {
 namespace protobuf {
@@ -179,6 +180,7 @@ TEST(WireFormatTest, Serialize) {
     io::StringOutputStream raw_output(&generated_data);
     io::CodedOutputStream output(&raw_output);
     message.SerializeWithCachedSizes(&output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Serialize using WireFormat.
@@ -186,6 +188,7 @@ TEST(WireFormatTest, Serialize) {
     io::StringOutputStream raw_output(&dynamic_data);
     io::CodedOutputStream output(&raw_output);
     WireFormat::SerializeWithCachedSizes(message, size, &output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Should be the same.
@@ -207,6 +210,7 @@ TEST(WireFormatTest, SerializeExtensions) {
     io::StringOutputStream raw_output(&generated_data);
     io::CodedOutputStream output(&raw_output);
     message.SerializeWithCachedSizes(&output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Serialize using WireFormat.
@@ -214,6 +218,7 @@ TEST(WireFormatTest, SerializeExtensions) {
     io::StringOutputStream raw_output(&dynamic_data);
     io::CodedOutputStream output(&raw_output);
     WireFormat::SerializeWithCachedSizes(message, size, &output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Should be the same.
@@ -235,6 +240,7 @@ TEST(WireFormatTest, SerializeFieldsAndExtensions) {
     io::StringOutputStream raw_output(&generated_data);
     io::CodedOutputStream output(&raw_output);
     message.SerializeWithCachedSizes(&output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Serialize using WireFormat.
@@ -242,6 +248,7 @@ TEST(WireFormatTest, SerializeFieldsAndExtensions) {
     io::StringOutputStream raw_output(&dynamic_data);
     io::CodedOutputStream output(&raw_output);
     WireFormat::SerializeWithCachedSizes(message, size, &output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Should be the same.
@@ -287,8 +294,8 @@ TEST(WireFormatTest, SerializeMessageSet) {
     unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
   message_set.MutableExtension(
     unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
-  message_set.mutable_unknown_fields()->AddField(kUnknownTypeId)
-                                      ->add_length_delimited("bar");
+  message_set.mutable_unknown_fields()->AddLengthDelimited(
+    kUnknownTypeId, "bar");
 
   string data;
   ASSERT_TRUE(message_set.SerializeToString(&data));
@@ -319,6 +326,43 @@ TEST(WireFormatTest, SerializeMessageSet) {
   EXPECT_EQ("bar", raw.item(2).message());
 }
 
+TEST(WireFormatTest, SerializeMessageSetToStreamAndArrayAreEqual) {
+  // Serialize a MessageSet to a stream and to a flat array and check that the
+  // results are equal.
+  // Set up a TestMessageSet with two known messages and an unknown one, as
+  // above.
+
+  unittest::TestMessageSet message_set;
+  message_set.MutableExtension(
+    unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
+  message_set.MutableExtension(
+    unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
+  message_set.mutable_unknown_fields()->AddLengthDelimited(
+    kUnknownTypeId, "bar");
+
+  int size = message_set.ByteSize();
+  string flat_data;
+  string stream_data;
+  flat_data.resize(size);
+  stream_data.resize(size);
+  // Serialize to flat array
+  {
+    uint8* target = reinterpret_cast<uint8*>(string_as_array(&flat_data));
+    uint8* end = message_set.SerializeWithCachedSizesToArray(target);
+    EXPECT_EQ(size, end - target);
+  }
+
+  // Serialize to buffer
+  {
+    io::ArrayOutputStream array_stream(string_as_array(&stream_data), size, 1);
+    io::CodedOutputStream output_stream(&array_stream);
+    message_set.SerializeWithCachedSizes(&output_stream);
+    ASSERT_FALSE(output_stream.HadError());
+  }
+
+  EXPECT_TRUE(flat_data == stream_data);
+}
+
 TEST(WireFormatTest, ParseMessageSet) {
   // Set up a RawMessageSet with two known messages and an unknown one.
   unittest::RawMessageSet raw;
@@ -360,8 +404,9 @@ TEST(WireFormatTest, ParseMessageSet) {
     unittest::TestMessageSetExtension2::message_set_extension).str());
 
   ASSERT_EQ(1, message_set.unknown_fields().field_count());
-  ASSERT_EQ(1, message_set.unknown_fields().field(0).length_delimited_size());
-  EXPECT_EQ("bar", message_set.unknown_fields().field(0).length_delimited(0));
+  ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED,
+            message_set.unknown_fields().field(0).type());
+  EXPECT_EQ("bar", message_set.unknown_fields().field(0).length_delimited());
 }
 
 TEST(WireFormatTest, RecursionLimit) {
@@ -390,11 +435,11 @@ TEST(WireFormatTest, RecursionLimit) {
 TEST(WireFormatTest, UnknownFieldRecursionLimit) {
   unittest::TestEmptyMessage message;
   message.mutable_unknown_fields()
-        ->AddField(1234)->add_group()
-        ->AddField(1234)->add_group()
-        ->AddField(1234)->add_group()
-        ->AddField(1234)->add_group()
-        ->AddField(1234)->add_varint(123);
+        ->AddGroup(1234)
+        ->AddGroup(1234)
+        ->AddGroup(1234)
+        ->AddGroup(1234)
+        ->AddVarint(1234, 123);
   string data;
   message.SerializeToString(&data);
 
@@ -500,8 +545,7 @@ class WireFormatInvalidInputTest : public testing::Test {
       io::StringOutputStream raw_output(&result);
       io::CodedOutputStream output(&raw_output);
 
-      EXPECT_TRUE(WireFormat::WriteBytes(
-        field->number(), string(bytes, size), &output));
+      WireFormat::WriteBytes(field->number(), string(bytes, size), &output);
     }
 
     return result;
@@ -522,12 +566,11 @@ class WireFormatInvalidInputTest : public testing::Test {
       io::StringOutputStream raw_output(&result);
       io::CodedOutputStream output(&raw_output);
 
-      EXPECT_TRUE(output.WriteVarint32(WireFormat::MakeTag(field)));
-      EXPECT_TRUE(output.WriteString(string(bytes, size)));
+      output.WriteVarint32(WireFormat::MakeTag(field));
+      output.WriteString(string(bytes, size));
       if (include_end_tag) {
-        EXPECT_TRUE(
-          output.WriteVarint32(WireFormat::MakeTag(
-            field->number(), WireFormat::WIRETYPE_END_GROUP)));
+        output.WriteVarint32(WireFormat::MakeTag(
+          field->number(), WireFormat::WIRETYPE_END_GROUP));
       }
     }