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

for details.

1 files changed, 133 insertions, 228 deletions

diff --git a/src/google/protobuf/unknown_field_set_unittest.cc b/src/google/protobuf/unknown_field_set_unittest.cc
index 0a75af9f..1235c9ee 100644
--- a/src/google/protobuf/unknown_field_set_unittest.cc
+++ b/src/google/protobuf/unknown_field_set_unittest.cc
@@ -37,8 +37,8 @@
 
 #include <google/protobuf/unknown_field_set.h>
 #include <google/protobuf/descriptor.h>
-#include <google/protobuf/io/zero_copy_stream_impl.h>
 #include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
 #include <google/protobuf/wire_format.h>
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/test_util.h>
@@ -46,6 +46,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 {
@@ -67,7 +68,12 @@ class UnknownFieldSetTest : public testing::Test {
   const UnknownField* GetField(const string& name) {
     const FieldDescriptor* field = descriptor_->FindFieldByName(name);
     if (field == NULL) return NULL;
-    return unknown_fields_->FindFieldByNumber(field->number());
+    for (int i = 0; i < unknown_fields_->field_count(); i++) {
+      if (unknown_fields_->field(i).number() == field->number()) {
+        return &unknown_fields_->field(i);
+      }
+    }
+    return NULL;
   }
 
   // Constructs a protocol buffer which contains fields with all the same
@@ -79,12 +85,10 @@ class UnknownFieldSetTest : public testing::Test {
       bizarro_message.mutable_unknown_fields();
     for (int i = 0; i < unknown_fields_->field_count(); i++) {
       const UnknownField& unknown_field = unknown_fields_->field(i);
-      UnknownField* bizarro_field =
-        bizarro_unknown_fields->AddField(unknown_field.number());
-      if (unknown_field.varint_size() == 0) {
-        bizarro_field->add_varint(1);
+      if (unknown_field.type() == UnknownField::TYPE_VARINT) {
+        bizarro_unknown_fields->AddFixed32(unknown_field.number(), 1);
       } else {
-        bizarro_field->add_fixed32(1);
+        bizarro_unknown_fields->AddVarint(unknown_field.number(), 1);
       }
     }
 
@@ -103,71 +107,98 @@ class UnknownFieldSetTest : public testing::Test {
   UnknownFieldSet* unknown_fields_;
 };
 
-TEST_F(UnknownFieldSetTest, Index) {
-  for (int i = 0; i < unknown_fields_->field_count(); i++) {
-    EXPECT_EQ(i, unknown_fields_->field(i).index());
-  }
-}
+TEST_F(UnknownFieldSetTest, AllFieldsPresent) {
+  // All fields of TestAllTypes should be present, in numeric order (because
+  // that's the order we parsed them in).  Fields that are not valid field
+  // numbers of TestAllTypes should NOT be present.
 
-TEST_F(UnknownFieldSetTest, FindFieldByNumber) {
-  // All fields of TestAllTypes should be present.  Fields that are not valid
-  // field numbers of TestAllTypes should NOT be present.
+  int pos = 0;
 
   for (int i = 0; i < 1000; i++) {
-    if (descriptor_->FindFieldByNumber(i) == NULL) {
-      EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) == NULL);
-    } else {
-      EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) != NULL);
+    const FieldDescriptor* field = descriptor_->FindFieldByNumber(i);
+    if (field != NULL) {
+      ASSERT_LT(pos, unknown_fields_->field_count());
+      EXPECT_EQ(i, unknown_fields_->field(pos++).number());
+      if (field->is_repeated()) {
+        // Should have a second instance.
+        ASSERT_LT(pos, unknown_fields_->field_count());
+        EXPECT_EQ(i, unknown_fields_->field(pos++).number());
+      }
     }
   }
+  EXPECT_EQ(unknown_fields_->field_count(), pos);
 }
 
 TEST_F(UnknownFieldSetTest, Varint) {
   const UnknownField* field = GetField("optional_int32");
   ASSERT_TRUE(field != NULL);
 
-  ASSERT_EQ(1, field->varint_size());
-  EXPECT_EQ(all_fields_.optional_int32(), field->varint(0));
+  ASSERT_EQ(UnknownField::TYPE_VARINT, field->type());
+  EXPECT_EQ(all_fields_.optional_int32(), field->varint());
 }
 
 TEST_F(UnknownFieldSetTest, Fixed32) {
   const UnknownField* field = GetField("optional_fixed32");
   ASSERT_TRUE(field != NULL);
 
-  ASSERT_EQ(1, field->fixed32_size());
-  EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32(0));
+  ASSERT_EQ(UnknownField::TYPE_FIXED32, field->type());
+  EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32());
 }
 
 TEST_F(UnknownFieldSetTest, Fixed64) {
   const UnknownField* field = GetField("optional_fixed64");
   ASSERT_TRUE(field != NULL);
 
-  ASSERT_EQ(1, field->fixed64_size());
-  EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64(0));
+  ASSERT_EQ(UnknownField::TYPE_FIXED64, field->type());
+  EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64());
 }
 
 TEST_F(UnknownFieldSetTest, LengthDelimited) {
   const UnknownField* field = GetField("optional_string");
   ASSERT_TRUE(field != NULL);
 
-  ASSERT_EQ(1, field->length_delimited_size());
-  EXPECT_EQ(all_fields_.optional_string(), field->length_delimited(0));
+  ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED, field->type());
+  EXPECT_EQ(all_fields_.optional_string(), field->length_delimited());
 }
 
 TEST_F(UnknownFieldSetTest, Group) {
   const UnknownField* field = GetField("optionalgroup");
   ASSERT_TRUE(field != NULL);
 
-  ASSERT_EQ(1, field->group_size());
-  EXPECT_EQ(1, field->group(0).field_count());
+  ASSERT_EQ(UnknownField::TYPE_GROUP, field->type());
+  ASSERT_EQ(1, field->group().field_count());
 
-  const UnknownField& nested_field = field->group(0).field(0);
+  const UnknownField& nested_field = field->group().field(0);
   const FieldDescriptor* nested_field_descriptor =
     unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
   ASSERT_TRUE(nested_field_descriptor != NULL);
 
   EXPECT_EQ(nested_field_descriptor->number(), nested_field.number());
-  EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint(0));
+  ASSERT_EQ(UnknownField::TYPE_VARINT, nested_field.type());
+  EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint());
+}
+
+TEST_F(UnknownFieldSetTest, SerializeFastAndSlowAreEquivalent) {
+  int size = WireFormat::ComputeUnknownFieldsSize(
+      empty_message_.unknown_fields());
+  string slow_buffer;
+  string fast_buffer;
+  slow_buffer.resize(size);
+  fast_buffer.resize(size);
+
+  uint8* target = reinterpret_cast<uint8*>(string_as_array(&fast_buffer));
+  uint8* result = WireFormat::SerializeUnknownFieldsToArray(
+          empty_message_.unknown_fields(), target);
+  EXPECT_EQ(size, result - target);
+
+  {
+    io::ArrayOutputStream raw_stream(string_as_array(&slow_buffer), size, 1);
+    io::CodedOutputStream output_stream(&raw_stream);
+    WireFormat::SerializeUnknownFields(empty_message_.unknown_fields(),
+                                       &output_stream);
+    ASSERT_FALSE(output_stream.HadError());
+  }
+  EXPECT_TRUE(fast_buffer == slow_buffer);
 }
 
 TEST_F(UnknownFieldSetTest, Serialize) {
@@ -205,8 +236,8 @@ TEST_F(UnknownFieldSetTest, SerializeViaReflection) {
     io::StringOutputStream raw_output(&data);
     io::CodedOutputStream output(&raw_output);
     int size = WireFormat::ByteSize(empty_message_);
-    ASSERT_TRUE(
-      WireFormat::SerializeWithCachedSizes(empty_message_, size, &output));
+    WireFormat::SerializeWithCachedSizes(empty_message_, size, &output);
+    ASSERT_FALSE(output.HadError());
   }
 
   // Don't use EXPECT_EQ because we don't want to dump raw binary data to
@@ -249,10 +280,10 @@ TEST_F(UnknownFieldSetTest, SwapWithSelf) {
 TEST_F(UnknownFieldSetTest, MergeFrom) {
   unittest::TestEmptyMessage source, destination;
 
-  destination.mutable_unknown_fields()->AddField(1)->add_varint(1);
-  destination.mutable_unknown_fields()->AddField(3)->add_varint(2);
-  source.mutable_unknown_fields()->AddField(2)->add_varint(3);
-  source.mutable_unknown_fields()->AddField(3)->add_varint(4);
+  destination.mutable_unknown_fields()->AddVarint(1, 1);
+  destination.mutable_unknown_fields()->AddVarint(3, 2);
+  source.mutable_unknown_fields()->AddVarint(2, 3);
+  source.mutable_unknown_fields()->AddVarint(3, 4);
 
   destination.MergeFrom(source);
 
@@ -261,34 +292,22 @@ TEST_F(UnknownFieldSetTest, MergeFrom) {
     //   and merging, above.
     "1: 1\n"
     "3: 2\n"
-    "3: 4\n"
-    "2: 3\n",
+    "2: 3\n"
+    "3: 4\n",
     destination.DebugString());
 }
 
 TEST_F(UnknownFieldSetTest, Clear) {
-  // Get a pointer to a contained field object.
-  const UnknownField* field = GetField("optional_int32");
-  ASSERT_TRUE(field != NULL);
-  ASSERT_EQ(1, field->varint_size());
-  int number = field->number();
-
   // Clear the set.
   empty_message_.Clear();
   EXPECT_EQ(0, unknown_fields_->field_count());
-
-  // If we add that field again we should get the same object.
-  ASSERT_EQ(field, unknown_fields_->AddField(number));
-
-  // But it should be cleared.
-  EXPECT_EQ(0, field->varint_size());
 }
 
 TEST_F(UnknownFieldSetTest, ParseKnownAndUnknown) {
   // Test mixing known and unknown fields when parsing.
 
   unittest::TestEmptyMessage source;
-  source.mutable_unknown_fields()->AddField(123456)->add_varint(654321);
+  source.mutable_unknown_fields()->AddVarint(123456, 654321);
   string data;
   ASSERT_TRUE(source.SerializeToString(&data));
 
@@ -297,8 +316,9 @@ TEST_F(UnknownFieldSetTest, ParseKnownAndUnknown) {
 
   TestUtil::ExpectAllFieldsSet(destination);
   ASSERT_EQ(1, destination.unknown_fields().field_count());
-  ASSERT_EQ(1, destination.unknown_fields().field(0).varint_size());
-  EXPECT_EQ(654321, destination.unknown_fields().field(0).varint(0));
+  ASSERT_EQ(UnknownField::TYPE_VARINT,
+            destination.unknown_fields().field(0).type());
+  EXPECT_EQ(654321, destination.unknown_fields().field(0).varint());
 }
 
 TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknown) {
@@ -384,16 +404,12 @@ TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
   {
     TestEmptyMessage empty_message;
     UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
-    UnknownField* singular_unknown_field =
-      unknown_fields->AddField(singular_field->number());
-    singular_unknown_field->add_varint(TestAllTypes::BAR);
-    singular_unknown_field->add_varint(5);  // not valid
-    UnknownField* repeated_unknown_field =
-      unknown_fields->AddField(repeated_field->number());
-    repeated_unknown_field->add_varint(TestAllTypes::FOO);
-    repeated_unknown_field->add_varint(4);  // not valid
-    repeated_unknown_field->add_varint(TestAllTypes::BAZ);
-    repeated_unknown_field->add_varint(6);  // not valid
+    unknown_fields->AddVarint(singular_field->number(), TestAllTypes::BAR);
+    unknown_fields->AddVarint(singular_field->number(), 5);  // not valid
+    unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::FOO);
+    unknown_fields->AddVarint(repeated_field->number(), 4);  // not valid
+    unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::BAZ);
+    unknown_fields->AddVarint(repeated_field->number(), 6);  // not valid
     empty_message.SerializeToString(&data);
   }
 
@@ -406,18 +422,19 @@ TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
     EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(1));
 
     const UnknownFieldSet& unknown_fields = message.unknown_fields();
-    ASSERT_EQ(2, unknown_fields.field_count());
-
-    const UnknownField& singular_unknown_field = unknown_fields.field(0);
-    ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
-    ASSERT_EQ(1, singular_unknown_field.varint_size());
-    EXPECT_EQ(5, singular_unknown_field.varint(0));
-
-    const UnknownField& repeated_unknown_field = unknown_fields.field(1);
-    ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
-    ASSERT_EQ(2, repeated_unknown_field.varint_size());
-    EXPECT_EQ(4, repeated_unknown_field.varint(0));
-    EXPECT_EQ(6, repeated_unknown_field.varint(1));
+    ASSERT_EQ(3, unknown_fields.field_count());
+
+    EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
+    EXPECT_EQ(5, unknown_fields.field(0).varint());
+
+    EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
+    EXPECT_EQ(4, unknown_fields.field(1).varint());
+
+    EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
+    EXPECT_EQ(6, unknown_fields.field(2).varint());
   }
 
   {
@@ -435,173 +452,61 @@ TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
               message.GetExtension(repeated_nested_enum_extension, 1));
 
     const UnknownFieldSet& unknown_fields = message.unknown_fields();
-    ASSERT_EQ(2, unknown_fields.field_count());
-
-    const UnknownField& singular_unknown_field = unknown_fields.field(0);
-    ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
-    ASSERT_EQ(1, singular_unknown_field.varint_size());
-    EXPECT_EQ(5, singular_unknown_field.varint(0));
-
-    const UnknownField& repeated_unknown_field = unknown_fields.field(1);
-    ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
-    ASSERT_EQ(2, repeated_unknown_field.varint_size());
-    EXPECT_EQ(4, repeated_unknown_field.varint(0));
-    EXPECT_EQ(6, repeated_unknown_field.varint(1));
-  }
-}
+    ASSERT_EQ(3, unknown_fields.field_count());
 
-TEST_F(UnknownFieldSetTest, SpaceUsedExcludingSelf) {
-  {
-    // Make sure an unknown field set has zero space used until a field is
-    // actually added.
-    unittest::TestEmptyMessage empty_message;
-    const int empty_message_size = empty_message.SpaceUsed();
-    UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
-    EXPECT_EQ(empty_message_size, empty_message.SpaceUsed());
-    unknown_fields->AddField(1)->add_varint(0);
-    EXPECT_LT(empty_message_size, empty_message.SpaceUsed());
-  }
-  {
-    // Test varints.
-    UnknownFieldSet unknown_fields;
-    UnknownField* field = unknown_fields.AddField(1);
-    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
-    for (int i = 0; i < 16; ++i) {
-      field->add_varint(i);
-    }
-    // Should just defer computation to the RepeatedField.
-    int expected_size = base_size + field->varint().SpaceUsedExcludingSelf();
-    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
-  }
-  {
-    // Test fixed32s.
-    UnknownFieldSet unknown_fields;
-    UnknownField* field = unknown_fields.AddField(1);
-    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
-    for (int i = 0; i < 16; ++i) {
-      field->add_fixed32(i);
-    }
-    int expected_size = base_size + field->fixed32().SpaceUsedExcludingSelf();
-    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
-  }
-  {
-    // Test fixed64s.
-    UnknownFieldSet unknown_fields;
-    UnknownField* field = unknown_fields.AddField(1);
-    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
-    for (int i = 0; i < 16; ++i) {
-      field->add_fixed64(i);
-    }
-    int expected_size = base_size + field->fixed64().SpaceUsedExcludingSelf();
-    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
-  }
-  {
-    // Test length-delimited types.
-    UnknownFieldSet unknown_fields;
-    UnknownField* field = unknown_fields.AddField(1);
-    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
-    for (int i = 0; i < 16; ++i) {
-      field->add_length_delimited()->assign("my length delimited string");
-    }
-    int expected_size = base_size +
-        field->length_delimited().SpaceUsedExcludingSelf();
-    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
+    EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
+    EXPECT_EQ(5, unknown_fields.field(0).varint());
+
+    EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
+    EXPECT_EQ(4, unknown_fields.field(1).varint());
+
+    EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
+    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
+    EXPECT_EQ(6, unknown_fields.field(2).varint());
   }
 }
 
 TEST_F(UnknownFieldSetTest, SpaceUsed) {
-  UnknownFieldSet unknown_fields;
-  const int expected_size = sizeof(unknown_fields) +
-      unknown_fields.SpaceUsedExcludingSelf();
-  EXPECT_EQ(expected_size, unknown_fields.SpaceUsed());
+  unittest::TestEmptyMessage empty_message;
+
+  // Make sure an unknown field set has zero space used until a field is
+  // actually added.
+  int base_size = empty_message.SpaceUsed();
+  UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
+  EXPECT_EQ(base_size, empty_message.SpaceUsed());
+
+  // Make sure each thing we add to the set increases the SpaceUsed().
+  unknown_fields->AddVarint(1, 0);
+  EXPECT_LT(base_size, empty_message.SpaceUsed());
+  base_size = empty_message.SpaceUsed();
+
+  string* str = unknown_fields->AddLengthDelimited(1);
+  EXPECT_LT(base_size, empty_message.SpaceUsed());
+  base_size = empty_message.SpaceUsed();
+
+  str->assign(sizeof(string) + 1, 'x');
+  EXPECT_LT(base_size, empty_message.SpaceUsed());
+  base_size = empty_message.SpaceUsed();
+
+  UnknownFieldSet* group = unknown_fields->AddGroup(1);
+  EXPECT_LT(base_size, empty_message.SpaceUsed());
+  base_size = empty_message.SpaceUsed();
+
+  group->AddVarint(1, 0);
+  EXPECT_LT(base_size, empty_message.SpaceUsed());
 }
 
 TEST_F(UnknownFieldSetTest, Empty) {
   UnknownFieldSet unknown_fields;
   EXPECT_TRUE(unknown_fields.empty());
-  unknown_fields.AddField(6)->add_varint(123);
+  unknown_fields.AddVarint(6, 123);
   EXPECT_FALSE(unknown_fields.empty());
   unknown_fields.Clear();
   EXPECT_TRUE(unknown_fields.empty());
 }
 
-TEST_F(UnknownFieldSetTest, FieldEmpty) {
-  UnknownFieldSet unknown_fields;
-  UnknownField* field = unknown_fields.AddField(1);
-
-  EXPECT_TRUE(field->empty());
-
-  field->add_varint(1);
-  EXPECT_FALSE(field->empty());
-  field->Clear();
-  EXPECT_TRUE(field->empty());
-
-  field->add_fixed32(1);
-  EXPECT_FALSE(field->empty());
-  field->Clear();
-  EXPECT_TRUE(field->empty());
-
-  field->add_fixed64(1);
-  EXPECT_FALSE(field->empty());
-  field->Clear();
-  EXPECT_TRUE(field->empty());
-
-  field->add_length_delimited("foo");
-  EXPECT_FALSE(field->empty());
-  field->Clear();
-  EXPECT_TRUE(field->empty());
-
-  field->add_group();
-  EXPECT_FALSE(field->empty());
-  field->Clear();
-  EXPECT_TRUE(field->empty());
-}
-
-TEST_F(UnknownFieldSetTest, Iterator) {
-  UnknownFieldSet unknown_fields;
-  EXPECT_TRUE(unknown_fields.begin() == unknown_fields.end());
-
-  // Populate the UnknownFieldSet with some inactive fields by adding some
-  // fields and then clearing.
-  unknown_fields.AddField(6);
-  unknown_fields.AddField(4);
-  unknown_fields.Clear();
-
-  // Add a bunch of "active" fields.
-  UnknownField* a = unknown_fields.AddField(5);
-  unknown_fields.AddField(3);
-  unknown_fields.AddField(9);
-  unknown_fields.AddField(1);
-  UnknownField* b = unknown_fields.AddField(2);
-
-  // Only make some of them non-empty.
-  a->add_varint(1);
-  b->add_length_delimited("foo");
-
-  // Iterate!
-  {
-    UnknownFieldSet::iterator iter = unknown_fields.begin();
-    ASSERT_TRUE(iter != unknown_fields.end());
-    EXPECT_EQ(b, &*iter);
-    ++iter;
-    ASSERT_TRUE(iter != unknown_fields.end());
-    EXPECT_EQ(a, &*iter);
-    ++iter;
-    EXPECT_TRUE(iter == unknown_fields.end());
-  }
-
-  {
-    UnknownFieldSet::const_iterator iter = unknown_fields.begin();
-    ASSERT_TRUE(iter != unknown_fields.end());
-    EXPECT_EQ(b, &*iter);
-    ++iter;
-    ASSERT_TRUE(iter != unknown_fields.end());
-    EXPECT_EQ(a, &*iter);
-    ++iter;
-    EXPECT_TRUE(iter == unknown_fields.end());
-  }
-}
-
 }  // namespace
 }  // namespace protobuf
 }  // namespace google