Update //third_party/protobuf to version 3.

third_party/protobuf/src/google/protobuf/repeated_field_unittest.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// http://code.google.com/p/protobuf/
+// 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.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
@@ skipping 21 matching lines @@
 // TODO(kenton):  Improve this unittest to bring it up to the standards of
 //   other proto2 unittests.
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <vector>
 
 #include <google/protobuf/repeated_field.h>
 
+#include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
 #include <google/protobuf/stubs/stl_util.h>
 
 namespace google {
 using protobuf_unittest::TestAllTypes;
 
 namespace protobuf {
 namespace {
 
 // Test operations on a small RepeatedField.
 TEST(RepeatedField, Small) {
   RepeatedField<int> field;
 
+  EXPECT_TRUE(field.empty());
   EXPECT_EQ(field.size(), 0);
 
   field.Add(5);
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 1);
   EXPECT_EQ(field.Get(0), 5);
 
   field.Add(42);
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 2);
   EXPECT_EQ(field.Get(0), 5);
   EXPECT_EQ(field.Get(1), 42);
 
   field.Set(1, 23);
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 2);
   EXPECT_EQ(field.Get(0), 5);
   EXPECT_EQ(field.Get(1), 23);
 
   field.RemoveLast();
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 1);
   EXPECT_EQ(field.Get(0), 5);
 
   field.Clear();
 
+  EXPECT_TRUE(field.empty());
   EXPECT_EQ(field.size(), 0);
-  int expected_usage = 4 * sizeof(int);
+  // Additional bytes are for 'struct Rep' header.
+  int expected_usage = 4 * sizeof(int) + sizeof(Arena*);
   EXPECT_EQ(field.SpaceUsedExcludingSelf(), expected_usage);
 }
 
 
 // Test operations on a RepeatedField which is large enough to allocate a
 // separate array.
 TEST(RepeatedField, Large) {
   RepeatedField<int> field;
 
   for (int i = 0; i < 16; i++) {
     field.Add(i * i);
   }
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 16);
 
   for (int i = 0; i < 16; i++) {
     EXPECT_EQ(field.Get(i), i * i);
   }
 
   int expected_usage = 16 * sizeof(int);
   EXPECT_GE(field.SpaceUsedExcludingSelf(), expected_usage);
 }
 
 // Test swapping between various types of RepeatedFields.
 TEST(RepeatedField, SwapSmallSmall) {
   RepeatedField<int> field1;
   RepeatedField<int> field2;
 
   field1.Add(5);
   field1.Add(42);
 
+  EXPECT_FALSE(field1.empty());
+  EXPECT_EQ(field1.size(), 2);
+  EXPECT_EQ(field1.Get(0), 5);
+  EXPECT_EQ(field1.Get(1), 42);
+
+  EXPECT_TRUE(field2.empty());
+  EXPECT_EQ(field2.size(), 0);
+
   field1.Swap(&field2);
 
+  EXPECT_TRUE(field1.empty());
   EXPECT_EQ(field1.size(), 0);
+
+  EXPECT_FALSE(field2.empty());
   EXPECT_EQ(field2.size(), 2);
   EXPECT_EQ(field2.Get(0), 5);
   EXPECT_EQ(field2.Get(1), 42);
 }
 
 TEST(RepeatedField, SwapLargeSmall) {
   RepeatedField<int> field1;
   RepeatedField<int> field2;
 
   for (int i = 0; i < 16; i++) {
@@ skipping 71 matching lines @@
   // field to not re-allocate at all.
   RepeatedField<int> field;
   field.Reserve(20);
   const int* previous_ptr = field.data();
   field.Reserve(10);
 
   EXPECT_EQ(previous_ptr, field.data());
   EXPECT_EQ(20, ReservedSpace(&field));
 }
 
+TEST(RepeatedField, Resize) {
+  RepeatedField<int> field;
+  field.Resize(2, 1);
+  EXPECT_EQ(2, field.size());
+  field.Resize(5, 2);
+  EXPECT_EQ(5, field.size());
+  field.Resize(4, 3);
+  ASSERT_EQ(4, field.size());
+  EXPECT_EQ(1, field.Get(0));
+  EXPECT_EQ(1, field.Get(1));
+  EXPECT_EQ(2, field.Get(2));
+  EXPECT_EQ(2, field.Get(3));
+  field.Resize(0, 4);
+  EXPECT_TRUE(field.empty());
+}
+
 TEST(RepeatedField, MergeFrom) {
   RepeatedField<int> source, destination;
   source.Add(4);
   source.Add(5);
   destination.Add(1);
   destination.Add(2);
   destination.Add(3);
 
   destination.MergeFrom(source);
 
   ASSERT_EQ(5, destination.size());
   EXPECT_EQ(1, destination.Get(0));
   EXPECT_EQ(2, destination.Get(1));
   EXPECT_EQ(3, destination.Get(2));
   EXPECT_EQ(4, destination.Get(3));
   EXPECT_EQ(5, destination.Get(4));
 }
 
+#ifdef PROTOBUF_HAS_DEATH_TEST
+TEST(RepeatedField, MergeFromSelf) {
+  RepeatedField<int> me;
+  me.Add(3);
+  EXPECT_DEATH(me.MergeFrom(me), "");
+}
+#endif  // PROTOBUF_HAS_DEATH_TEST
+
 TEST(RepeatedField, CopyFrom) {
   RepeatedField<int> source, destination;
   source.Add(4);
   source.Add(5);
   destination.Add(1);
   destination.Add(2);
   destination.Add(3);
 
   destination.CopyFrom(source);
 
   ASSERT_EQ(2, destination.size());
   EXPECT_EQ(4, destination.Get(0));
   EXPECT_EQ(5, destination.Get(1));
 }
 
+TEST(RepeatedField, CopyFromSelf) {
+  RepeatedField<int> me;
+  me.Add(3);
+  me.CopyFrom(me);
+  ASSERT_EQ(1, me.size());
+  EXPECT_EQ(3, me.Get(0));
+}
+
+TEST(RepeatedField, Erase) {
+  RepeatedField<int> me;
+  RepeatedField<int>::iterator it = me.erase(me.begin(), me.end());
+  EXPECT_TRUE(me.begin() == it);
+  EXPECT_EQ(0, me.size());
+
+  me.Add(1);
+  me.Add(2);
+  me.Add(3);
+  it = me.erase(me.begin(), me.end());
+  EXPECT_TRUE(me.begin() == it);
+  EXPECT_EQ(0, me.size());
+
+  me.Add(4);
+  me.Add(5);
+  me.Add(6);
+  it = me.erase(me.begin() + 2, me.end());
+  EXPECT_TRUE(me.begin() + 2 == it);
+  EXPECT_EQ(2, me.size());
+  EXPECT_EQ(4, me.Get(0));
+  EXPECT_EQ(5, me.Get(1));
+
+  me.Add(6);
+  me.Add(7);
+  me.Add(8);
+  it = me.erase(me.begin() + 1, me.begin() + 3);
+  EXPECT_TRUE(me.begin() + 1 == it);
+  EXPECT_EQ(3, me.size());
+  EXPECT_EQ(4, me.Get(0));
+  EXPECT_EQ(7, me.Get(1));
+  EXPECT_EQ(8, me.Get(2));
+}
+
 TEST(RepeatedField, CopyConstruct) {
   RepeatedField<int> source;
   source.Add(1);
   source.Add(2);
 
   RepeatedField<int> destination(source);
 
   ASSERT_EQ(2, destination.size());
   EXPECT_EQ(1, destination.Get(0));
   EXPECT_EQ(2, destination.Get(1));
@@ skipping 107 matching lines @@
         // Does the resulting array contain the right values?
         for (int i = 0; i < start; ++i)
           EXPECT_EQ(field.Get(i), i);
         for (int i = start; i < field.size(); ++i)
           EXPECT_EQ(field.Get(i), i + num);
       }
     }
   }
 }
 
+TEST(RepeatedField, ClearThenReserveMore) {
+  // Test that Reserve properly destroys the old internal array when it's forced
+  // to allocate a new one, even when cleared-but-not-deleted objects are
+  // present. Use a 'string' and > 16 bytes length so that the elements are
+  // non-POD and allocate -- the leak checker will catch any skipped destructor
+  // calls here.
+  RepeatedField<string> field;
+  for (int i = 0; i < 32; i++) {
+    field.Add(string("abcdefghijklmnopqrstuvwxyz0123456789"));
+  }
+  EXPECT_EQ(32, field.size());
+  field.Clear();
+  EXPECT_EQ(0, field.size());
+  EXPECT_EQ(32, field.Capacity());
+
+  field.Reserve(1024);
+  EXPECT_EQ(0, field.size());
+  EXPECT_EQ(1024, field.Capacity());
+  // Finish test -- |field| should destroy the cleared-but-not-yet-destroyed
+  // strings.
+}
+
 // ===================================================================
 // RepeatedPtrField tests.  These pretty much just mirror the RepeatedField
 // tests above.
 
 TEST(RepeatedPtrField, Small) {
   RepeatedPtrField<string> field;
 
+  EXPECT_TRUE(field.empty());
   EXPECT_EQ(field.size(), 0);
 
   field.Add()->assign("foo");
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 1);
   EXPECT_EQ(field.Get(0), "foo");
 
   field.Add()->assign("bar");
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 2);
   EXPECT_EQ(field.Get(0), "foo");
   EXPECT_EQ(field.Get(1), "bar");
 
   field.Mutable(1)->assign("baz");
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 2);
   EXPECT_EQ(field.Get(0), "foo");
   EXPECT_EQ(field.Get(1), "baz");
 
   field.RemoveLast();
 
+  EXPECT_FALSE(field.empty());
   EXPECT_EQ(field.size(), 1);
   EXPECT_EQ(field.Get(0), "foo");
 
   field.Clear();
 
+  EXPECT_TRUE(field.empty());
   EXPECT_EQ(field.size(), 0);
 }
 
-
 TEST(RepeatedPtrField, Large) {
   RepeatedPtrField<string> field;
 
   for (int i = 0; i < 16; i++) {
     *field.Add() += 'a' + i;
   }
 
   EXPECT_EQ(field.size(), 16);
 
   for (int i = 0; i < 16; i++) {
     EXPECT_EQ(field.Get(i).size(), 1);
     EXPECT_EQ(field.Get(i)[0], 'a' + i);
   }
 
   int min_expected_usage = 16 * sizeof(string);
   EXPECT_GE(field.SpaceUsedExcludingSelf(), min_expected_usage);
 }
 
 TEST(RepeatedPtrField, SwapSmallSmall) {
   RepeatedPtrField<string> field1;
   RepeatedPtrField<string> field2;
 
+  EXPECT_TRUE(field1.empty());
+  EXPECT_EQ(field1.size(), 0);
+  EXPECT_TRUE(field2.empty());
+  EXPECT_EQ(field2.size(), 0);
+
   field1.Add()->assign("foo");
   field1.Add()->assign("bar");
+
+  EXPECT_FALSE(field1.empty());
+  EXPECT_EQ(field1.size(), 2);
+  EXPECT_EQ(field1.Get(0), "foo");
+  EXPECT_EQ(field1.Get(1), "bar");
+
+  EXPECT_TRUE(field2.empty());
+  EXPECT_EQ(field2.size(), 0);
+
   field1.Swap(&field2);
 
+  EXPECT_TRUE(field1.empty());
   EXPECT_EQ(field1.size(), 0);
+
   EXPECT_EQ(field2.size(), 2);
   EXPECT_EQ(field2.Get(0), "foo");
   EXPECT_EQ(field2.Get(1), "bar");
 }
 
 TEST(RepeatedPtrField, SwapLargeSmall) {
   RepeatedPtrField<string> field1;
   RepeatedPtrField<string> field2;
 
   field2.Add()->assign("foo");
@@ skipping 183 matching lines @@
   destination.MergeFrom(source);
 
   ASSERT_EQ(5, destination.size());
   EXPECT_EQ("1", destination.Get(0));
   EXPECT_EQ("2", destination.Get(1));
   EXPECT_EQ("3", destination.Get(2));
   EXPECT_EQ("4", destination.Get(3));
   EXPECT_EQ("5", destination.Get(4));
 }
 
+#ifdef PROTOBUF_HAS_DEATH_TEST
+TEST(RepeatedPtrField, MergeFromSelf) {
+  RepeatedPtrField<string> me;
+  me.Add()->assign("1");
+  EXPECT_DEATH(me.MergeFrom(me), "");
+}
+#endif  // PROTOBUF_HAS_DEATH_TEST
+
 TEST(RepeatedPtrField, CopyFrom) {
   RepeatedPtrField<string> source, destination;
   source.Add()->assign("4");
   source.Add()->assign("5");
   destination.Add()->assign("1");
   destination.Add()->assign("2");
   destination.Add()->assign("3");
 
   destination.CopyFrom(source);
 
   ASSERT_EQ(2, destination.size());
   EXPECT_EQ("4", destination.Get(0));
   EXPECT_EQ("5", destination.Get(1));
 }
 
+TEST(RepeatedPtrField, CopyFromSelf) {
+  RepeatedPtrField<string> me;
+  me.Add()->assign("1");
+  me.CopyFrom(me);
+  ASSERT_EQ(1, me.size());
+  EXPECT_EQ("1", me.Get(0));
+}
+
+TEST(RepeatedPtrField, Erase) {
+  RepeatedPtrField<string> me;
+  RepeatedPtrField<string>::iterator it = me.erase(me.begin(), me.end());
+  EXPECT_TRUE(me.begin() == it);
+  EXPECT_EQ(0, me.size());
+
+  *me.Add() = "1";
+  *me.Add() = "2";
+  *me.Add() = "3";
+  it = me.erase(me.begin(), me.end());
+  EXPECT_TRUE(me.begin() == it);
+  EXPECT_EQ(0, me.size());
+
+  *me.Add() = "4";
+  *me.Add() = "5";
+  *me.Add() = "6";
+  it = me.erase(me.begin() + 2, me.end());
+  EXPECT_TRUE(me.begin() + 2 == it);
+  EXPECT_EQ(2, me.size());
+  EXPECT_EQ("4", me.Get(0));
+  EXPECT_EQ("5", me.Get(1));
+
+  *me.Add() = "6";
+  *me.Add() = "7";
+  *me.Add() = "8";
+  it = me.erase(me.begin() + 1, me.begin() + 3);
+  EXPECT_TRUE(me.begin() + 1 == it);
+  EXPECT_EQ(3, me.size());
+  EXPECT_EQ("4", me.Get(0));
+  EXPECT_EQ("7", me.Get(1));
+  EXPECT_EQ("8", me.Get(2));
+}
+
 TEST(RepeatedPtrField, CopyConstruct) {
   RepeatedPtrField<string> source;
   source.Add()->assign("1");
   source.Add()->assign("2");
 
   RepeatedPtrField<string> destination(source);
 
   ASSERT_EQ(2, destination.size());
   EXPECT_EQ("1", destination.Get(0));
   EXPECT_EQ("2", destination.Get(1));
@@ skipping 303 matching lines @@
   proto_array_.Add()->assign("a");
   proto_array_.Add()->assign("c");
   proto_array_.Add()->assign("d");
   proto_array_.Add()->assign("n");
   proto_array_.Add()->assign("p");
   proto_array_.Add()->assign("x");
   proto_array_.Add()->assign("y");
 
   string v = "f";
   RepeatedPtrField<string>::const_iterator it =
-      lower_bound(proto_array_.begin(), proto_array_.end(), v);
+      std::lower_bound(proto_array_.begin(), proto_array_.end(), v);
 
   EXPECT_EQ(*it, "n");
   EXPECT_TRUE(it == proto_array_.begin() + 3);
 }
 
 TEST_F(RepeatedPtrFieldIteratorTest, Mutation) {
   RepeatedPtrField<string>::iterator iter = proto_array_.begin();
   *iter = "qux";
   EXPECT_EQ("qux", proto_array_.Get(0));
 }
 
 // -------------------------------------------------------------------
 
 class RepeatedPtrFieldPtrsIteratorTest : public testing::Test {
  protected:
   virtual void SetUp() {
     proto_array_.Add()->assign("foo");
     proto_array_.Add()->assign("bar");
     proto_array_.Add()->assign("baz");
     const_proto_array_ = &proto_array_;
   }
 
   RepeatedPtrField<string> proto_array_;
   const RepeatedPtrField<string>* const_proto_array_;
 };
 
 TEST_F(RepeatedPtrFieldPtrsIteratorTest, ConvertiblePtr) {
   RepeatedPtrField<string>::pointer_iterator iter =
       proto_array_.pointer_begin();
-  (void) iter;
+  static_cast<void>(iter);
 }
 
 TEST_F(RepeatedPtrFieldPtrsIteratorTest, ConvertibleConstPtr) {
   RepeatedPtrField<string>::const_pointer_iterator iter =
       const_proto_array_->pointer_begin();
-  (void) iter;
+  static_cast<void>(iter);
 }
 
 TEST_F(RepeatedPtrFieldPtrsIteratorTest, MutablePtrIteration) {
   RepeatedPtrField<string>::pointer_iterator iter =
       proto_array_.pointer_begin();
   EXPECT_EQ("foo", **iter);
   ++iter;
   EXPECT_EQ("bar", **(iter++));
   EXPECT_EQ("baz", **iter);
   ++iter;
@@ skipping 88 matching lines @@
 }
 
 // This comparison functor is required by the tests for RepeatedPtrOverPtrs.
 // They operate on strings and need to compare strings as strings in
 // any stl algorithm, even though the iterator returns a pointer to a string
 // - i.e. *iter has type string*.
 struct StringLessThan {
   bool operator()(const string* z, const string& y) {
     return *z < y;
   }
-  bool operator()(const string* z, const string* y) {
-    return *z < *y;
-  }
+  bool operator()(const string* z, const string* y) const { return *z < *y; }
 };
 
 TEST_F(RepeatedPtrFieldPtrsIteratorTest, PtrSTLAlgorithms_lower_bound) {
   proto_array_.Clear();
   proto_array_.Add()->assign("a");
   proto_array_.Add()->assign("c");
   proto_array_.Add()->assign("d");
   proto_array_.Add()->assign("n");
   proto_array_.Add()->assign("p");
   proto_array_.Add()->assign("x");
   proto_array_.Add()->assign("y");
 
   {
     string v = "f";
     RepeatedPtrField<string>::pointer_iterator it =
-        lower_bound(proto_array_.pointer_begin(), proto_array_.pointer_end(),
-                    &v, StringLessThan());
+        std::lower_bound(proto_array_.pointer_begin(),
+                         proto_array_.pointer_end(), &v, StringLessThan());
 
     GOOGLE_CHECK(*it != NULL);
 
     EXPECT_EQ(**it, "n");
     EXPECT_TRUE(it == proto_array_.pointer_begin() + 3);
   }
   {
     string v = "f";
-    RepeatedPtrField<string>::const_pointer_iterator it =
-        lower_bound(const_proto_array_->pointer_begin(),
-                    const_proto_array_->pointer_end(),
-                    &v, StringLessThan());
+    RepeatedPtrField<string>::const_pointer_iterator it = std::lower_bound(
+        const_proto_array_->pointer_begin(), const_proto_array_->pointer_end(),
+        &v, StringLessThan());
 
     GOOGLE_CHECK(*it != NULL);
 
     EXPECT_EQ(**it, "n");
     EXPECT_TRUE(it == const_proto_array_->pointer_begin() + 3);
   }
 }
 
 TEST_F(RepeatedPtrFieldPtrsIteratorTest, PtrMutation) {
   RepeatedPtrField<string>::pointer_iterator iter =
@@ skipping 17 matching lines @@
   proto_array_.Add()->assign("c");
   proto_array_.Add()->assign("d");
   proto_array_.Add()->assign("n");
   proto_array_.Add()->assign("p");
   proto_array_.Add()->assign("a");
   proto_array_.Add()->assign("y");
   proto_array_.Add()->assign("x");
   EXPECT_EQ("foo", proto_array_.Get(0));
   EXPECT_EQ("n", proto_array_.Get(5));
   EXPECT_EQ("x", proto_array_.Get(9));
-  sort(proto_array_.pointer_begin(),
-       proto_array_.pointer_end(),
-       StringLessThan());
+  std::sort(proto_array_.pointer_begin(), proto_array_.pointer_end(),
+            StringLessThan());
   EXPECT_EQ("a", proto_array_.Get(0));
   EXPECT_EQ("baz", proto_array_.Get(2));
   EXPECT_EQ("y", proto_array_.Get(9));
 }
 
 
 // -----------------------------------------------------------------------------
 // Unit-tests for the insert iterators
 // google::protobuf::RepeatedFieldBackInserter,
 // google::protobuf::AllocatedRepeatedPtrFieldBackInserter
@@ skipping 43 matching lines @@
               RepeatedFieldBackInserter(
                   protobuffer.mutable_repeated_nested_message()));
 
     nested_ptrs.push_back(new Nested);
     nested_ptrs.back()->set_bb(170);
     nested_ptrs.push_back(new Nested);
     nested_ptrs.back()->set_bb(47110);
     std::copy(nested_ptrs.begin(), nested_ptrs.end(),
               RepeatedFieldBackInserter(
                   protobuffer.mutable_repeated_nested_message()));
-
   }
 
   virtual void TearDown() {
     STLDeleteContainerPointers(nested_ptrs.begin(), nested_ptrs.end());
   }
 };
 
 TEST_F(RepeatedFieldInsertionIteratorsTest, Fibonacci) {
   EXPECT_TRUE(std::equal(fibonacci.begin(),
                          fibonacci.end(),
@@ skipping 48 matching lines @@
   TestAllTypes goldenproto;
   for (int i = 0; i < 10; ++i) {
     Nested* new_data = new Nested;
     new_data->set_bb(i);
     data.push_back(new_data);
 
     new_data = goldenproto.add_repeated_nested_message();
     new_data->set_bb(i);
   }
   TestAllTypes testproto;
-  copy(data.begin(), data.end(),
-       AllocatedRepeatedPtrFieldBackInserter(
-           testproto.mutable_repeated_nested_message()));
+  std::copy(data.begin(), data.end(),
+            AllocatedRepeatedPtrFieldBackInserter(
+                testproto.mutable_repeated_nested_message()));
   EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
 }
 
 TEST_F(RepeatedFieldInsertionIteratorsTest,
        AllocatedRepeatedPtrFieldWithString) {
   vector<string*> data;
   TestAllTypes goldenproto;
   for (int i = 0; i < 10; ++i) {
     string* new_data = new string;
     *new_data = "name-" + SimpleItoa(i);
     data.push_back(new_data);
 
     new_data = goldenproto.add_repeated_string();
     *new_data = "name-" + SimpleItoa(i);
   }
   TestAllTypes testproto;
-  copy(data.begin(), data.end(),
-       AllocatedRepeatedPtrFieldBackInserter(
-           testproto.mutable_repeated_string()));
+  std::copy(data.begin(), data.end(), AllocatedRepeatedPtrFieldBackInserter(
+                                          testproto.mutable_repeated_string()));
   EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
 }
 
 }  // namespace
 
 }  // namespace protobuf
 }  // namespace google