OLD | NEW |
1 // Protocol Buffers - Google's data interchange format | 1 // Protocol Buffers - Google's data interchange format |
2 // Copyright 2008 Google Inc. All rights reserved. | 2 // Copyright 2008 Google Inc. All rights reserved. |
3 // https://developers.google.com/protocol-buffers/ | 3 // https://developers.google.com/protocol-buffers/ |
4 // | 4 // |
5 // Redistribution and use in source and binary forms, with or without | 5 // Redistribution and use in source and binary forms, with or without |
6 // modification, are permitted provided that the following conditions are | 6 // modification, are permitted provided that the following conditions are |
7 // met: | 7 // met: |
8 // | 8 // |
9 // * Redistributions of source code must retain the above copyright | 9 // * Redistributions of source code must retain the above copyright |
10 // notice, this list of conditions and the following disclaimer. | 10 // notice, this list of conditions and the following disclaimer. |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
88 EXPECT_FALSE(field.empty()); | 88 EXPECT_FALSE(field.empty()); |
89 EXPECT_EQ(field.size(), 1); | 89 EXPECT_EQ(field.size(), 1); |
90 EXPECT_EQ(field.Get(0), 5); | 90 EXPECT_EQ(field.Get(0), 5); |
91 | 91 |
92 field.Clear(); | 92 field.Clear(); |
93 | 93 |
94 EXPECT_TRUE(field.empty()); | 94 EXPECT_TRUE(field.empty()); |
95 EXPECT_EQ(field.size(), 0); | 95 EXPECT_EQ(field.size(), 0); |
96 // Additional bytes are for 'struct Rep' header. | 96 // Additional bytes are for 'struct Rep' header. |
97 int expected_usage = 4 * sizeof(int) + sizeof(Arena*); | 97 int expected_usage = 4 * sizeof(int) + sizeof(Arena*); |
98 EXPECT_EQ(field.SpaceUsedExcludingSelf(), expected_usage); | 98 EXPECT_GE(field.SpaceUsedExcludingSelf(), expected_usage); |
99 } | 99 } |
100 | 100 |
101 | 101 |
102 // Test operations on a RepeatedField which is large enough to allocate a | 102 // Test operations on a RepeatedField which is large enough to allocate a |
103 // separate array. | 103 // separate array. |
104 TEST(RepeatedField, Large) { | 104 TEST(RepeatedField, Large) { |
105 RepeatedField<int> field; | 105 RepeatedField<int> field; |
106 | 106 |
107 for (int i = 0; i < 16; i++) { | 107 for (int i = 0; i < 16; i++) { |
108 field.Add(i * i); | 108 field.Add(i * i); |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
200 | 200 |
201 return field->size() - 1; | 201 return field->size() - 1; |
202 } | 202 } |
203 | 203 |
204 TEST(RepeatedField, ReserveMoreThanDouble) { | 204 TEST(RepeatedField, ReserveMoreThanDouble) { |
205 // Reserve more than double the previous space in the field and expect the | 205 // Reserve more than double the previous space in the field and expect the |
206 // field to reserve exactly the amount specified. | 206 // field to reserve exactly the amount specified. |
207 RepeatedField<int> field; | 207 RepeatedField<int> field; |
208 field.Reserve(20); | 208 field.Reserve(20); |
209 | 209 |
210 EXPECT_EQ(20, ReservedSpace(&field)); | 210 EXPECT_LE(20, ReservedSpace(&field)); |
211 } | 211 } |
212 | 212 |
213 TEST(RepeatedField, ReserveLessThanDouble) { | 213 TEST(RepeatedField, ReserveLessThanDouble) { |
214 // Reserve less than double the previous space in the field and expect the | 214 // Reserve less than double the previous space in the field and expect the |
215 // field to grow by double instead. | 215 // field to grow by double instead. |
216 RepeatedField<int> field; | 216 RepeatedField<int> field; |
217 field.Reserve(20); | 217 field.Reserve(20); |
218 field.Reserve(30); | 218 int capacity = field.Capacity(); |
| 219 field.Reserve(capacity * 1.5); |
219 | 220 |
220 EXPECT_EQ(40, ReservedSpace(&field)); | 221 EXPECT_LE(2 * capacity, ReservedSpace(&field)); |
221 } | 222 } |
222 | 223 |
223 TEST(RepeatedField, ReserveLessThanExisting) { | 224 TEST(RepeatedField, ReserveLessThanExisting) { |
224 // Reserve less than the previous space in the field and expect the | 225 // Reserve less than the previous space in the field and expect the |
225 // field to not re-allocate at all. | 226 // field to not re-allocate at all. |
226 RepeatedField<int> field; | 227 RepeatedField<int> field; |
227 field.Reserve(20); | 228 field.Reserve(20); |
228 const int* previous_ptr = field.data(); | 229 const int* previous_ptr = field.data(); |
229 field.Reserve(10); | 230 field.Reserve(10); |
230 | 231 |
231 EXPECT_EQ(previous_ptr, field.data()); | 232 EXPECT_EQ(previous_ptr, field.data()); |
232 EXPECT_EQ(20, ReservedSpace(&field)); | 233 EXPECT_LE(20, ReservedSpace(&field)); |
233 } | 234 } |
234 | 235 |
235 TEST(RepeatedField, Resize) { | 236 TEST(RepeatedField, Resize) { |
236 RepeatedField<int> field; | 237 RepeatedField<int> field; |
237 field.Resize(2, 1); | 238 field.Resize(2, 1); |
238 EXPECT_EQ(2, field.size()); | 239 EXPECT_EQ(2, field.size()); |
239 field.Resize(5, 2); | 240 field.Resize(5, 2); |
240 EXPECT_EQ(5, field.size()); | 241 EXPECT_EQ(5, field.size()); |
241 field.Resize(4, 3); | 242 field.Resize(4, 3); |
242 ASSERT_EQ(4, field.size()); | 243 ASSERT_EQ(4, field.size()); |
(...skipping 17 matching lines...) Expand all Loading... |
260 | 261 |
261 ASSERT_EQ(5, destination.size()); | 262 ASSERT_EQ(5, destination.size()); |
262 EXPECT_EQ(1, destination.Get(0)); | 263 EXPECT_EQ(1, destination.Get(0)); |
263 EXPECT_EQ(2, destination.Get(1)); | 264 EXPECT_EQ(2, destination.Get(1)); |
264 EXPECT_EQ(3, destination.Get(2)); | 265 EXPECT_EQ(3, destination.Get(2)); |
265 EXPECT_EQ(4, destination.Get(3)); | 266 EXPECT_EQ(4, destination.Get(3)); |
266 EXPECT_EQ(5, destination.Get(4)); | 267 EXPECT_EQ(5, destination.Get(4)); |
267 } | 268 } |
268 | 269 |
269 #ifdef PROTOBUF_HAS_DEATH_TEST | 270 #ifdef PROTOBUF_HAS_DEATH_TEST |
| 271 #ifndef NDEBUG |
270 TEST(RepeatedField, MergeFromSelf) { | 272 TEST(RepeatedField, MergeFromSelf) { |
271 RepeatedField<int> me; | 273 RepeatedField<int> me; |
272 me.Add(3); | 274 me.Add(3); |
273 EXPECT_DEATH(me.MergeFrom(me), ""); | 275 EXPECT_DEATH(me.MergeFrom(me), ""); |
274 } | 276 } |
| 277 #endif // NDEBUG |
275 #endif // PROTOBUF_HAS_DEATH_TEST | 278 #endif // PROTOBUF_HAS_DEATH_TEST |
276 | 279 |
277 TEST(RepeatedField, CopyFrom) { | 280 TEST(RepeatedField, CopyFrom) { |
278 RepeatedField<int> source, destination; | 281 RepeatedField<int> source, destination; |
279 source.Add(4); | 282 source.Add(4); |
280 source.Add(5); | 283 source.Add(5); |
281 destination.Add(1); | 284 destination.Add(1); |
282 destination.Add(2); | 285 destination.Add(2); |
283 destination.Add(3); | 286 destination.Add(3); |
284 | 287 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
336 source.Add(2); | 339 source.Add(2); |
337 | 340 |
338 RepeatedField<int> destination(source); | 341 RepeatedField<int> destination(source); |
339 | 342 |
340 ASSERT_EQ(2, destination.size()); | 343 ASSERT_EQ(2, destination.size()); |
341 EXPECT_EQ(1, destination.Get(0)); | 344 EXPECT_EQ(1, destination.Get(0)); |
342 EXPECT_EQ(2, destination.Get(1)); | 345 EXPECT_EQ(2, destination.Get(1)); |
343 } | 346 } |
344 | 347 |
345 TEST(RepeatedField, IteratorConstruct) { | 348 TEST(RepeatedField, IteratorConstruct) { |
346 vector<int> values; | 349 std::vector<int> values; |
347 values.push_back(1); | 350 values.push_back(1); |
348 values.push_back(2); | 351 values.push_back(2); |
349 | 352 |
350 RepeatedField<int> field(values.begin(), values.end()); | 353 RepeatedField<int> field(values.begin(), values.end()); |
351 ASSERT_EQ(values.size(), field.size()); | 354 ASSERT_EQ(values.size(), field.size()); |
352 EXPECT_EQ(values[0], field.Get(0)); | 355 EXPECT_EQ(values[0], field.Get(0)); |
353 EXPECT_EQ(values[1], field.Get(1)); | 356 EXPECT_EQ(values[1], field.Get(1)); |
354 | 357 |
355 RepeatedField<int> other(field.begin(), field.end()); | 358 RepeatedField<int> other(field.begin(), field.end()); |
356 ASSERT_EQ(values.size(), other.size()); | 359 ASSERT_EQ(values.size(), other.size()); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
390 TEST(RepeatedField, MutableDataIsMutable) { | 393 TEST(RepeatedField, MutableDataIsMutable) { |
391 RepeatedField<int> field; | 394 RepeatedField<int> field; |
392 field.Add(1); | 395 field.Add(1); |
393 EXPECT_EQ(1, field.Get(0)); | 396 EXPECT_EQ(1, field.Get(0)); |
394 // The fact that this line compiles would be enough, but we'll check the | 397 // The fact that this line compiles would be enough, but we'll check the |
395 // value anyway. | 398 // value anyway. |
396 *field.mutable_data() = 2; | 399 *field.mutable_data() = 2; |
397 EXPECT_EQ(2, field.Get(0)); | 400 EXPECT_EQ(2, field.Get(0)); |
398 } | 401 } |
399 | 402 |
| 403 TEST(RepeatedField, SubscriptOperators) { |
| 404 RepeatedField<int> field; |
| 405 field.Add(1); |
| 406 EXPECT_EQ(1, field.Get(0)); |
| 407 EXPECT_EQ(1, field[0]); |
| 408 EXPECT_EQ(field.Mutable(0), &field[0]); |
| 409 const RepeatedField<int>& const_field = field; |
| 410 EXPECT_EQ(field.data(), &const_field[0]); |
| 411 } |
| 412 |
400 TEST(RepeatedField, Truncate) { | 413 TEST(RepeatedField, Truncate) { |
401 RepeatedField<int> field; | 414 RepeatedField<int> field; |
402 | 415 |
403 field.Add(12); | 416 field.Add(12); |
404 field.Add(34); | 417 field.Add(34); |
405 field.Add(56); | 418 field.Add(56); |
406 field.Add(78); | 419 field.Add(78); |
407 EXPECT_EQ(4, field.size()); | 420 EXPECT_EQ(4, field.size()); |
408 | 421 |
409 field.Truncate(3); | 422 field.Truncate(3); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
463 // present. Use a 'string' and > 16 bytes length so that the elements are | 476 // present. Use a 'string' and > 16 bytes length so that the elements are |
464 // non-POD and allocate -- the leak checker will catch any skipped destructor | 477 // non-POD and allocate -- the leak checker will catch any skipped destructor |
465 // calls here. | 478 // calls here. |
466 RepeatedField<string> field; | 479 RepeatedField<string> field; |
467 for (int i = 0; i < 32; i++) { | 480 for (int i = 0; i < 32; i++) { |
468 field.Add(string("abcdefghijklmnopqrstuvwxyz0123456789")); | 481 field.Add(string("abcdefghijklmnopqrstuvwxyz0123456789")); |
469 } | 482 } |
470 EXPECT_EQ(32, field.size()); | 483 EXPECT_EQ(32, field.size()); |
471 field.Clear(); | 484 field.Clear(); |
472 EXPECT_EQ(0, field.size()); | 485 EXPECT_EQ(0, field.size()); |
473 EXPECT_EQ(32, field.Capacity()); | 486 EXPECT_LE(32, field.Capacity()); |
474 | 487 |
475 field.Reserve(1024); | 488 field.Reserve(1024); |
476 EXPECT_EQ(0, field.size()); | 489 EXPECT_EQ(0, field.size()); |
477 EXPECT_EQ(1024, field.Capacity()); | 490 EXPECT_LE(1024, field.Capacity()); |
478 // Finish test -- |field| should destroy the cleared-but-not-yet-destroyed | 491 // Finish test -- |field| should destroy the cleared-but-not-yet-destroyed |
479 // strings. | 492 // strings. |
480 } | 493 } |
481 | 494 |
482 // =================================================================== | 495 // =================================================================== |
483 // RepeatedPtrField tests. These pretty much just mirror the RepeatedField | 496 // RepeatedPtrField tests. These pretty much just mirror the RepeatedField |
484 // tests above. | 497 // tests above. |
485 | 498 |
486 TEST(RepeatedPtrField, Small) { | 499 TEST(RepeatedPtrField, Small) { |
487 RepeatedPtrField<string> field; | 500 RepeatedPtrField<string> field; |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
622 field->Add(); | 635 field->Add(); |
623 } while (field->data() == ptr); | 636 } while (field->data() == ptr); |
624 | 637 |
625 return field->size() - 1; | 638 return field->size() - 1; |
626 } | 639 } |
627 | 640 |
628 TEST(RepeatedPtrField, ReserveMoreThanDouble) { | 641 TEST(RepeatedPtrField, ReserveMoreThanDouble) { |
629 RepeatedPtrField<string> field; | 642 RepeatedPtrField<string> field; |
630 field.Reserve(20); | 643 field.Reserve(20); |
631 | 644 |
632 EXPECT_EQ(20, ReservedSpace(&field)); | 645 EXPECT_LE(20, ReservedSpace(&field)); |
633 } | 646 } |
634 | 647 |
635 TEST(RepeatedPtrField, ReserveLessThanDouble) { | 648 TEST(RepeatedPtrField, ReserveLessThanDouble) { |
636 RepeatedPtrField<string> field; | 649 RepeatedPtrField<string> field; |
637 field.Reserve(20); | 650 field.Reserve(20); |
638 field.Reserve(30); | |
639 | 651 |
640 EXPECT_EQ(40, ReservedSpace(&field)); | 652 int capacity = field.Capacity(); |
| 653 // Grow by 1.5x |
| 654 field.Reserve(capacity + (capacity >> 2)); |
| 655 |
| 656 EXPECT_LE(2 * capacity, ReservedSpace(&field)); |
641 } | 657 } |
642 | 658 |
643 TEST(RepeatedPtrField, ReserveLessThanExisting) { | 659 TEST(RepeatedPtrField, ReserveLessThanExisting) { |
644 RepeatedPtrField<string> field; | 660 RepeatedPtrField<string> field; |
645 field.Reserve(20); | 661 field.Reserve(20); |
646 const string* const* previous_ptr = field.data(); | 662 const string* const* previous_ptr = field.data(); |
647 field.Reserve(10); | 663 field.Reserve(10); |
648 | 664 |
649 EXPECT_EQ(previous_ptr, field.data()); | 665 EXPECT_EQ(previous_ptr, field.data()); |
650 EXPECT_EQ(20, ReservedSpace(&field)); | 666 EXPECT_LE(20, ReservedSpace(&field)); |
651 } | 667 } |
652 | 668 |
653 TEST(RepeatedPtrField, ReserveDoesntLoseAllocated) { | 669 TEST(RepeatedPtrField, ReserveDoesntLoseAllocated) { |
654 // Check that a bug is fixed: An earlier implementation of Reserve() | 670 // Check that a bug is fixed: An earlier implementation of Reserve() |
655 // failed to copy pointers to allocated-but-cleared objects, possibly | 671 // failed to copy pointers to allocated-but-cleared objects, possibly |
656 // leading to segfaults. | 672 // leading to segfaults. |
657 RepeatedPtrField<string> field; | 673 RepeatedPtrField<string> field; |
658 string* first = field.Add(); | 674 string* first = field.Add(); |
659 field.RemoveLast(); | 675 field.RemoveLast(); |
660 | 676 |
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
837 source.Add()->assign("2"); | 853 source.Add()->assign("2"); |
838 | 854 |
839 RepeatedPtrField<string> destination(source); | 855 RepeatedPtrField<string> destination(source); |
840 | 856 |
841 ASSERT_EQ(2, destination.size()); | 857 ASSERT_EQ(2, destination.size()); |
842 EXPECT_EQ("1", destination.Get(0)); | 858 EXPECT_EQ("1", destination.Get(0)); |
843 EXPECT_EQ("2", destination.Get(1)); | 859 EXPECT_EQ("2", destination.Get(1)); |
844 } | 860 } |
845 | 861 |
846 TEST(RepeatedPtrField, IteratorConstruct_String) { | 862 TEST(RepeatedPtrField, IteratorConstruct_String) { |
847 vector<string> values; | 863 std::vector<string> values; |
848 values.push_back("1"); | 864 values.push_back("1"); |
849 values.push_back("2"); | 865 values.push_back("2"); |
850 | 866 |
851 RepeatedPtrField<string> field(values.begin(), values.end()); | 867 RepeatedPtrField<string> field(values.begin(), values.end()); |
852 ASSERT_EQ(values.size(), field.size()); | 868 ASSERT_EQ(values.size(), field.size()); |
853 EXPECT_EQ(values[0], field.Get(0)); | 869 EXPECT_EQ(values[0], field.Get(0)); |
854 EXPECT_EQ(values[1], field.Get(1)); | 870 EXPECT_EQ(values[1], field.Get(1)); |
855 | 871 |
856 RepeatedPtrField<string> other(field.begin(), field.end()); | 872 RepeatedPtrField<string> other(field.begin(), field.end()); |
857 ASSERT_EQ(values.size(), other.size()); | 873 ASSERT_EQ(values.size(), other.size()); |
858 EXPECT_EQ(values[0], other.Get(0)); | 874 EXPECT_EQ(values[0], other.Get(0)); |
859 EXPECT_EQ(values[1], other.Get(1)); | 875 EXPECT_EQ(values[1], other.Get(1)); |
860 } | 876 } |
861 | 877 |
862 TEST(RepeatedPtrField, IteratorConstruct_Proto) { | 878 TEST(RepeatedPtrField, IteratorConstruct_Proto) { |
863 typedef TestAllTypes::NestedMessage Nested; | 879 typedef TestAllTypes::NestedMessage Nested; |
864 vector<Nested> values; | 880 std::vector<Nested> values; |
865 values.push_back(Nested()); | 881 values.push_back(Nested()); |
866 values.back().set_bb(1); | 882 values.back().set_bb(1); |
867 values.push_back(Nested()); | 883 values.push_back(Nested()); |
868 values.back().set_bb(2); | 884 values.back().set_bb(2); |
869 | 885 |
870 RepeatedPtrField<Nested> field(values.begin(), values.end()); | 886 RepeatedPtrField<Nested> field(values.begin(), values.end()); |
871 ASSERT_EQ(values.size(), field.size()); | 887 ASSERT_EQ(values.size(), field.size()); |
872 EXPECT_EQ(values[0].bb(), field.Get(0).bb()); | 888 EXPECT_EQ(values[0].bb(), field.Get(0).bb()); |
873 EXPECT_EQ(values[1].bb(), field.Get(1).bb()); | 889 EXPECT_EQ(values[1].bb(), field.Get(1).bb()); |
874 | 890 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
911 RepeatedPtrField<string> field; | 927 RepeatedPtrField<string> field; |
912 *field.Add() = "1"; | 928 *field.Add() = "1"; |
913 EXPECT_EQ("1", field.Get(0)); | 929 EXPECT_EQ("1", field.Get(0)); |
914 // The fact that this line compiles would be enough, but we'll check the | 930 // The fact that this line compiles would be enough, but we'll check the |
915 // value anyway. | 931 // value anyway. |
916 string** data = field.mutable_data(); | 932 string** data = field.mutable_data(); |
917 **data = "2"; | 933 **data = "2"; |
918 EXPECT_EQ("2", field.Get(0)); | 934 EXPECT_EQ("2", field.Get(0)); |
919 } | 935 } |
920 | 936 |
| 937 TEST(RepeatedPtrField, SubscriptOperators) { |
| 938 RepeatedPtrField<string> field; |
| 939 *field.Add() = "1"; |
| 940 EXPECT_EQ("1", field.Get(0)); |
| 941 EXPECT_EQ("1", field[0]); |
| 942 EXPECT_EQ(field.Mutable(0), &field[0]); |
| 943 const RepeatedPtrField<string>& const_field = field; |
| 944 EXPECT_EQ(*field.data(), &const_field[0]); |
| 945 } |
| 946 |
921 TEST(RepeatedPtrField, ExtractSubrange) { | 947 TEST(RepeatedPtrField, ExtractSubrange) { |
922 // Exhaustively test every subrange in arrays of all sizes from 0 through 9 | 948 // Exhaustively test every subrange in arrays of all sizes from 0 through 9 |
923 // with 0 through 3 cleared elements at the end. | 949 // with 0 through 3 cleared elements at the end. |
924 for (int sz = 0; sz < 10; ++sz) { | 950 for (int sz = 0; sz < 10; ++sz) { |
925 for (int num = 0; num <= sz; ++num) { | 951 for (int num = 0; num <= sz; ++num) { |
926 for (int start = 0; start < sz - num; ++start) { | 952 for (int start = 0; start < sz - num; ++start) { |
927 for (int extra = 0; extra < 4; ++extra) { | 953 for (int extra = 0; extra < 4; ++extra) { |
928 vector<string*> subject; | 954 std::vector<string*> subject; |
929 | 955 |
930 // Create an array with "sz" elements and "extra" cleared elements. | 956 // Create an array with "sz" elements and "extra" cleared elements. |
931 RepeatedPtrField<string> field; | 957 RepeatedPtrField<string> field; |
932 for (int i = 0; i < sz + extra; ++i) { | 958 for (int i = 0; i < sz + extra; ++i) { |
933 subject.push_back(new string()); | 959 subject.push_back(new string()); |
934 field.AddAllocated(subject[i]); | 960 field.AddAllocated(subject[i]); |
935 } | 961 } |
936 EXPECT_EQ(field.size(), sz + extra); | 962 EXPECT_EQ(field.size(), sz + extra); |
937 for (int i = 0; i < extra; ++i) | 963 for (int i = 0; i < extra; ++i) |
938 field.RemoveLast(); | 964 field.RemoveLast(); |
(...skipping 541 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1480 TEST_F(RepeatedFieldInsertionIteratorsTest, Nesteds) { | 1506 TEST_F(RepeatedFieldInsertionIteratorsTest, Nesteds) { |
1481 ASSERT_EQ(protobuffer.repeated_nested_message_size(), 4); | 1507 ASSERT_EQ(protobuffer.repeated_nested_message_size(), 4); |
1482 EXPECT_EQ(protobuffer.repeated_nested_message(0).bb(), 17); | 1508 EXPECT_EQ(protobuffer.repeated_nested_message(0).bb(), 17); |
1483 EXPECT_EQ(protobuffer.repeated_nested_message(1).bb(), 4711); | 1509 EXPECT_EQ(protobuffer.repeated_nested_message(1).bb(), 4711); |
1484 EXPECT_EQ(protobuffer.repeated_nested_message(2).bb(), 170); | 1510 EXPECT_EQ(protobuffer.repeated_nested_message(2).bb(), 170); |
1485 EXPECT_EQ(protobuffer.repeated_nested_message(3).bb(), 47110); | 1511 EXPECT_EQ(protobuffer.repeated_nested_message(3).bb(), 47110); |
1486 } | 1512 } |
1487 | 1513 |
1488 TEST_F(RepeatedFieldInsertionIteratorsTest, | 1514 TEST_F(RepeatedFieldInsertionIteratorsTest, |
1489 AllocatedRepeatedPtrFieldWithStringIntData) { | 1515 AllocatedRepeatedPtrFieldWithStringIntData) { |
1490 vector<Nested*> data; | 1516 std::vector<Nested*> data; |
1491 TestAllTypes goldenproto; | 1517 TestAllTypes goldenproto; |
1492 for (int i = 0; i < 10; ++i) { | 1518 for (int i = 0; i < 10; ++i) { |
1493 Nested* new_data = new Nested; | 1519 Nested* new_data = new Nested; |
1494 new_data->set_bb(i); | 1520 new_data->set_bb(i); |
1495 data.push_back(new_data); | 1521 data.push_back(new_data); |
1496 | 1522 |
1497 new_data = goldenproto.add_repeated_nested_message(); | 1523 new_data = goldenproto.add_repeated_nested_message(); |
1498 new_data->set_bb(i); | 1524 new_data->set_bb(i); |
1499 } | 1525 } |
1500 TestAllTypes testproto; | 1526 TestAllTypes testproto; |
1501 std::copy(data.begin(), data.end(), | 1527 std::copy(data.begin(), data.end(), |
1502 AllocatedRepeatedPtrFieldBackInserter( | 1528 AllocatedRepeatedPtrFieldBackInserter( |
1503 testproto.mutable_repeated_nested_message())); | 1529 testproto.mutable_repeated_nested_message())); |
1504 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); | 1530 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); |
1505 } | 1531 } |
1506 | 1532 |
1507 TEST_F(RepeatedFieldInsertionIteratorsTest, | 1533 TEST_F(RepeatedFieldInsertionIteratorsTest, |
1508 AllocatedRepeatedPtrFieldWithString) { | 1534 AllocatedRepeatedPtrFieldWithString) { |
1509 vector<string*> data; | 1535 std::vector<string*> data; |
1510 TestAllTypes goldenproto; | 1536 TestAllTypes goldenproto; |
1511 for (int i = 0; i < 10; ++i) { | 1537 for (int i = 0; i < 10; ++i) { |
1512 string* new_data = new string; | 1538 string* new_data = new string; |
1513 *new_data = "name-" + SimpleItoa(i); | 1539 *new_data = "name-" + SimpleItoa(i); |
1514 data.push_back(new_data); | 1540 data.push_back(new_data); |
1515 | 1541 |
1516 new_data = goldenproto.add_repeated_string(); | 1542 new_data = goldenproto.add_repeated_string(); |
1517 *new_data = "name-" + SimpleItoa(i); | 1543 *new_data = "name-" + SimpleItoa(i); |
1518 } | 1544 } |
1519 TestAllTypes testproto; | 1545 TestAllTypes testproto; |
1520 std::copy(data.begin(), data.end(), AllocatedRepeatedPtrFieldBackInserter( | 1546 std::copy(data.begin(), data.end(), AllocatedRepeatedPtrFieldBackInserter( |
1521 testproto.mutable_repeated_string())); | 1547 testproto.mutable_repeated_string())); |
1522 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); | 1548 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); |
1523 } | 1549 } |
1524 | 1550 |
1525 TEST_F(RepeatedFieldInsertionIteratorsTest, | 1551 TEST_F(RepeatedFieldInsertionIteratorsTest, |
1526 UnsafeArenaAllocatedRepeatedPtrFieldWithStringIntData) { | 1552 UnsafeArenaAllocatedRepeatedPtrFieldWithStringIntData) { |
1527 vector<Nested*> data; | 1553 std::vector<Nested*> data; |
1528 TestAllTypes goldenproto; | 1554 TestAllTypes goldenproto; |
1529 for (int i = 0; i < 10; ++i) { | 1555 for (int i = 0; i < 10; ++i) { |
1530 Nested* new_data = new Nested; | 1556 Nested* new_data = new Nested; |
1531 new_data->set_bb(i); | 1557 new_data->set_bb(i); |
1532 data.push_back(new_data); | 1558 data.push_back(new_data); |
1533 | 1559 |
1534 new_data = goldenproto.add_repeated_nested_message(); | 1560 new_data = goldenproto.add_repeated_nested_message(); |
1535 new_data->set_bb(i); | 1561 new_data->set_bb(i); |
1536 } | 1562 } |
1537 TestAllTypes testproto; | 1563 TestAllTypes testproto; |
1538 std::copy(data.begin(), data.end(), | 1564 std::copy(data.begin(), data.end(), |
1539 UnsafeArenaAllocatedRepeatedPtrFieldBackInserter( | 1565 UnsafeArenaAllocatedRepeatedPtrFieldBackInserter( |
1540 testproto.mutable_repeated_nested_message())); | 1566 testproto.mutable_repeated_nested_message())); |
1541 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); | 1567 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); |
1542 } | 1568 } |
1543 | 1569 |
1544 TEST_F(RepeatedFieldInsertionIteratorsTest, | 1570 TEST_F(RepeatedFieldInsertionIteratorsTest, |
1545 UnsafeArenaAllocatedRepeatedPtrFieldWithString) { | 1571 UnsafeArenaAllocatedRepeatedPtrFieldWithString) { |
1546 vector<string*> data; | 1572 std::vector<string*> data; |
1547 TestAllTypes goldenproto; | 1573 TestAllTypes goldenproto; |
1548 for (int i = 0; i < 10; ++i) { | 1574 for (int i = 0; i < 10; ++i) { |
1549 string* new_data = new string; | 1575 string* new_data = new string; |
1550 *new_data = "name-" + SimpleItoa(i); | 1576 *new_data = "name-" + SimpleItoa(i); |
1551 data.push_back(new_data); | 1577 data.push_back(new_data); |
1552 | 1578 |
1553 new_data = goldenproto.add_repeated_string(); | 1579 new_data = goldenproto.add_repeated_string(); |
1554 *new_data = "name-" + SimpleItoa(i); | 1580 *new_data = "name-" + SimpleItoa(i); |
1555 } | 1581 } |
1556 TestAllTypes testproto; | 1582 TestAllTypes testproto; |
1557 std::copy(data.begin(), data.end(), | 1583 std::copy(data.begin(), data.end(), |
1558 UnsafeArenaAllocatedRepeatedPtrFieldBackInserter( | 1584 UnsafeArenaAllocatedRepeatedPtrFieldBackInserter( |
1559 testproto.mutable_repeated_string())); | 1585 testproto.mutable_repeated_string())); |
1560 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); | 1586 EXPECT_EQ(testproto.DebugString(), goldenproto.DebugString()); |
1561 } | 1587 } |
1562 | 1588 |
1563 } // namespace | 1589 } // namespace |
1564 | 1590 |
1565 } // namespace protobuf | 1591 } // namespace protobuf |
1566 } // namespace google | 1592 } // namespace google |
OLD | NEW |