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

third_party/protobuf/src/google/protobuf/util/message_differencer_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 48 matching lines @@
 #include <gtest/gtest.h>
 
 namespace google {
 namespace protobuf {
 
 namespace {
 
 
 const FieldDescriptor* GetFieldDescriptor(
     const Message& message, const string& field_name) {
-  std::vector<string> field_path =
+  vector<string> field_path =
       Split(field_name, ".", true);
   const Descriptor* descriptor = message.GetDescriptor();
   const FieldDescriptor* field = NULL;
   for (int i = 0; i < field_path.size(); i++) {
     field = descriptor->FindFieldByName(field_path[i]);
     descriptor = field->message_type();
   }
   return field;
 }
 
@@ skipping 703 matching lines @@
   EXPECT_TRUE(differencer.Compare(empty1, empty2));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsEqualityAllTest) {
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
 
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
-  std::vector<const FieldDescriptor*> fields2;
+  vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields2;
   msg1.GetReflection()->ListFields(msg1, &fields1);
   msg2.GetReflection()->ListFields(msg2, &fields2);
 
   util::MessageDifferencer differencer;
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, fields1, fields2));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsInequalityAllTest) {
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
 
   TestUtil::SetAllFields(&msg1);
 
-  std::vector<const FieldDescriptor*> fields1;
-  std::vector<const FieldDescriptor*> fields2;
+  vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields2;
   msg1.GetReflection()->ListFields(msg1, &fields1);
   msg2.GetReflection()->ListFields(msg2, &fields2);
 
   util::MessageDifferencer differencer;
   EXPECT_FALSE(differencer.CompareWithFields(msg1, msg2, fields1, fields2));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsEmptyListAlwaysSucceeds) {
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
 
   TestUtil::SetAllFields(&msg1);
 
-  std::vector<const FieldDescriptor*> empty_fields;
+  vector<const FieldDescriptor*> empty_fields;
 
   util::MessageDifferencer differencer;
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
                                             empty_fields, empty_fields));
 
   TestUtil::SetAllFields(&msg2);
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
                                             empty_fields, empty_fields));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsCompareWithSelf) {
   unittest::TestAllTypes msg1;
   TestUtil::SetAllFields(&msg1);
 
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   msg1.GetReflection()->ListFields(msg1, &fields);
 
   util::MessageDifferencer differencer;
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg1, fields, fields));
 
   {
     // Compare with a subset of fields.
-    std::vector<const FieldDescriptor*> compare_fields;
+    vector<const FieldDescriptor*> compare_fields;
     for (int i = 0; i < fields.size(); ++i) {
       if (i % 2 == 0) {
         compare_fields.push_back(fields[i]);
       }
     }
     EXPECT_TRUE(differencer.CompareWithFields(msg1, msg1,
                                               compare_fields, compare_fields));
   }
   {
     // Specify a different set of fields to compare, even though we're using the
     // same message. This should fail, since we are explicitly saying that the
     // set of fields are different.
-    std::vector<const FieldDescriptor*> compare_fields1;
-    std::vector<const FieldDescriptor*> compare_fields2;
+    vector<const FieldDescriptor*> compare_fields1;
+    vector<const FieldDescriptor*> compare_fields2;
     for (int i = 0; i < fields.size(); ++i) {
       if (i % 2 == 0) {
         compare_fields1.push_back(fields[i]);
       } else {
         compare_fields2.push_back(fields[i]);
       }
     }
     EXPECT_FALSE(differencer.CompareWithFields(
         msg1, msg1, compare_fields1, compare_fields2));
   }
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsEqualityAllShuffledTest) {
   // This is a public function, so make sure there are no assumptions about the
   // list of fields. Randomly shuffle them to make sure that they are properly
   // ordered for comparison.
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
 
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
-  std::vector<const FieldDescriptor*> fields2;
+  vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields2;
   msg1.GetReflection()->ListFields(msg1, &fields1);
   msg2.GetReflection()->ListFields(msg2, &fields2);
 
   std::random_shuffle(fields1.begin(), fields1.end());
   std::random_shuffle(fields2.begin(), fields2.end());
 
   util::MessageDifferencer differencer;
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, fields1, fields2));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsSubsetEqualityTest) {
   // Specify a set of fields to compare. All the fields are equal.
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields1;
   msg1.GetReflection()->ListFields(msg1, &fields1);
 
-  std::vector<const FieldDescriptor*> compare_fields;
+  vector<const FieldDescriptor*> compare_fields;
   // Only compare the field descriptors with even indices.
   for (int i = 0; i < fields1.size(); ++i) {
     if (i % 2 == 0) {
       compare_fields.push_back(fields1[i]);
     }
   }
 
   util::MessageDifferencer differencer;
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
                                             compare_fields, compare_fields));
 }
 
 TEST(MessageDifferencerTest,
      SpecifiedFieldsSubsetIgnoresOtherFieldDifferencesTest) {
   // Specify a set of fields to compare, but clear all the other fields in one
   // of the messages. This should fail a regular compare, but CompareWithFields
   // should succeed.
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields1;
   const Reflection* reflection = msg1.GetReflection();
   reflection->ListFields(msg1, &fields1);
 
-  std::vector<const FieldDescriptor*> compare_fields;
+  vector<const FieldDescriptor*> compare_fields;
   // Only compare the field descriptors with even indices.
   for (int i = 0; i < fields1.size(); ++i) {
     if (i % 2 == 0) {
       compare_fields.push_back(fields1[i]);
     } else {
       reflection->ClearField(&msg2, fields1[i]);
     }
   }
 
   util::MessageDifferencer differencer;
   EXPECT_FALSE(differencer.Compare(msg1, msg2));
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2,
                                             compare_fields, compare_fields));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsDetectsDifferencesTest) {
   // Change all of the repeated fields in one of the messages, and use only
   // those fields for comparison.
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
   TestUtil::ModifyRepeatedFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields1;
   msg1.GetReflection()->ListFields(msg1, &fields1);
 
-  std::vector<const FieldDescriptor*> compare_fields;
+  vector<const FieldDescriptor*> compare_fields;
   // Only compare the repeated field descriptors.
   for (int i = 0; i < fields1.size(); ++i) {
     if (fields1[i]->is_repeated()) {
       compare_fields.push_back(fields1[i]);
     }
   }
 
   util::MessageDifferencer differencer;
   EXPECT_FALSE(differencer.CompareWithFields(msg1, msg2,
                                              compare_fields, compare_fields));
 }
 
 TEST(MessageDifferencerTest, SpecifiedFieldsEquivalenceAllTest) {
   unittest::TestAllTypes msg1;
   unittest::TestAllTypes msg2;
 
   TestUtil::SetAllFields(&msg1);
   TestUtil::SetAllFields(&msg2);
 
-  std::vector<const FieldDescriptor*> fields1;
-  std::vector<const FieldDescriptor*> fields2;
+  vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields2;
   msg1.GetReflection()->ListFields(msg1, &fields1);
   msg2.GetReflection()->ListFields(msg2, &fields2);
 
   util::MessageDifferencer differencer;
   differencer.set_message_field_comparison(
       util::MessageDifferencer::EQUIVALENT);
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, fields1, fields2));
 }
 
 TEST(MessageDifferencerTest,
@@ skipping 12 matching lines @@
   ASSERT_TRUE(optional_int64_desc != NULL);
   ASSERT_TRUE(default_int64_desc != NULL);
   msg1.set_optional_int32(0);
   msg2.set_optional_int64(0);
   msg1.set_default_int64(default_int64_desc->default_value_int64());
 
   // Set a field to a non-default value so we know that field selection is
   // actually doing something.
   msg2.set_optional_uint64(23);
 
-  std::vector<const FieldDescriptor*> fields1;
-  std::vector<const FieldDescriptor*> fields2;
+  vector<const FieldDescriptor*> fields1;
+  vector<const FieldDescriptor*> fields2;
   fields1.push_back(optional_int32_desc);
   fields1.push_back(default_int64_desc);
 
   fields2.push_back(optional_int64_desc);
 
   util::MessageDifferencer differencer;
   EXPECT_FALSE(differencer.CompareWithFields(msg1, msg2, fields1, fields2));
   differencer.set_message_field_comparison(
       util::MessageDifferencer::EQUIVALENT);
   EXPECT_FALSE(differencer.Compare(msg1, msg2));
@@ skipping 253 matching lines @@
   // key => value: (2, {1, 3}) => "b"
   item->set_a(2);
   item->add_ra(3);
   item->add_ra(1);
   item->set_b("b");
 
   // Compare
   util::MessageDifferencer differencer;
   differencer.TreatAsSet(GetFieldDescriptor(msg1, "item.ra"));
   EXPECT_FALSE(differencer.Compare(msg1, msg2));
-  std::vector<const FieldDescriptor*> key_fields;
+  vector<const FieldDescriptor*> key_fields;
   key_fields.push_back(GetFieldDescriptor(msg1, "item.a"));
   key_fields.push_back(GetFieldDescriptor(msg1, "item.ra"));
   differencer.TreatAsMapWithMultipleFieldsAsKey(
       GetFieldDescriptor(msg1, "item"), key_fields);
   EXPECT_TRUE(differencer.Compare(msg1, msg2));
 
   // Introduce some differences.
   msg1.clear_item();
   msg2.clear_item();
   item = msg1.add_item();
@@ skipping 56 matching lines @@
   // key => value: (2, {1, 3}) => "b"
   item->mutable_m()->set_a(2);
   item->mutable_m()->add_rc(3);
   item->mutable_m()->add_rc(1);
   item->set_b("b");
 
   // Compare
   util::MessageDifferencer differencer;
   differencer.TreatAsSet(GetFieldDescriptor(msg1, "item.m.rc"));
   EXPECT_FALSE(differencer.Compare(msg1, msg2));
-  std::vector<std::vector<const FieldDescriptor*> > key_field_paths;
-  std::vector<const FieldDescriptor*> key_field_path1;
+  vector<vector<const FieldDescriptor*> > key_field_paths;
+  vector<const FieldDescriptor*> key_field_path1;
   key_field_path1.push_back(GetFieldDescriptor(msg1, "item.m"));
   key_field_path1.push_back(GetFieldDescriptor(msg1, "item.m.a"));
-  std::vector<const FieldDescriptor*> key_field_path2;
+  vector<const FieldDescriptor*> key_field_path2;
   key_field_path2.push_back(GetFieldDescriptor(msg1, "item.m"));
   key_field_path2.push_back(GetFieldDescriptor(msg1, "item.m.rc"));
   key_field_paths.push_back(key_field_path1);
   key_field_paths.push_back(key_field_path2);
   differencer.TreatAsMapWithMultipleFieldPathsAsKey(
       GetFieldDescriptor(msg1, "item"), key_field_paths);
   EXPECT_TRUE(differencer.Compare(msg1, msg2));
 
   // Introduce some differences.
   msg1.clear_item();
@@ skipping 25 matching lines @@
   protobuf_unittest::TestDiffMessage::Item* item = msg1.add_item();
   item->set_a(1);
   item->add_ra(2);
   item->set_b("hello");
   item = msg2.add_item();
   item->set_a(1);
   item->add_ra(3);
   item->set_b("world");
   // Compare
   util::MessageDifferencer differencer;
-  std::vector<const FieldDescriptor*> key_fields;
+  vector<const FieldDescriptor*> key_fields;
   key_fields.push_back(GetFieldDescriptor(msg1, "item.a"));
   key_fields.push_back(GetFieldDescriptor(msg1, "item.ra"));
   differencer.TreatAsMapWithMultipleFieldsAsKey(
       GetFieldDescriptor(msg1, "item"), key_fields);
   string output;
   differencer.ReportDifferencesToString(&output);
   EXPECT_FALSE(differencer.Compare(msg1, msg2));
   EXPECT_EQ(
       "added: item[0]: { a: 1 ra: 3 b: \"world\" }\n"
       "deleted: item[0]: { a: 1 ra: 2 b: \"hello\" }\n",
@@ skipping 23 matching lines @@
       output);
 }
 
 static const char* const kIgnoredFields[] = {"rm.b", "rm.m.b"};
 
 class TestIgnorer : public util::MessageDifferencer::IgnoreCriteria {
  public:
   virtual bool IsIgnored(
       const Message& message1, const Message& message2,
       const FieldDescriptor* field,
-      const std::vector<util::MessageDifferencer::SpecificField>&
-          parent_fields) {
+      const vector<util::MessageDifferencer::SpecificField>& parent_fields) {
     string name = "";
     for (int i = 0; i < parent_fields.size(); ++i) {
       name += parent_fields[i].field->name() + ".";
     }
     name += field->name();
     for (int i = 0; i < GOOGLE_ARRAYSIZE(kIgnoredFields); ++i) {
       if (name.compare(kIgnoredFields[i]) == 0) {
         return true;
       }
     }
@@ skipping 24 matching lines @@
   EXPECT_TRUE(differ.Compare(msg1, msg2));
 }
 
 // Takes the product of all elements of item.ra as the key for key comparison.
 class ValueProductMapKeyComparator
     : public util::MessageDifferencer::MapKeyComparator {
  public:
   typedef util::MessageDifferencer::SpecificField SpecificField;
   virtual bool IsMatch(
       const Message &message1, const Message &message2,
-      const std::vector<SpecificField>& parent_fields) const {
+      const vector<SpecificField>& parent_fields) const {
     const Reflection* reflection1 = message1.GetReflection();
     const Reflection* reflection2 = message2.GetReflection();
     // FieldDescriptor for item.ra
     const FieldDescriptor* ra_field =
         message1.GetDescriptor()->FindFieldByName("ra");
     // Get the product of all elements in item.ra
     int result1 = 1, result2 = 1;
     for (int i = 0; i < reflection1->FieldSize(message1, ra_field); ++i) {
       result1 *= reflection1->GetRepeatedInt32(message1, ra_field, i);
     }
@@ skipping 340 matching lines @@
   msg1.add_rc(1);
   msg1.add_rc(2);
 
   msg2.set_c(3);
   msg2.add_rc(1);
   msg2.add_rc(3);
 
   const FieldDescriptor* c = GetFieldDescriptor(msg1, "c");
   const FieldDescriptor* rc = GetFieldDescriptor(msg1, "rc");
 
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   fields.push_back(c);
   fields.push_back(rc);
 
   util::MessageDifferencer differencer;
   differencer.IgnoreField(rc);
 
   differencer.set_scope(util::MessageDifferencer::FULL);
   EXPECT_TRUE(differencer.CompareWithFields(msg1, msg2, fields, fields));
 
   differencer.set_scope(util::MessageDifferencer::PARTIAL);
@@ skipping 15 matching lines @@
       const google::protobuf::util::FieldContext* field_context) {
     if (field_context)
       parent_fields_ = *(field_context->parent_fields());
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       return RECURSE;
     } else {
       return SAME;
     }
   }
 
-  std::vector<google::protobuf::util::MessageDifferencer::SpecificField> parent_fields() {
+  vector<google::protobuf::util::MessageDifferencer::SpecificField> parent_fields() {
     return parent_fields_;
   }
 
  private:
-  std::vector<google::protobuf::util::MessageDifferencer::SpecificField> parent_fields_;
+  vector<google::protobuf::util::MessageDifferencer::SpecificField> parent_fields_;
 };
 
 // Tests if MessageDifferencer sends the parent fields in the FieldContext
 // parameter.
 TEST(MessageDifferencerTest, FieldContextParentFieldsTest) {
   protobuf_unittest::TestDiffMessage msg1;
   msg1.add_rm()->set_c(1);
   protobuf_unittest::TestDiffMessage msg2;
   msg2.add_rm()->set_c(1);
 
@@ skipping 424 matching lines @@
   item = msg2.add_item();
   item->CopyFrom(msg1.item(1));
   item->add_rb("second");
 
   EXPECT_EQ("added: item[0].rb[1]: \"second\"\n"
             "deleted: item[0]: { rm { c: 2 rc: 10 rc: 10 } }\n",
             Run(msg1, msg2));
 }
 
 TEST_F(ComparisonTest, RepeatedSetOptionTest_Unknown) {
-  // Currently, as_set option doesn't have affects on unknown field.
+  // Currently, as_set option doens't have affects on unknown field.
   // If needed, this feature will be added by request.
   repeated_field_as_set();
   unknown1_->AddGroup(245)->AddFixed32(248, 1);
   unknown2_->AddGroup(245)->AddFixed32(248, 3);
   unknown2_->AddGroup(245)->AddFixed32(248, 1);
 
   // We expect it behaves the same as normal comparison.
   EXPECT_EQ("modified: 245[0].248[0]: 0x00000001 -> 0x00000003\n"
             "added: 245[1]: { ... }\n",
             RunUn());
@@ skipping 779 matching lines @@
 
   util::MessageDifferencer message_differencer;
   message_differencer.TreatAsSet(GetFieldDescriptor(m1, "repeated_any_value"));
   EXPECT_TRUE(message_differencer.Compare(m1, m2));
 }
 
 
 }  // namespace
 }  // namespace protobuf
 }  // namespace google