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