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