1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 // Author: tgs@google.com (Tom Szymanski)
32 //
33 // Test reflection methods for aggregate access to Repeated[Ptr]Fields.
34 // This test proto2 methods on a proto2 layout.
35
36 #include <google/protobuf/stubs/casts.h>
37 #include <google/protobuf/stubs/stringprintf.h>
38 #include <google/protobuf/test_util.h>
39 #include <google/protobuf/unittest.pb.h>
40 #include <google/protobuf/dynamic_message.h>
41 #include <google/protobuf/reflection.h>
42 #include <gtest/gtest.h>
43
44 namespace google {
45 namespace protobuf {
46
47 using unittest::ForeignMessage;
48 using unittest::TestAllExtensions;
49 using unittest::TestAllTypes;
50
51 namespace {
52
Func(int i,int j)53 static int Func(int i, int j) { return i * j; }
54
StrFunc(int i,int j)55 static std::string StrFunc(int i, int j) {
56 std::string str;
57 SStringPrintf(&str, "%d", Func(i, 4));
58 return str;
59 }
60
TEST(RepeatedFieldReflectionTest,RegularFields)61 TEST(RepeatedFieldReflectionTest, RegularFields) {
62 TestAllTypes message;
63 const Reflection* refl = message.GetReflection();
64 const Descriptor* desc = message.GetDescriptor();
65
66 for (int i = 0; i < 10; ++i) {
67 message.add_repeated_int32(Func(i, 1));
68 message.add_repeated_double(Func(i, 2));
69 message.add_repeated_string(StrFunc(i, 5));
70 message.add_repeated_foreign_message()->set_c(Func(i, 6));
71 }
72
73 // Get FieldDescriptors for all the fields of interest.
74 const FieldDescriptor* fd_repeated_int32 =
75 desc->FindFieldByName("repeated_int32");
76 const FieldDescriptor* fd_repeated_double =
77 desc->FindFieldByName("repeated_double");
78 const FieldDescriptor* fd_repeated_string =
79 desc->FindFieldByName("repeated_string");
80 const FieldDescriptor* fd_repeated_foreign_message =
81 desc->FindFieldByName("repeated_foreign_message");
82
83 // Get RepeatedField objects for all fields of interest.
84 const RepeatedField<int32>& rf_int32 =
85 refl->GetRepeatedField<int32>(message, fd_repeated_int32);
86 const RepeatedField<double>& rf_double =
87 refl->GetRepeatedField<double>(message, fd_repeated_double);
88
89 // Get mutable RepeatedField objects for all fields of interest.
90 RepeatedField<int32>* mrf_int32 =
91 refl->MutableRepeatedField<int32>(&message, fd_repeated_int32);
92 RepeatedField<double>* mrf_double =
93 refl->MutableRepeatedField<double>(&message, fd_repeated_double);
94
95 // Get RepeatedPtrField objects for all fields of interest.
96 const RepeatedPtrField<std::string>& rpf_string =
97 refl->GetRepeatedPtrField<std::string>(message, fd_repeated_string);
98 const RepeatedPtrField<ForeignMessage>& rpf_foreign_message =
99 refl->GetRepeatedPtrField<ForeignMessage>(message,
100 fd_repeated_foreign_message);
101 const RepeatedPtrField<Message>& rpf_message =
102 refl->GetRepeatedPtrField<Message>(message, fd_repeated_foreign_message);
103
104 // Get mutable RepeatedPtrField objects for all fields of interest.
105 RepeatedPtrField<std::string>* mrpf_string =
106 refl->MutableRepeatedPtrField<std::string>(&message, fd_repeated_string);
107 RepeatedPtrField<ForeignMessage>* mrpf_foreign_message =
108 refl->MutableRepeatedPtrField<ForeignMessage>(
109 &message, fd_repeated_foreign_message);
110 RepeatedPtrField<Message>* mrpf_message =
111 refl->MutableRepeatedPtrField<Message>(&message,
112 fd_repeated_foreign_message);
113
114 // Make sure we can do gets and sets through the Repeated[Ptr]Field objects.
115 for (int i = 0; i < 10; ++i) {
116 // Check gets through const objects.
117 EXPECT_EQ(rf_int32.Get(i), Func(i, 1));
118 EXPECT_EQ(rf_double.Get(i), Func(i, 2));
119 EXPECT_EQ(rpf_string.Get(i), StrFunc(i, 5));
120 EXPECT_EQ(rpf_foreign_message.Get(i).c(), Func(i, 6));
121 EXPECT_EQ(down_cast<const ForeignMessage*>(&rpf_message.Get(i))->c(),
122 Func(i, 6));
123
124 // Check gets through mutable objects.
125 EXPECT_EQ(mrf_int32->Get(i), Func(i, 1));
126 EXPECT_EQ(mrf_double->Get(i), Func(i, 2));
127 EXPECT_EQ(mrpf_string->Get(i), StrFunc(i, 5));
128 EXPECT_EQ(mrpf_foreign_message->Get(i).c(), Func(i, 6));
129 EXPECT_EQ(down_cast<const ForeignMessage*>(&mrpf_message->Get(i))->c(),
130 Func(i, 6));
131
132 // Check sets through mutable objects.
133 mrf_int32->Set(i, Func(i, -1));
134 mrf_double->Set(i, Func(i, -2));
135 mrpf_string->Mutable(i)->assign(StrFunc(i, -5));
136 mrpf_foreign_message->Mutable(i)->set_c(Func(i, -6));
137 EXPECT_EQ(message.repeated_int32(i), Func(i, -1));
138 EXPECT_EQ(message.repeated_double(i), Func(i, -2));
139 EXPECT_EQ(message.repeated_string(i), StrFunc(i, -5));
140 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, -6));
141 down_cast<ForeignMessage*>(mrpf_message->Mutable(i))->set_c(Func(i, 7));
142 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, 7));
143 }
144
145 #ifdef PROTOBUF_HAS_DEATH_TEST
146 // Make sure types are checked correctly at runtime.
147 const FieldDescriptor* fd_optional_int32 =
148 desc->FindFieldByName("optional_int32");
149 EXPECT_DEATH(refl->GetRepeatedField<int32>(message, fd_optional_int32),
150 "requires a repeated field");
151 EXPECT_DEATH(refl->GetRepeatedField<double>(message, fd_repeated_int32),
152 "not the right type");
153 EXPECT_DEATH(refl->GetRepeatedPtrField<TestAllTypes>(
154 message, fd_repeated_foreign_message),
155 "wrong submessage type");
156 #endif // PROTOBUF_HAS_DEATH_TEST
157 }
158
159
TEST(RepeatedFieldReflectionTest,ExtensionFields)160 TEST(RepeatedFieldReflectionTest, ExtensionFields) {
161 TestAllExtensions extended_message;
162 const Reflection* refl = extended_message.GetReflection();
163 const Descriptor* desc = extended_message.GetDescriptor();
164
165 for (int i = 0; i < 10; ++i) {
166 extended_message.AddExtension(unittest::repeated_int64_extension,
167 Func(i, 1));
168 }
169
170 const FieldDescriptor* fd_repeated_int64_extension =
171 desc->file()->FindExtensionByName("repeated_int64_extension");
172 GOOGLE_CHECK(fd_repeated_int64_extension != NULL);
173
174 const RepeatedField<int64>& rf_int64_extension =
175 refl->GetRepeatedField<int64>(extended_message,
176 fd_repeated_int64_extension);
177
178 RepeatedField<int64>* mrf_int64_extension = refl->MutableRepeatedField<int64>(
179 &extended_message, fd_repeated_int64_extension);
180
181 for (int i = 0; i < 10; ++i) {
182 EXPECT_EQ(Func(i, 1), rf_int64_extension.Get(i));
183 mrf_int64_extension->Set(i, Func(i, -1));
184 EXPECT_EQ(Func(i, -1), extended_message.GetExtension(
185 unittest::repeated_int64_extension, i));
186 }
187 }
188
189 template <typename Ref, typename MessageType, typename ValueType>
TestRepeatedFieldRefIteratorForPrimitive(const Ref & handle,const MessageType & message,ValueType (MessageType::* GetFunc)(int)const)190 void TestRepeatedFieldRefIteratorForPrimitive(
191 const Ref& handle, const MessageType& message,
192 ValueType (MessageType::*GetFunc)(int) const) {
193 int index = 0;
194 for (typename Ref::const_iterator it = handle.begin(); it != handle.end();
195 ++it) {
196 EXPECT_EQ((message.*GetFunc)(index), *it);
197 ++index;
198 }
199 EXPECT_EQ(handle.size(), index);
200 }
201
202 template <typename MessageType, typename ValueType>
TestRepeatedFieldRefIteratorForString(const RepeatedFieldRef<std::string> & handle,const MessageType & message,ValueType (MessageType::* GetFunc)(int)const)203 void TestRepeatedFieldRefIteratorForString(
204 const RepeatedFieldRef<std::string>& handle, const MessageType& message,
205 ValueType (MessageType::*GetFunc)(int) const) {
206 int index = 0;
207 for (typename RepeatedFieldRef<std::string>::const_iterator it =
208 handle.begin();
209 it != handle.end(); ++it) {
210 // Test both operator* and operator->
211 EXPECT_EQ((message.*GetFunc)(index), *it);
212 EXPECT_EQ((message.*GetFunc)(index).size(), it->size());
213 ++index;
214 }
215 EXPECT_EQ(handle.size(), index);
216 }
217
TEST(RepeatedFieldReflectionTest,RepeatedFieldRefForRegularFields)218 TEST(RepeatedFieldReflectionTest, RepeatedFieldRefForRegularFields) {
219 TestAllTypes message;
220 const Reflection* refl = message.GetReflection();
221 const Descriptor* desc = message.GetDescriptor();
222
223 for (int i = 0; i < 10; ++i) {
224 message.add_repeated_int32(Func(i, 1));
225 message.add_repeated_double(Func(i, 2));
226 message.add_repeated_string(StrFunc(i, 5));
227 message.add_repeated_foreign_message()->set_c(Func(i, 6));
228 }
229
230 // Get FieldDescriptors for all the fields of interest.
231 const FieldDescriptor* fd_repeated_int32 =
232 desc->FindFieldByName("repeated_int32");
233 const FieldDescriptor* fd_repeated_double =
234 desc->FindFieldByName("repeated_double");
235 const FieldDescriptor* fd_repeated_string =
236 desc->FindFieldByName("repeated_string");
237 const FieldDescriptor* fd_repeated_foreign_message =
238 desc->FindFieldByName("repeated_foreign_message");
239
240 // Get RepeatedFieldRef objects for all fields of interest.
241 const RepeatedFieldRef<int32> rf_int32 =
242 refl->GetRepeatedFieldRef<int32>(message, fd_repeated_int32);
243 const RepeatedFieldRef<double> rf_double =
244 refl->GetRepeatedFieldRef<double>(message, fd_repeated_double);
245 const RepeatedFieldRef<std::string> rf_string =
246 refl->GetRepeatedFieldRef<std::string>(message, fd_repeated_string);
247 const RepeatedFieldRef<ForeignMessage> rf_foreign_message =
248 refl->GetRepeatedFieldRef<ForeignMessage>(message,
249 fd_repeated_foreign_message);
250 const RepeatedFieldRef<Message> rf_message =
251 refl->GetRepeatedFieldRef<Message>(message, fd_repeated_foreign_message);
252
253 // Get MutableRepeatedFieldRef objects for all fields of interest.
254 const MutableRepeatedFieldRef<int32> mrf_int32 =
255 refl->GetMutableRepeatedFieldRef<int32>(&message, fd_repeated_int32);
256 const MutableRepeatedFieldRef<double> mrf_double =
257 refl->GetMutableRepeatedFieldRef<double>(&message, fd_repeated_double);
258 const MutableRepeatedFieldRef<std::string> mrf_string =
259 refl->GetMutableRepeatedFieldRef<std::string>(&message,
260 fd_repeated_string);
261 const MutableRepeatedFieldRef<ForeignMessage> mrf_foreign_message =
262 refl->GetMutableRepeatedFieldRef<ForeignMessage>(
263 &message, fd_repeated_foreign_message);
264 const MutableRepeatedFieldRef<Message> mrf_message =
265 refl->GetMutableRepeatedFieldRef<Message>(&message,
266 fd_repeated_foreign_message);
267
268 EXPECT_EQ(message.repeated_int32_size(), rf_int32.size());
269 EXPECT_EQ(message.repeated_int32_size(), mrf_int32.size());
270 EXPECT_EQ(message.repeated_double_size(), rf_double.size());
271 EXPECT_EQ(message.repeated_double_size(), mrf_double.size());
272 EXPECT_EQ(message.repeated_string_size(), rf_string.size());
273 EXPECT_EQ(message.repeated_string_size(), mrf_string.size());
274 EXPECT_EQ(message.repeated_foreign_message_size(), rf_foreign_message.size());
275 EXPECT_EQ(message.repeated_foreign_message_size(),
276 mrf_foreign_message.size());
277 EXPECT_EQ(message.repeated_foreign_message_size(), rf_message.size());
278 EXPECT_EQ(message.repeated_foreign_message_size(), mrf_message.size());
279
280 EXPECT_FALSE(rf_int32.empty());
281 EXPECT_FALSE(mrf_int32.empty());
282 EXPECT_FALSE(rf_double.empty());
283 EXPECT_FALSE(mrf_double.empty());
284 EXPECT_FALSE(rf_string.empty());
285 EXPECT_FALSE(mrf_string.empty());
286 EXPECT_FALSE(rf_foreign_message.empty());
287 EXPECT_FALSE(mrf_foreign_message.empty());
288 EXPECT_FALSE(rf_message.empty());
289 EXPECT_FALSE(mrf_message.empty());
290
291 // Make sure we can do gets and sets through the RepeatedFieldRef objects.
292 for (int i = 0; i < 10; ++i) {
293 // Check gets through const objects.
294 EXPECT_EQ(rf_int32.Get(i), Func(i, 1));
295 EXPECT_EQ(rf_double.Get(i), Func(i, 2));
296 EXPECT_EQ(rf_string.Get(i), StrFunc(i, 5));
297 ForeignMessage scratch_space;
298 EXPECT_EQ(rf_foreign_message.Get(i, &scratch_space).c(), Func(i, 6));
299 EXPECT_EQ(
300 down_cast<const ForeignMessage&>(rf_message.Get(i, &scratch_space)).c(),
301 Func(i, 6));
302
303 // Check gets through mutable objects.
304 EXPECT_EQ(mrf_int32.Get(i), Func(i, 1));
305 EXPECT_EQ(mrf_double.Get(i), Func(i, 2));
306 EXPECT_EQ(mrf_string.Get(i), StrFunc(i, 5));
307 EXPECT_EQ(mrf_foreign_message.Get(i, &scratch_space).c(), Func(i, 6));
308 EXPECT_EQ(
309 down_cast<const ForeignMessage&>(mrf_message.Get(i, &scratch_space))
310 .c(),
311 Func(i, 6));
312
313 // Check sets through mutable objects.
314 mrf_int32.Set(i, Func(i, -1));
315 mrf_double.Set(i, Func(i, -2));
316 mrf_string.Set(i, StrFunc(i, -5));
317 ForeignMessage foreign_message;
318 foreign_message.set_c(Func(i, -6));
319 mrf_foreign_message.Set(i, foreign_message);
320 EXPECT_EQ(message.repeated_int32(i), Func(i, -1));
321 EXPECT_EQ(message.repeated_double(i), Func(i, -2));
322 EXPECT_EQ(message.repeated_string(i), StrFunc(i, -5));
323 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, -6));
324 foreign_message.set_c(Func(i, 7));
325 mrf_message.Set(i, foreign_message);
326 EXPECT_EQ(message.repeated_foreign_message(i).c(), Func(i, 7));
327 }
328
329 // Test iterators.
330 TestRepeatedFieldRefIteratorForPrimitive(rf_int32, message,
331 &TestAllTypes::repeated_int32);
332 TestRepeatedFieldRefIteratorForPrimitive(rf_double, message,
333 &TestAllTypes::repeated_double);
334 TestRepeatedFieldRefIteratorForString(rf_string, message,
335 &TestAllTypes::repeated_string);
336
337 // Test iterators for message fields.
338 typedef RepeatedFieldRef<ForeignMessage>::iterator MessageIterator;
339 int index = 0;
340 for (MessageIterator it = rf_foreign_message.begin();
341 it != rf_foreign_message.end(); ++it) {
342 EXPECT_EQ(message.repeated_foreign_message(index).c(), it->c());
343 ++index;
344 }
345 EXPECT_EQ(10, index);
346
347 // Test iterator operators that are not ususally used in regular for-loops.
348 // Including: post increment, assign, ==.
349 MessageIterator old_it = rf_foreign_message.begin();
350 MessageIterator new_it = old_it++;
351 EXPECT_FALSE(old_it == new_it);
352 // Check that old_it++ increments old_it once.
353 for (index = 1; old_it != rf_foreign_message.end(); ++old_it, ++index) {
354 EXPECT_EQ(message.repeated_foreign_message(index).c(), old_it->c());
355 }
356 EXPECT_EQ(10, index);
357 // Test assign operator.
358 old_it = new_it;
359 for (index = 0; old_it != rf_foreign_message.end(); ++old_it, ++index) {
360 EXPECT_EQ(message.repeated_foreign_message(index).c(), old_it->c());
361 }
362 EXPECT_EQ(10, index);
363 // Check that the returned value of old_it++ is the one before increment.
364 for (index = 0; new_it != rf_foreign_message.end(); ++new_it, ++index) {
365 EXPECT_EQ(message.repeated_foreign_message(index).c(), new_it->c());
366 }
367 EXPECT_EQ(10, index);
368
369 // Test MutableRepeatedFieldRef::Add()
370 mrf_int32.Add(1234);
371 mrf_double.Add(1234.0);
372 mrf_string.Add("1234");
373 ForeignMessage foreign_message;
374 foreign_message.set_c(1234);
375 mrf_foreign_message.Add(foreign_message);
376 EXPECT_EQ(1234, message.repeated_int32(10));
377 EXPECT_EQ(1234.0, message.repeated_double(10));
378 EXPECT_EQ("1234", message.repeated_string(10));
379 EXPECT_EQ(1234, message.repeated_foreign_message(10).c());
380
381 // Test MutableRepeatedFieldRef::RemoveLast()
382 mrf_int32.RemoveLast();
383 mrf_double.RemoveLast();
384 mrf_string.RemoveLast();
385 mrf_foreign_message.RemoveLast();
386 EXPECT_EQ(10, message.repeated_int32_size());
387 EXPECT_EQ(10, message.repeated_double_size());
388 EXPECT_EQ(10, message.repeated_string_size());
389 EXPECT_EQ(10, message.repeated_foreign_message_size());
390
391 // Test MutableRepeatedFieldRef::SwapElements()
392 mrf_int32.SwapElements(0, 9);
393 mrf_double.SwapElements(0, 9);
394 mrf_string.SwapElements(0, 9);
395 mrf_foreign_message.SwapElements(0, 9);
396 EXPECT_EQ(Func(9, -1), message.repeated_int32(0));
397 EXPECT_EQ(Func(0, -1), message.repeated_int32(9));
398 EXPECT_EQ(Func(9, -2), message.repeated_double(0));
399 EXPECT_EQ(Func(0, -2), message.repeated_double(9));
400 EXPECT_EQ(StrFunc(9, -5), message.repeated_string(0));
401 EXPECT_EQ(StrFunc(0, -5), message.repeated_string(9));
402 EXPECT_EQ(Func(9, 7), message.repeated_foreign_message(0).c());
403 EXPECT_EQ(Func(0, 7), message.repeated_foreign_message(9).c());
404
405 // Test MutableRepeatedFieldRef::Clear()
406 mrf_int32.Clear();
407 mrf_double.Clear();
408 mrf_string.Clear();
409 mrf_foreign_message.Clear();
410 EXPECT_EQ(0, message.repeated_int32_size());
411 EXPECT_EQ(0, message.repeated_double_size());
412 EXPECT_EQ(0, message.repeated_string_size());
413 EXPECT_EQ(0, message.repeated_foreign_message_size());
414
415 // Test (Mutable)RepeatedFieldRef::empty()
416 EXPECT_TRUE(rf_int32.empty());
417 EXPECT_TRUE(mrf_int32.empty());
418 EXPECT_TRUE(rf_double.empty());
419 EXPECT_TRUE(mrf_double.empty());
420 EXPECT_TRUE(rf_string.empty());
421 EXPECT_TRUE(mrf_string.empty());
422 EXPECT_TRUE(rf_foreign_message.empty());
423 EXPECT_TRUE(mrf_foreign_message.empty());
424 EXPECT_TRUE(rf_message.empty());
425 EXPECT_TRUE(mrf_message.empty());
426
427 #ifdef PROTOBUF_HAS_DEATH_TEST
428
429 // Make sure types are checked correctly at runtime.
430 const FieldDescriptor* fd_optional_int32 =
431 desc->FindFieldByName("optional_int32");
432 EXPECT_DEATH(refl->GetRepeatedFieldRef<int32>(message, fd_optional_int32),
433 "");
434 EXPECT_DEATH(refl->GetRepeatedFieldRef<double>(message, fd_repeated_int32),
435 "");
436 EXPECT_DEATH(refl->GetRepeatedFieldRef<TestAllTypes>(
437 message, fd_repeated_foreign_message),
438 "");
439
440 #endif // PROTOBUF_HAS_DEATH_TEST
441 }
442
TEST(RepeatedFieldReflectionTest,RepeatedFieldRefForEnums)443 TEST(RepeatedFieldReflectionTest, RepeatedFieldRefForEnums) {
444 TestAllTypes message;
445 const Reflection* refl = message.GetReflection();
446 const Descriptor* desc = message.GetDescriptor();
447
448 for (int i = 0; i < 10; ++i) {
449 message.add_repeated_nested_enum(TestAllTypes::BAR);
450 }
451
452 const FieldDescriptor* fd_repeated_nested_enum =
453 desc->FindFieldByName("repeated_nested_enum");
454 const RepeatedFieldRef<TestAllTypes::NestedEnum> enum_ref =
455 refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
456 message, fd_repeated_nested_enum);
457 const MutableRepeatedFieldRef<TestAllTypes::NestedEnum> mutable_enum_ref =
458 refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
459 &message, fd_repeated_nested_enum);
460 const RepeatedFieldRef<int32> int32_ref =
461 refl->GetRepeatedFieldRef<int32>(message, fd_repeated_nested_enum);
462 const MutableRepeatedFieldRef<int32> mutable_int32_ref =
463 refl->GetMutableRepeatedFieldRef<int32>(&message,
464 fd_repeated_nested_enum);
465
466 EXPECT_EQ(message.repeated_nested_enum_size(), enum_ref.size());
467 EXPECT_EQ(message.repeated_nested_enum_size(), mutable_enum_ref.size());
468 EXPECT_EQ(message.repeated_nested_enum_size(), int32_ref.size());
469 EXPECT_EQ(message.repeated_nested_enum_size(), mutable_int32_ref.size());
470
471 EXPECT_FALSE(enum_ref.empty());
472 EXPECT_FALSE(mutable_enum_ref.empty());
473 EXPECT_FALSE(int32_ref.empty());
474 EXPECT_FALSE(mutable_int32_ref.empty());
475
476 for (int i = 0; i < 10; ++i) {
477 EXPECT_EQ(TestAllTypes::BAR, enum_ref.Get(i));
478 EXPECT_EQ(TestAllTypes::BAR, mutable_enum_ref.Get(i));
479 mutable_enum_ref.Set(i, TestAllTypes::BAZ);
480 EXPECT_EQ(TestAllTypes::BAZ, enum_ref.Get(i));
481 EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(i));
482
483 message.set_repeated_nested_enum(i, TestAllTypes::BAR);
484 EXPECT_EQ(TestAllTypes::BAR, int32_ref.Get(i));
485 EXPECT_EQ(TestAllTypes::BAR, mutable_int32_ref.Get(i));
486 mutable_int32_ref.Set(i, TestAllTypes::BAZ);
487 EXPECT_EQ(TestAllTypes::BAZ, int32_ref.Get(i));
488 EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(i));
489 }
490
491 TestRepeatedFieldRefIteratorForPrimitive(enum_ref, message,
492 &TestAllTypes::repeated_nested_enum);
493 TestRepeatedFieldRefIteratorForPrimitive(int32_ref, message,
494 &TestAllTypes::repeated_nested_enum);
495
496 // Test Add()
497 mutable_enum_ref.Add(TestAllTypes::FOO);
498 EXPECT_EQ(TestAllTypes::FOO, message.repeated_nested_enum(10));
499 mutable_int32_ref.Add(TestAllTypes::BAR);
500 EXPECT_EQ(TestAllTypes::BAR, message.repeated_nested_enum(11));
501
502 // Test RemoveLast()
503 mutable_enum_ref.RemoveLast();
504 EXPECT_EQ(11, message.repeated_nested_enum_size());
505 mutable_int32_ref.RemoveLast();
506 EXPECT_EQ(10, message.repeated_nested_enum_size());
507
508 // Test SwapElements()
509 mutable_enum_ref.Set(0, TestAllTypes::BAR);
510 mutable_enum_ref.Set(9, TestAllTypes::BAZ);
511 mutable_enum_ref.SwapElements(0, 9);
512 EXPECT_EQ(TestAllTypes::BAZ, enum_ref.Get(0));
513 EXPECT_EQ(TestAllTypes::BAR, enum_ref.Get(9));
514 mutable_int32_ref.SwapElements(0, 9);
515 EXPECT_EQ(TestAllTypes::BAR, enum_ref.Get(0));
516 EXPECT_EQ(TestAllTypes::BAZ, enum_ref.Get(9));
517
518 // Test Clear()
519 mutable_enum_ref.Clear();
520 EXPECT_EQ(0, message.repeated_nested_enum_size());
521 mutable_enum_ref.Add(TestAllTypes::FOO);
522 EXPECT_EQ(1, message.repeated_nested_enum_size());
523 mutable_int32_ref.Clear();
524 EXPECT_EQ(0, message.repeated_nested_enum_size());
525
526 // Test empty()
527 EXPECT_TRUE(enum_ref.empty());
528 EXPECT_TRUE(mutable_enum_ref.empty());
529 EXPECT_TRUE(int32_ref.empty());
530 EXPECT_TRUE(mutable_int32_ref.empty());
531 }
532
TEST(RepeatedFieldReflectionTest,RepeatedFieldRefForExtensionFields)533 TEST(RepeatedFieldReflectionTest, RepeatedFieldRefForExtensionFields) {
534 TestAllExtensions extended_message;
535 const Reflection* refl = extended_message.GetReflection();
536 const Descriptor* desc = extended_message.GetDescriptor();
537
538 for (int i = 0; i < 10; ++i) {
539 extended_message.AddExtension(unittest::repeated_int64_extension,
540 Func(i, 1));
541 }
542
543 const FieldDescriptor* fd_repeated_int64_extension =
544 desc->file()->FindExtensionByName("repeated_int64_extension");
545 GOOGLE_CHECK(fd_repeated_int64_extension != NULL);
546
547 const RepeatedFieldRef<int64> rf_int64_extension =
548 refl->GetRepeatedFieldRef<int64>(extended_message,
549 fd_repeated_int64_extension);
550
551 const MutableRepeatedFieldRef<int64> mrf_int64_extension =
552 refl->GetMutableRepeatedFieldRef<int64>(&extended_message,
553 fd_repeated_int64_extension);
554
555 for (int i = 0; i < 10; ++i) {
556 EXPECT_EQ(Func(i, 1), rf_int64_extension.Get(i));
557 mrf_int64_extension.Set(i, Func(i, -1));
558 EXPECT_EQ(Func(i, -1), extended_message.GetExtension(
559 unittest::repeated_int64_extension, i));
560 }
561 }
562
563
TEST(RepeatedFieldReflectionTest,RepeatedFieldRefMergeFromAndSwap)564 TEST(RepeatedFieldReflectionTest, RepeatedFieldRefMergeFromAndSwap) {
565 // Set-up message content.
566 TestAllTypes m0, m1, m2;
567 for (int i = 0; i < 10; ++i) {
568 m0.add_repeated_int32(Func(i, 1));
569 m0.add_repeated_double(Func(i, 2));
570 m0.add_repeated_string(StrFunc(i, 5));
571 m0.add_repeated_foreign_message()->set_c(Func(i, 6));
572 m0.add_repeated_nested_enum(TestAllTypes::FOO);
573 m1.add_repeated_int32(Func(i, 11));
574 m1.add_repeated_double(Func(i, 12));
575 m1.add_repeated_string(StrFunc(i, 15));
576 m1.add_repeated_foreign_message()->set_c(Func(i, 16));
577 m1.add_repeated_nested_enum(TestAllTypes::BAR);
578 m2.add_repeated_int32(Func(i, 21));
579 m2.add_repeated_double(Func(i, 22));
580 m2.add_repeated_string(StrFunc(i, 25));
581 m2.add_repeated_foreign_message()->set_c(Func(i, 26));
582 m2.add_repeated_nested_enum(TestAllTypes::BAZ);
583 }
584
585 const Reflection* refl = m0.GetReflection();
586 const Descriptor* desc = m0.GetDescriptor();
587
588 // Get FieldDescriptors for all the fields of interest.
589 const FieldDescriptor* fd_repeated_int32 =
590 desc->FindFieldByName("repeated_int32");
591 const FieldDescriptor* fd_repeated_double =
592 desc->FindFieldByName("repeated_double");
593 const FieldDescriptor* fd_repeated_string =
594 desc->FindFieldByName("repeated_string");
595 const FieldDescriptor* fd_repeated_foreign_message =
596 desc->FindFieldByName("repeated_foreign_message");
597 const FieldDescriptor* fd_repeated_nested_enum =
598 desc->FindFieldByName("repeated_nested_enum");
599
600 // Get MutableRepeatedFieldRef objects for all fields of interest.
601 const MutableRepeatedFieldRef<int32> mrf_int32 =
602 refl->GetMutableRepeatedFieldRef<int32>(&m0, fd_repeated_int32);
603 const MutableRepeatedFieldRef<double> mrf_double =
604 refl->GetMutableRepeatedFieldRef<double>(&m0, fd_repeated_double);
605 const MutableRepeatedFieldRef<std::string> mrf_string =
606 refl->GetMutableRepeatedFieldRef<std::string>(&m0, fd_repeated_string);
607 const MutableRepeatedFieldRef<ForeignMessage> mrf_foreign_message =
608 refl->GetMutableRepeatedFieldRef<ForeignMessage>(
609 &m0, fd_repeated_foreign_message);
610 const MutableRepeatedFieldRef<TestAllTypes::NestedEnum> mrf_nested_enum =
611 refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
612 &m0, fd_repeated_nested_enum);
613
614 // Test MutableRepeatedRef::CopyFrom
615 mrf_int32.CopyFrom(refl->GetRepeatedFieldRef<int32>(m1, fd_repeated_int32));
616 mrf_double.CopyFrom(
617 refl->GetRepeatedFieldRef<double>(m1, fd_repeated_double));
618 mrf_string.CopyFrom(
619 refl->GetRepeatedFieldRef<std::string>(m1, fd_repeated_string));
620 mrf_foreign_message.CopyFrom(refl->GetRepeatedFieldRef<ForeignMessage>(
621 m1, fd_repeated_foreign_message));
622 mrf_nested_enum.CopyFrom(refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
623 m1, fd_repeated_nested_enum));
624 for (int i = 0; i < 10; ++i) {
625 EXPECT_EQ(Func(i, 11), m0.repeated_int32(i));
626 EXPECT_EQ(Func(i, 12), m0.repeated_double(i));
627 EXPECT_EQ(StrFunc(i, 15), m0.repeated_string(i));
628 EXPECT_EQ(Func(i, 16), m0.repeated_foreign_message(i).c());
629 EXPECT_EQ(TestAllTypes::BAR, m0.repeated_nested_enum(i));
630 }
631
632 // Test MutableRepeatedRef::MergeFrom
633 mrf_int32.MergeFrom(refl->GetRepeatedFieldRef<int32>(m2, fd_repeated_int32));
634 mrf_double.MergeFrom(
635 refl->GetRepeatedFieldRef<double>(m2, fd_repeated_double));
636 mrf_string.MergeFrom(
637 refl->GetRepeatedFieldRef<std::string>(m2, fd_repeated_string));
638 mrf_foreign_message.MergeFrom(refl->GetRepeatedFieldRef<ForeignMessage>(
639 m2, fd_repeated_foreign_message));
640 mrf_nested_enum.MergeFrom(refl->GetRepeatedFieldRef<TestAllTypes::NestedEnum>(
641 m2, fd_repeated_nested_enum));
642 for (int i = 0; i < 10; ++i) {
643 EXPECT_EQ(Func(i, 21), m0.repeated_int32(i + 10));
644 EXPECT_EQ(Func(i, 22), m0.repeated_double(i + 10));
645 EXPECT_EQ(StrFunc(i, 25), m0.repeated_string(i + 10));
646 EXPECT_EQ(Func(i, 26), m0.repeated_foreign_message(i + 10).c());
647 EXPECT_EQ(TestAllTypes::BAZ, m0.repeated_nested_enum(i + 10));
648 }
649
650 // Test MutableRepeatedRef::Swap
651 // Swap between m0 and m2.
652 mrf_int32.Swap(
653 refl->GetMutableRepeatedFieldRef<int32>(&m2, fd_repeated_int32));
654 mrf_double.Swap(
655 refl->GetMutableRepeatedFieldRef<double>(&m2, fd_repeated_double));
656 mrf_string.Swap(
657 refl->GetMutableRepeatedFieldRef<std::string>(&m2, fd_repeated_string));
658 mrf_foreign_message.Swap(refl->GetMutableRepeatedFieldRef<ForeignMessage>(
659 &m2, fd_repeated_foreign_message));
660 mrf_nested_enum.Swap(
661 refl->GetMutableRepeatedFieldRef<TestAllTypes::NestedEnum>(
662 &m2, fd_repeated_nested_enum));
663 for (int i = 0; i < 10; ++i) {
664 // Check the content of m0.
665 EXPECT_EQ(Func(i, 21), m0.repeated_int32(i));
666 EXPECT_EQ(Func(i, 22), m0.repeated_double(i));
667 EXPECT_EQ(StrFunc(i, 25), m0.repeated_string(i));
668 EXPECT_EQ(Func(i, 26), m0.repeated_foreign_message(i).c());
669 EXPECT_EQ(TestAllTypes::BAZ, m0.repeated_nested_enum(i));
670
671 // Check the content of m2.
672 EXPECT_EQ(Func(i, 11), m2.repeated_int32(i));
673 EXPECT_EQ(Func(i, 12), m2.repeated_double(i));
674 EXPECT_EQ(StrFunc(i, 15), m2.repeated_string(i));
675 EXPECT_EQ(Func(i, 16), m2.repeated_foreign_message(i).c());
676 EXPECT_EQ(TestAllTypes::BAR, m2.repeated_nested_enum(i));
677 EXPECT_EQ(Func(i, 21), m2.repeated_int32(i + 10));
678 EXPECT_EQ(Func(i, 22), m2.repeated_double(i + 10));
679 EXPECT_EQ(StrFunc(i, 25), m2.repeated_string(i + 10));
680 EXPECT_EQ(Func(i, 26), m2.repeated_foreign_message(i + 10).c());
681 EXPECT_EQ(TestAllTypes::BAZ, m2.repeated_nested_enum(i + 10));
682 }
683 }
684
685 // Test that GetRepeatedFieldRef/MutableRepeatedFieldRef works with
686 // DynamicMessage.
TEST(RepeatedFieldReflectionTest,RepeatedFieldRefDynamicMessage)687 TEST(RepeatedFieldReflectionTest, RepeatedFieldRefDynamicMessage) {
688 // DynamicMessage shares the same memory layout as generated message
689 // and use the same GeneratedMessageReflection code for reflection.
690 // All code paths should already be covered by the other tests for
691 // generated messages. Here we just test one field.
692
693 const Descriptor* desc = TestAllTypes::descriptor();
694 const FieldDescriptor* fd_repeated_int32 =
695 desc->FindFieldByName("repeated_int32");
696
697 DynamicMessageFactory factory;
698 std::unique_ptr<Message> dynamic_message(factory.GetPrototype(desc)->New());
699 const Reflection* refl = dynamic_message->GetReflection();
700
701 MutableRepeatedFieldRef<int32> rf_int32 =
702 refl->GetMutableRepeatedFieldRef<int32>(dynamic_message.get(),
703 fd_repeated_int32);
704 rf_int32.Add(1234);
705 EXPECT_EQ(1, refl->FieldSize(*dynamic_message, fd_repeated_int32));
706 EXPECT_EQ(1234,
707 refl->GetRepeatedInt32(*dynamic_message, fd_repeated_int32, 0));
708 }
709
710 } // namespace
711 } // namespace protobuf
712 } // namespace google
713