third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/repeated_field_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 77 matching lines @@
   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);
   // Additional bytes are for 'struct Rep' header.
   int expected_usage = 4 * sizeof(int) + sizeof(Arena*);
-  EXPECT_EQ(field.SpaceUsedExcludingSelf(), expected_usage);
+  EXPECT_GE(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);
@@ skipping 91 matching lines @@
 
   return field->size() - 1;
 }
 
 TEST(RepeatedField, ReserveMoreThanDouble) {
   // Reserve more than double the previous space in the field and expect the
   // field to reserve exactly the amount specified.
   RepeatedField<int> field;
   field.Reserve(20);
 
-  EXPECT_EQ(20, ReservedSpace(&field));
+  EXPECT_LE(20, ReservedSpace(&field));
 }
 
 TEST(RepeatedField, ReserveLessThanDouble) {
   // Reserve less than double the previous space in the field and expect the
   // field to grow by double instead.
   RepeatedField<int> field;
   field.Reserve(20);
-  field.Reserve(30);
+  int capacity = field.Capacity();
+  field.Reserve(capacity * 1.5);
 
-  EXPECT_EQ(40, ReservedSpace(&field));
+  EXPECT_LE(2 * capacity, ReservedSpace(&field));
 }
 
 TEST(RepeatedField, ReserveLessThanExisting) {
   // Reserve less than the previous space in the field and expect the
   // 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));
+  EXPECT_LE(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());
@@ skipping 17 matching lines @@
 
   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
+#ifndef NDEBUG
 TEST(RepeatedField, MergeFromSelf) {
   RepeatedField<int> me;
   me.Add(3);
   EXPECT_DEATH(me.MergeFrom(me), "");
 }
+#endif  // NDEBUG
 #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);
 
@@ skipping 51 matching lines @@
   source.Add(2);
 
   RepeatedField<int> destination(source);
 
   ASSERT_EQ(2, destination.size());
   EXPECT_EQ(1, destination.Get(0));
   EXPECT_EQ(2, destination.Get(1));
 }
 
 TEST(RepeatedField, IteratorConstruct) {
-  vector<int> values;
+  std::vector<int> values;
   values.push_back(1);
   values.push_back(2);
 
   RepeatedField<int> field(values.begin(), values.end());
   ASSERT_EQ(values.size(), field.size());
   EXPECT_EQ(values[0], field.Get(0));
   EXPECT_EQ(values[1], field.Get(1));
 
   RepeatedField<int> other(field.begin(), field.end());
   ASSERT_EQ(values.size(), other.size());
@@ skipping 33 matching lines @@
 TEST(RepeatedField, MutableDataIsMutable) {
   RepeatedField<int> field;
   field.Add(1);
   EXPECT_EQ(1, field.Get(0));
   // The fact that this line compiles would be enough, but we'll check the
   // value anyway.
   *field.mutable_data() = 2;
   EXPECT_EQ(2, field.Get(0));
 }
 
+TEST(RepeatedField, SubscriptOperators) {
+  RepeatedField<int> field;
+  field.Add(1);
+  EXPECT_EQ(1, field.Get(0));
+  EXPECT_EQ(1, field[0]);
+  EXPECT_EQ(field.Mutable(0), &field[0]);
+  const RepeatedField<int>& const_field = field;
+  EXPECT_EQ(field.data(), &const_field[0]);
+}
+
 TEST(RepeatedField, Truncate) {
   RepeatedField<int> field;
 
   field.Add(12);
   field.Add(34);
   field.Add(56);
   field.Add(78);
   EXPECT_EQ(4, field.size());
 
   field.Truncate(3);
@@ skipping 53 matching lines @@
   // 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());
+  EXPECT_LE(32, field.Capacity());
 
   field.Reserve(1024);
   EXPECT_EQ(0, field.size());
-  EXPECT_EQ(1024, field.Capacity());
+  EXPECT_LE(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;
@@ skipping 134 matching lines @@
     field->Add();
   } while (field->data() == ptr);
 
   return field->size() - 1;
 }
 
 TEST(RepeatedPtrField, ReserveMoreThanDouble) {
   RepeatedPtrField<string> field;
   field.Reserve(20);
 
-  EXPECT_EQ(20, ReservedSpace(&field));
+  EXPECT_LE(20, ReservedSpace(&field));
 }
 
 TEST(RepeatedPtrField, ReserveLessThanDouble) {
   RepeatedPtrField<string> field;
   field.Reserve(20);
-  field.Reserve(30);
 
-  EXPECT_EQ(40, ReservedSpace(&field));
+  int capacity = field.Capacity();
+  // Grow by 1.5x
+  field.Reserve(capacity + (capacity >> 2));
+
+  EXPECT_LE(2 * capacity, ReservedSpace(&field));
 }
 
 TEST(RepeatedPtrField, ReserveLessThanExisting) {
   RepeatedPtrField<string> field;
   field.Reserve(20);
   const string* const* previous_ptr = field.data();
   field.Reserve(10);
 
   EXPECT_EQ(previous_ptr, field.data());
-  EXPECT_EQ(20, ReservedSpace(&field));
+  EXPECT_LE(20, ReservedSpace(&field));
 }
 
 TEST(RepeatedPtrField, ReserveDoesntLoseAllocated) {
   // Check that a bug is fixed:  An earlier implementation of Reserve()
   // failed to copy pointers to allocated-but-cleared objects, possibly
   // leading to segfaults.
   RepeatedPtrField<string> field;
   string* first = field.Add();
   field.RemoveLast();
 
@@ skipping 176 matching lines @@
   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));
 }
 
 TEST(RepeatedPtrField, IteratorConstruct_String) {
-  vector<string> values;
+  std::vector<string> values;
   values.push_back("1");
   values.push_back("2");
 
   RepeatedPtrField<string> field(values.begin(), values.end());
   ASSERT_EQ(values.size(), field.size());
   EXPECT_EQ(values[0], field.Get(0));
   EXPECT_EQ(values[1], field.Get(1));
 
   RepeatedPtrField<string> other(field.begin(), field.end());
   ASSERT_EQ(values.size(), other.size());
   EXPECT_EQ(values[0], other.Get(0));
   EXPECT_EQ(values[1], other.Get(1));
 }
 
 TEST(RepeatedPtrField, IteratorConstruct_Proto) {
   typedef TestAllTypes::NestedMessage Nested;
-  vector<Nested> values;
+  std::vector<Nested> values;
   values.push_back(Nested());
   values.back().set_bb(1);
   values.push_back(Nested());
   values.back().set_bb(2);
 
   RepeatedPtrField<Nested> field(values.begin(), values.end());
   ASSERT_EQ(values.size(), field.size());
   EXPECT_EQ(values[0].bb(), field.Get(0).bb());
   EXPECT_EQ(values[1].bb(), field.Get(1).bb());
 
@@ skipping 36 matching lines @@
   RepeatedPtrField<string> field;
   *field.Add() = "1";
   EXPECT_EQ("1", field.Get(0));
   // The fact that this line compiles would be enough, but we'll check the
   // value anyway.
   string** data = field.mutable_data();
   **data = "2";
   EXPECT_EQ("2", field.Get(0));
 }
 
+TEST(RepeatedPtrField, SubscriptOperators) {
+  RepeatedPtrField<string> field;
+  *field.Add() = "1";
+  EXPECT_EQ("1", field.Get(0));
+  EXPECT_EQ("1", field[0]);
+  EXPECT_EQ(field.Mutable(0), &field[0]);
+  const RepeatedPtrField<string>& const_field = field;
+  EXPECT_EQ(*field.data(), &const_field[0]);
+}
+
 TEST(RepeatedPtrField, ExtractSubrange) {
   // Exhaustively test every subrange in arrays of all sizes from 0 through 9
   // with 0 through 3 cleared elements at the end.
   for (int sz = 0; sz < 10; ++sz) {
     for (int num = 0; num <= sz; ++num) {
       for (int start = 0; start < sz - num; ++start) {
         for (int extra = 0; extra < 4; ++extra) {
-          vector<string*> subject;
+          std::vector<string*> subject;
 
           // Create an array with "sz" elements and "extra" cleared elements.
           RepeatedPtrField<string> field;
           for (int i = 0; i < sz + extra; ++i) {
             subject.push_back(new string());
             field.AddAllocated(subject[i]);
           }
           EXPECT_EQ(field.size(), sz + extra);
           for (int i = 0; i < extra; ++i)
             field.RemoveLast();
@@ skipping 541 matching lines @@
 TEST_F(RepeatedFieldInsertionIteratorsTest, Nesteds) {
   ASSERT_EQ(protobuffer.repeated_nested_message_size(), 4);
   EXPECT_EQ(protobuffer.repeated_nested_message(0).bb(), 17);
   EXPECT_EQ(protobuffer.repeated_nested_message(1).bb(), 4711);
   EXPECT_EQ(protobuffer.repeated_nested_message(2).bb(), 170);
   EXPECT_EQ(protobuffer.repeated_nested_message(3).bb(), 47110);
 }
 
 TEST_F(RepeatedFieldInsertionIteratorsTest,
        AllocatedRepeatedPtrFieldWithStringIntData) {
-  vector<Nested*> data;
+  std::vector<Nested*> data;
   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;
   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;
+  std::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;
   std::copy(data.begin(), data.end(), AllocatedRepeatedPtrFieldBackInserter(
                                           testproto.mutable_repeated_string()));
   EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
 }
 
 TEST_F(RepeatedFieldInsertionIteratorsTest,
        UnsafeArenaAllocatedRepeatedPtrFieldWithStringIntData) {
-  vector<Nested*> data;
+  std::vector<Nested*> data;
   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;
   std::copy(data.begin(), data.end(),
             UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
                 testproto.mutable_repeated_nested_message()));
   EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
 }
 
 TEST_F(RepeatedFieldInsertionIteratorsTest,
        UnsafeArenaAllocatedRepeatedPtrFieldWithString) {
-  vector<string*> data;
+  std::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;
   std::copy(data.begin(), data.end(),
             UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
                 testproto.mutable_repeated_string()));
   EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString());
 }
 
 }  // namespace
 
 }  // namespace protobuf
 }  // namespace google