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