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 #include <google/protobuf/map_test_util.h> 32 #include <google/protobuf/map_test_util_impl.h> 33 #include <google/protobuf/descriptor.h> 34 #include <google/protobuf/message.h> 35 36 namespace google { 37 namespace protobuf { 38 39 void MapTestUtil::SetMapFields(unittest::TestMap* message) { 40 MapTestUtilImpl::SetMapFields<unittest::MapEnum, unittest::MAP_ENUM_BAR, 41 unittest::MAP_ENUM_BAZ>(message); 42 } 43 44 void MapTestUtil::SetArenaMapFields(unittest::TestArenaMap* message) { 45 MapTestUtilImpl::SetArenaMapFields<unittest::MapEnum, unittest::MAP_ENUM_BAR, 46 unittest::MAP_ENUM_BAZ>(message); 47 } 48 49 void MapTestUtil::SetMapFieldsInitialized(unittest::TestMap* message) { 50 MapTestUtilImpl::SetMapFieldsInitialized(message); 51 } 52 53 void MapTestUtil::ModifyMapFields(unittest::TestMap* message) { 54 MapTestUtilImpl::ModifyMapFields<unittest::MapEnum, unittest::MAP_ENUM_FOO>( 55 message); 56 } 57 58 void MapTestUtil::ExpectClear(const unittest::TestMap& message) { 59 MapTestUtilImpl::ExpectClear(message); 60 } 61 62 void MapTestUtil::ExpectMapFieldsSet(const unittest::TestMap& message) { 63 MapTestUtilImpl::ExpectMapFieldsSet<unittest::MapEnum, unittest::MAP_ENUM_BAR, 64 unittest::MAP_ENUM_BAZ>(message); 65 } 66 67 void MapTestUtil::ExpectArenaMapFieldsSet( 68 const unittest::TestArenaMap& message) { 69 MapTestUtilImpl::ExpectArenaMapFieldsSet< 70 unittest::MapEnum, unittest::MAP_ENUM_BAR, unittest::MAP_ENUM_BAZ>( 71 message); 72 } 73 74 void MapTestUtil::ExpectMapFieldsSetInitialized( 75 const unittest::TestMap& message) { 76 MapTestUtilImpl::ExpectMapFieldsSetInitialized<unittest::MapEnum, 77 unittest::MAP_ENUM_FOO>( 78 message); 79 } 80 81 void MapTestUtil::ExpectMapFieldsModified( 82 const unittest::TestMap& message) { 83 MapTestUtilImpl::ExpectMapFieldsModified< 84 unittest::MapEnum, unittest::MAP_ENUM_BAR, unittest::MAP_ENUM_FOO>( 85 message); 86 } 87 88 void MapTestUtil::ExpectMapsSize( 89 const unittest::TestMap& message, int size) { 90 const Descriptor* descriptor = message.GetDescriptor(); 91 92 EXPECT_EQ(size, message.GetReflection()->FieldSize( 93 message, descriptor->FindFieldByName("map_int32_int32"))); 94 EXPECT_EQ(size, message.GetReflection()->FieldSize( 95 message, descriptor->FindFieldByName("map_int64_int64"))); 96 EXPECT_EQ(size, message.GetReflection()->FieldSize( 97 message, descriptor->FindFieldByName("map_uint32_uint32"))); 98 EXPECT_EQ(size, message.GetReflection()->FieldSize( 99 message, descriptor->FindFieldByName("map_uint64_uint64"))); 100 EXPECT_EQ(size, message.GetReflection()->FieldSize( 101 message, descriptor->FindFieldByName("map_sint32_sint32"))); 102 EXPECT_EQ(size, message.GetReflection()->FieldSize( 103 message, descriptor->FindFieldByName("map_sint64_sint64"))); 104 EXPECT_EQ(size, message.GetReflection()->FieldSize( 105 message, descriptor->FindFieldByName("map_fixed32_fixed32"))); 106 EXPECT_EQ(size, message.GetReflection()->FieldSize( 107 message, descriptor->FindFieldByName("map_fixed64_fixed64"))); 108 EXPECT_EQ(size, message.GetReflection()->FieldSize( 109 message, descriptor->FindFieldByName("map_sfixed32_sfixed32"))); 110 EXPECT_EQ(size, message.GetReflection()->FieldSize( 111 message, descriptor->FindFieldByName("map_sfixed64_sfixed64"))); 112 EXPECT_EQ(size, message.GetReflection()->FieldSize( 113 message, descriptor->FindFieldByName("map_int32_float"))); 114 EXPECT_EQ(size, message.GetReflection()->FieldSize( 115 message, descriptor->FindFieldByName("map_int32_double"))); 116 EXPECT_EQ(size, message.GetReflection()->FieldSize( 117 message, descriptor->FindFieldByName("map_bool_bool"))); 118 EXPECT_EQ(size, message.GetReflection()->FieldSize( 119 message, descriptor->FindFieldByName("map_string_string"))); 120 EXPECT_EQ(size, message.GetReflection()->FieldSize( 121 message, descriptor->FindFieldByName("map_int32_bytes"))); 122 EXPECT_EQ(size, message.GetReflection()->FieldSize( 123 message, descriptor->FindFieldByName("map_int32_foreign_message"))); 124 } 125 126 std::vector<const Message*> MapTestUtil::GetMapEntries( 127 const unittest::TestMap& message, int index) { 128 const Descriptor* descriptor = message.GetDescriptor(); 129 std::vector<const Message*> result; 130 131 result.push_back(&message.GetReflection()->GetRepeatedMessage( 132 message, descriptor->FindFieldByName("map_int32_int32"), index)); 133 result.push_back(&message.GetReflection()->GetRepeatedMessage( 134 message, descriptor->FindFieldByName("map_int64_int64"), index)); 135 result.push_back(&message.GetReflection()->GetRepeatedMessage( 136 message, descriptor->FindFieldByName("map_uint32_uint32"), index)); 137 result.push_back(&message.GetReflection()->GetRepeatedMessage( 138 message, descriptor->FindFieldByName("map_uint64_uint64"), index)); 139 result.push_back(&message.GetReflection()->GetRepeatedMessage( 140 message, descriptor->FindFieldByName("map_sint32_sint32"), index)); 141 result.push_back(&message.GetReflection()->GetRepeatedMessage( 142 message, descriptor->FindFieldByName("map_sint64_sint64"), index)); 143 result.push_back(&message.GetReflection()->GetRepeatedMessage( 144 message, descriptor->FindFieldByName("map_fixed32_fixed32"), index)); 145 result.push_back(&message.GetReflection()->GetRepeatedMessage( 146 message, descriptor->FindFieldByName("map_fixed64_fixed64"), index)); 147 result.push_back(&message.GetReflection()->GetRepeatedMessage( 148 message, descriptor->FindFieldByName("map_sfixed32_sfixed32"), index)); 149 result.push_back(&message.GetReflection()->GetRepeatedMessage( 150 message, descriptor->FindFieldByName("map_sfixed64_sfixed64"), index)); 151 result.push_back(&message.GetReflection()->GetRepeatedMessage( 152 message, descriptor->FindFieldByName("map_int32_float"), index)); 153 result.push_back(&message.GetReflection()->GetRepeatedMessage( 154 message, descriptor->FindFieldByName("map_int32_double"), index)); 155 result.push_back(&message.GetReflection()->GetRepeatedMessage( 156 message, descriptor->FindFieldByName("map_bool_bool"), index)); 157 result.push_back(&message.GetReflection()->GetRepeatedMessage( 158 message, descriptor->FindFieldByName("map_string_string"), index)); 159 result.push_back(&message.GetReflection()->GetRepeatedMessage( 160 message, descriptor->FindFieldByName("map_int32_bytes"), index)); 161 result.push_back(&message.GetReflection()->GetRepeatedMessage( 162 message, descriptor->FindFieldByName("map_int32_enum"), index)); 163 result.push_back(&message.GetReflection()->GetRepeatedMessage( 164 message, descriptor->FindFieldByName("map_int32_foreign_message"), index)); 165 166 return result; 167 } 168 169 std::vector<const Message*> MapTestUtil::GetMapEntriesFromRelease( 170 unittest::TestMap* message) { 171 const Descriptor* descriptor = message->GetDescriptor(); 172 std::vector<const Message*> result; 173 174 result.push_back(message->GetReflection()->ReleaseLast( 175 message, descriptor->FindFieldByName("map_int32_int32"))); 176 result.push_back(message->GetReflection()->ReleaseLast( 177 message, descriptor->FindFieldByName("map_int64_int64"))); 178 result.push_back(message->GetReflection()->ReleaseLast( 179 message, descriptor->FindFieldByName("map_uint32_uint32"))); 180 result.push_back(message->GetReflection()->ReleaseLast( 181 message, descriptor->FindFieldByName("map_uint64_uint64"))); 182 result.push_back(message->GetReflection()->ReleaseLast( 183 message, descriptor->FindFieldByName("map_sint32_sint32"))); 184 result.push_back(message->GetReflection()->ReleaseLast( 185 message, descriptor->FindFieldByName("map_sint64_sint64"))); 186 result.push_back(message->GetReflection()->ReleaseLast( 187 message, descriptor->FindFieldByName("map_fixed32_fixed32"))); 188 result.push_back(message->GetReflection()->ReleaseLast( 189 message, descriptor->FindFieldByName("map_fixed64_fixed64"))); 190 result.push_back(message->GetReflection()->ReleaseLast( 191 message, descriptor->FindFieldByName("map_sfixed32_sfixed32"))); 192 result.push_back(message->GetReflection()->ReleaseLast( 193 message, descriptor->FindFieldByName("map_sfixed64_sfixed64"))); 194 result.push_back(message->GetReflection()->ReleaseLast( 195 message, descriptor->FindFieldByName("map_int32_float"))); 196 result.push_back(message->GetReflection()->ReleaseLast( 197 message, descriptor->FindFieldByName("map_int32_double"))); 198 result.push_back(message->GetReflection()->ReleaseLast( 199 message, descriptor->FindFieldByName("map_bool_bool"))); 200 result.push_back(message->GetReflection()->ReleaseLast( 201 message, descriptor->FindFieldByName("map_string_string"))); 202 result.push_back(message->GetReflection()->ReleaseLast( 203 message, descriptor->FindFieldByName("map_int32_bytes"))); 204 result.push_back(message->GetReflection()->ReleaseLast( 205 message, descriptor->FindFieldByName("map_int32_enum"))); 206 result.push_back(message->GetReflection()->ReleaseLast( 207 message, descriptor->FindFieldByName("map_int32_foreign_message"))); 208 209 return result; 210 } 211 212 MapReflectionTester::MapReflectionTester( 213 const Descriptor* base_descriptor) 214 : base_descriptor_(base_descriptor) { 215 const DescriptorPool* pool = base_descriptor->file()->pool(); 216 217 map_enum_foo_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_FOO"); 218 map_enum_bar_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAR"); 219 map_enum_baz_ = pool->FindEnumValueByName("protobuf_unittest.MAP_ENUM_BAZ"); 220 221 foreign_c_ = pool->FindFieldByName( 222 "protobuf_unittest.ForeignMessage.c"); 223 map_int32_int32_key_ = pool->FindFieldByName( 224 "protobuf_unittest.TestMap.MapInt32Int32Entry.key"); 225 map_int32_int32_val_ = pool->FindFieldByName( 226 "protobuf_unittest.TestMap.MapInt32Int32Entry.value"); 227 map_int64_int64_key_ = pool->FindFieldByName( 228 "protobuf_unittest.TestMap.MapInt64Int64Entry.key"); 229 map_int64_int64_val_ = pool->FindFieldByName( 230 "protobuf_unittest.TestMap.MapInt64Int64Entry.value"); 231 map_uint32_uint32_key_ = pool->FindFieldByName( 232 "protobuf_unittest.TestMap.MapUint32Uint32Entry.key"); 233 map_uint32_uint32_val_ = pool->FindFieldByName( 234 "protobuf_unittest.TestMap.MapUint32Uint32Entry.value"); 235 map_uint64_uint64_key_ = pool->FindFieldByName( 236 "protobuf_unittest.TestMap.MapUint64Uint64Entry.key"); 237 map_uint64_uint64_val_ = pool->FindFieldByName( 238 "protobuf_unittest.TestMap.MapUint64Uint64Entry.value"); 239 map_sint32_sint32_key_ = pool->FindFieldByName( 240 "protobuf_unittest.TestMap.MapSint32Sint32Entry.key"); 241 map_sint32_sint32_val_ = pool->FindFieldByName( 242 "protobuf_unittest.TestMap.MapSint32Sint32Entry.value"); 243 map_sint64_sint64_key_ = pool->FindFieldByName( 244 "protobuf_unittest.TestMap.MapSint64Sint64Entry.key"); 245 map_sint64_sint64_val_ = pool->FindFieldByName( 246 "protobuf_unittest.TestMap.MapSint64Sint64Entry.value"); 247 map_fixed32_fixed32_key_ = pool->FindFieldByName( 248 "protobuf_unittest.TestMap.MapFixed32Fixed32Entry.key"); 249 map_fixed32_fixed32_val_ = pool->FindFieldByName( 250 "protobuf_unittest.TestMap.MapFixed32Fixed32Entry.value"); 251 map_fixed64_fixed64_key_ = pool->FindFieldByName( 252 "protobuf_unittest.TestMap.MapFixed64Fixed64Entry.key"); 253 map_fixed64_fixed64_val_ = pool->FindFieldByName( 254 "protobuf_unittest.TestMap.MapFixed64Fixed64Entry.value"); 255 map_sfixed32_sfixed32_key_ = pool->FindFieldByName( 256 "protobuf_unittest.TestMap.MapSfixed32Sfixed32Entry.key"); 257 map_sfixed32_sfixed32_val_ = pool->FindFieldByName( 258 "protobuf_unittest.TestMap.MapSfixed32Sfixed32Entry.value"); 259 map_sfixed64_sfixed64_key_ = pool->FindFieldByName( 260 "protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.key"); 261 map_sfixed64_sfixed64_val_ = pool->FindFieldByName( 262 "protobuf_unittest.TestMap.MapSfixed64Sfixed64Entry.value"); 263 map_int32_float_key_ = pool->FindFieldByName( 264 "protobuf_unittest.TestMap.MapInt32FloatEntry.key"); 265 map_int32_float_val_ = pool->FindFieldByName( 266 "protobuf_unittest.TestMap.MapInt32FloatEntry.value"); 267 map_int32_double_key_ = pool->FindFieldByName( 268 "protobuf_unittest.TestMap.MapInt32DoubleEntry.key"); 269 map_int32_double_val_ = pool->FindFieldByName( 270 "protobuf_unittest.TestMap.MapInt32DoubleEntry.value"); 271 map_bool_bool_key_ = pool->FindFieldByName( 272 "protobuf_unittest.TestMap.MapBoolBoolEntry.key"); 273 map_bool_bool_val_ = pool->FindFieldByName( 274 "protobuf_unittest.TestMap.MapBoolBoolEntry.value"); 275 map_string_string_key_ = pool->FindFieldByName( 276 "protobuf_unittest.TestMap.MapStringStringEntry.key"); 277 map_string_string_val_ = pool->FindFieldByName( 278 "protobuf_unittest.TestMap.MapStringStringEntry.value"); 279 map_int32_bytes_key_ = pool->FindFieldByName( 280 "protobuf_unittest.TestMap.MapInt32BytesEntry.key"); 281 map_int32_bytes_val_ = pool->FindFieldByName( 282 "protobuf_unittest.TestMap.MapInt32BytesEntry.value"); 283 map_int32_enum_key_ = pool->FindFieldByName( 284 "protobuf_unittest.TestMap.MapInt32EnumEntry.key"); 285 map_int32_enum_val_ = pool->FindFieldByName( 286 "protobuf_unittest.TestMap.MapInt32EnumEntry.value"); 287 map_int32_foreign_message_key_ = pool->FindFieldByName( 288 "protobuf_unittest.TestMap.MapInt32ForeignMessageEntry.key"); 289 map_int32_foreign_message_val_ = pool->FindFieldByName( 290 "protobuf_unittest.TestMap.MapInt32ForeignMessageEntry.value"); 291 292 EXPECT_FALSE(map_enum_foo_ == NULL); 293 EXPECT_FALSE(map_enum_bar_ == NULL); 294 EXPECT_FALSE(map_enum_baz_ == NULL); 295 EXPECT_FALSE(map_int32_int32_key_ == NULL); 296 EXPECT_FALSE(map_int32_int32_val_ == NULL); 297 EXPECT_FALSE(map_int64_int64_key_ == NULL); 298 EXPECT_FALSE(map_int64_int64_val_ == NULL); 299 EXPECT_FALSE(map_uint32_uint32_key_ == NULL); 300 EXPECT_FALSE(map_uint32_uint32_val_ == NULL); 301 EXPECT_FALSE(map_uint64_uint64_key_ == NULL); 302 EXPECT_FALSE(map_uint64_uint64_val_ == NULL); 303 EXPECT_FALSE(map_sint32_sint32_key_ == NULL); 304 EXPECT_FALSE(map_sint32_sint32_val_ == NULL); 305 EXPECT_FALSE(map_sint64_sint64_key_ == NULL); 306 EXPECT_FALSE(map_sint64_sint64_val_ == NULL); 307 EXPECT_FALSE(map_fixed32_fixed32_key_ == NULL); 308 EXPECT_FALSE(map_fixed32_fixed32_val_ == NULL); 309 EXPECT_FALSE(map_fixed64_fixed64_key_ == NULL); 310 EXPECT_FALSE(map_fixed64_fixed64_val_ == NULL); 311 EXPECT_FALSE(map_sfixed32_sfixed32_key_ == NULL); 312 EXPECT_FALSE(map_sfixed32_sfixed32_val_ == NULL); 313 EXPECT_FALSE(map_sfixed64_sfixed64_key_ == NULL); 314 EXPECT_FALSE(map_sfixed64_sfixed64_val_ == NULL); 315 EXPECT_FALSE(map_int32_float_key_ == NULL); 316 EXPECT_FALSE(map_int32_float_val_ == NULL); 317 EXPECT_FALSE(map_int32_double_key_ == NULL); 318 EXPECT_FALSE(map_int32_double_val_ == NULL); 319 EXPECT_FALSE(map_bool_bool_key_ == NULL); 320 EXPECT_FALSE(map_bool_bool_val_ == NULL); 321 EXPECT_FALSE(map_string_string_key_ == NULL); 322 EXPECT_FALSE(map_string_string_val_ == NULL); 323 EXPECT_FALSE(map_int32_bytes_key_ == NULL); 324 EXPECT_FALSE(map_int32_bytes_val_ == NULL); 325 EXPECT_FALSE(map_int32_enum_key_ == NULL); 326 EXPECT_FALSE(map_int32_enum_val_ == NULL); 327 EXPECT_FALSE(map_int32_foreign_message_key_ == NULL); 328 EXPECT_FALSE(map_int32_foreign_message_val_ == NULL); 329 } 330 331 // Shorthand to get a FieldDescriptor for a field of unittest::TestMap. 332 const FieldDescriptor* MapReflectionTester::F(const string& name) { 333 const FieldDescriptor* result = NULL; 334 result = base_descriptor_->FindFieldByName(name); 335 GOOGLE_CHECK(result != NULL); 336 return result; 337 } 338 339 void MapReflectionTester::SetMapFieldsViaReflection( 340 Message* message) { 341 const Reflection* reflection = message->GetReflection(); 342 Message* sub_message = NULL; 343 Message* sub_foreign_message = NULL; 344 345 // Add first element. 346 sub_message = reflection->AddMessage(message, F("map_int32_int32")); 347 sub_message->GetReflection() 348 ->SetInt32(sub_message, map_int32_int32_key_, 0); 349 sub_message->GetReflection() 350 ->SetInt32(sub_message, map_int32_int32_val_, 0); 351 352 sub_message = reflection->AddMessage(message, F("map_int64_int64")); 353 sub_message->GetReflection() 354 ->SetInt64(sub_message, map_int64_int64_key_, 0); 355 sub_message->GetReflection() 356 ->SetInt64(sub_message, map_int64_int64_val_, 0); 357 358 sub_message = reflection->AddMessage(message, F("map_uint32_uint32")); 359 sub_message->GetReflection() 360 ->SetUInt32(sub_message, map_uint32_uint32_key_, 0); 361 sub_message->GetReflection() 362 ->SetUInt32(sub_message, map_uint32_uint32_val_, 0); 363 364 sub_message = reflection->AddMessage(message, F("map_uint64_uint64")); 365 sub_message->GetReflection() 366 ->SetUInt64(sub_message, map_uint64_uint64_key_, 0); 367 sub_message->GetReflection() 368 ->SetUInt64(sub_message, map_uint64_uint64_val_, 0); 369 370 sub_message = reflection->AddMessage(message, F("map_sint32_sint32")); 371 sub_message->GetReflection() 372 ->SetInt32(sub_message, map_sint32_sint32_key_, 0); 373 sub_message->GetReflection() 374 ->SetInt32(sub_message, map_sint32_sint32_val_, 0); 375 376 sub_message = reflection->AddMessage(message, F("map_sint64_sint64")); 377 sub_message->GetReflection() 378 ->SetInt64(sub_message, map_sint64_sint64_key_, 0); 379 sub_message->GetReflection() 380 ->SetInt64(sub_message, map_sint64_sint64_val_, 0); 381 382 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32")); 383 sub_message->GetReflection() 384 ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 0); 385 sub_message->GetReflection() 386 ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 0); 387 388 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64")); 389 sub_message->GetReflection() 390 ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 0); 391 sub_message->GetReflection() 392 ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 0); 393 394 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32")); 395 sub_message->GetReflection() 396 ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 0); 397 sub_message->GetReflection() 398 ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 0); 399 400 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64")); 401 sub_message->GetReflection() 402 ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 0); 403 sub_message->GetReflection() 404 ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 0); 405 406 sub_message = reflection->AddMessage(message, F("map_int32_float")); 407 sub_message->GetReflection() 408 ->SetInt32(sub_message, map_int32_float_key_, 0); 409 sub_message->GetReflection() 410 ->SetFloat(sub_message, map_int32_float_val_, 0.0); 411 412 sub_message = reflection->AddMessage(message, F("map_int32_double")); 413 sub_message->GetReflection() 414 ->SetInt32(sub_message, map_int32_double_key_, 0); 415 sub_message->GetReflection() 416 ->SetDouble(sub_message, map_int32_double_val_, 0.0); 417 418 sub_message = reflection->AddMessage(message, F("map_bool_bool")); 419 sub_message->GetReflection() 420 ->SetBool(sub_message, map_bool_bool_key_, false); 421 sub_message->GetReflection() 422 ->SetBool(sub_message, map_bool_bool_val_, false); 423 424 sub_message = reflection->AddMessage(message, F("map_string_string")); 425 sub_message->GetReflection() 426 ->SetString(sub_message, map_string_string_key_, "0"); 427 sub_message->GetReflection() 428 ->SetString(sub_message, map_string_string_val_, "0"); 429 430 sub_message = reflection->AddMessage(message, F("map_int32_bytes")); 431 sub_message->GetReflection() 432 ->SetInt32(sub_message, map_int32_bytes_key_, 0); 433 sub_message->GetReflection() 434 ->SetString(sub_message, map_int32_bytes_val_, "0"); 435 436 sub_message = reflection->AddMessage(message, F("map_int32_enum")); 437 sub_message->GetReflection() 438 ->SetInt32(sub_message, map_int32_enum_key_, 0); 439 sub_message->GetReflection() 440 ->SetEnum(sub_message, map_int32_enum_val_, map_enum_bar_); 441 442 sub_message = reflection 443 ->AddMessage(message, F("map_int32_foreign_message")); 444 sub_message->GetReflection() 445 ->SetInt32(sub_message, map_int32_foreign_message_key_, 0); 446 sub_foreign_message = sub_message->GetReflection()-> 447 MutableMessage(sub_message, map_int32_foreign_message_val_, NULL); 448 sub_foreign_message->GetReflection()-> 449 SetInt32(sub_foreign_message, foreign_c_, 0); 450 451 // Add second element 452 sub_message = reflection->AddMessage(message, F("map_int32_int32")); 453 sub_message->GetReflection() 454 ->SetInt32(sub_message, map_int32_int32_key_, 1); 455 sub_message->GetReflection() 456 ->SetInt32(sub_message, map_int32_int32_val_, 1); 457 458 sub_message = reflection->AddMessage(message, F("map_int64_int64")); 459 sub_message->GetReflection() 460 ->SetInt64(sub_message, map_int64_int64_key_, 1); 461 sub_message->GetReflection() 462 ->SetInt64(sub_message, map_int64_int64_val_, 1); 463 464 sub_message = reflection->AddMessage(message, F("map_uint32_uint32")); 465 sub_message->GetReflection() 466 ->SetUInt32(sub_message, map_uint32_uint32_key_, 1); 467 sub_message->GetReflection() 468 ->SetUInt32(sub_message, map_uint32_uint32_val_, 1); 469 470 sub_message = reflection->AddMessage(message, F("map_uint64_uint64")); 471 sub_message->GetReflection() 472 ->SetUInt64(sub_message, map_uint64_uint64_key_, 1); 473 sub_message->GetReflection() 474 ->SetUInt64(sub_message, map_uint64_uint64_val_, 1); 475 476 sub_message = reflection->AddMessage(message, F("map_sint32_sint32")); 477 sub_message->GetReflection() 478 ->SetInt32(sub_message, map_sint32_sint32_key_, 1); 479 sub_message->GetReflection() 480 ->SetInt32(sub_message, map_sint32_sint32_val_, 1); 481 482 sub_message = reflection->AddMessage(message, F("map_sint64_sint64")); 483 sub_message->GetReflection() 484 ->SetInt64(sub_message, map_sint64_sint64_key_, 1); 485 sub_message->GetReflection() 486 ->SetInt64(sub_message, map_sint64_sint64_val_, 1); 487 488 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32")); 489 sub_message->GetReflection() 490 ->SetUInt32(sub_message, map_fixed32_fixed32_key_, 1); 491 sub_message->GetReflection() 492 ->SetUInt32(sub_message, map_fixed32_fixed32_val_, 1); 493 494 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64")); 495 sub_message->GetReflection() 496 ->SetUInt64(sub_message, map_fixed64_fixed64_key_, 1); 497 sub_message->GetReflection() 498 ->SetUInt64(sub_message, map_fixed64_fixed64_val_, 1); 499 500 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32")); 501 sub_message->GetReflection() 502 ->SetInt32(sub_message, map_sfixed32_sfixed32_key_, 1); 503 sub_message->GetReflection() 504 ->SetInt32(sub_message, map_sfixed32_sfixed32_val_, 1); 505 506 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64")); 507 sub_message->GetReflection() 508 ->SetInt64(sub_message, map_sfixed64_sfixed64_key_, 1); 509 sub_message->GetReflection() 510 ->SetInt64(sub_message, map_sfixed64_sfixed64_val_, 1); 511 512 sub_message = reflection->AddMessage(message, F("map_int32_float")); 513 sub_message->GetReflection() 514 ->SetInt32(sub_message, map_int32_float_key_, 1); 515 sub_message->GetReflection() 516 ->SetFloat(sub_message, map_int32_float_val_, 1.0); 517 518 sub_message = reflection->AddMessage(message, F("map_int32_double")); 519 sub_message->GetReflection() 520 ->SetInt32(sub_message, map_int32_double_key_, 1); 521 sub_message->GetReflection() 522 ->SetDouble(sub_message, map_int32_double_val_, 1.0); 523 524 sub_message = reflection->AddMessage(message, F("map_bool_bool")); 525 sub_message->GetReflection() 526 ->SetBool(sub_message, map_bool_bool_key_, true); 527 sub_message->GetReflection() 528 ->SetBool(sub_message, map_bool_bool_val_, true); 529 530 sub_message = reflection->AddMessage(message, F("map_string_string")); 531 sub_message->GetReflection() 532 ->SetString(sub_message, map_string_string_key_, "1"); 533 sub_message->GetReflection() 534 ->SetString(sub_message, map_string_string_val_, "1"); 535 536 sub_message = reflection->AddMessage(message, F("map_int32_bytes")); 537 sub_message->GetReflection() 538 ->SetInt32(sub_message, map_int32_bytes_key_, 1); 539 sub_message->GetReflection() 540 ->SetString(sub_message, map_int32_bytes_val_, "1"); 541 542 sub_message = reflection->AddMessage(message, F("map_int32_enum")); 543 sub_message->GetReflection() 544 ->SetInt32(sub_message, map_int32_enum_key_, 1); 545 sub_message->GetReflection() 546 ->SetEnum(sub_message, map_int32_enum_val_, map_enum_baz_); 547 548 sub_message = reflection 549 ->AddMessage(message, F("map_int32_foreign_message")); 550 sub_message->GetReflection() 551 ->SetInt32(sub_message, map_int32_foreign_message_key_, 1); 552 sub_foreign_message = sub_message->GetReflection()-> 553 MutableMessage(sub_message, map_int32_foreign_message_val_, NULL); 554 sub_foreign_message->GetReflection()-> 555 SetInt32(sub_foreign_message, foreign_c_, 1); 556 } 557 558 void MapReflectionTester::SetMapFieldsViaMapReflection( 559 Message* message) { 560 const Reflection* reflection = message->GetReflection(); 561 562 Message* sub_foreign_message = NULL; 563 MapValueRef map_val; 564 565 // Add first element. 566 MapKey map_key; 567 map_key.SetInt32Value(0); 568 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 569 message, F("map_int32_int32"), map_key, &map_val)); 570 map_val.SetInt32Value(0); 571 572 map_key.SetInt64Value(0); 573 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 574 message, F("map_int64_int64"), map_key, &map_val)); 575 map_val.SetInt64Value(0); 576 577 map_key.SetUInt32Value(0); 578 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 579 message, F("map_uint32_uint32"), map_key, &map_val)); 580 map_val.SetUInt32Value(0); 581 582 map_key.SetUInt64Value(0); 583 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 584 message, F("map_uint64_uint64"), map_key, &map_val)); 585 map_val.SetUInt64Value(0); 586 587 map_key.SetInt32Value(0); 588 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 589 message, F("map_sint32_sint32"), map_key, &map_val)); 590 map_val.SetInt32Value(0); 591 592 map_key.SetInt64Value(0); 593 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 594 message, F("map_sint64_sint64"), map_key, &map_val)); 595 map_val.SetInt64Value(0); 596 597 map_key.SetUInt32Value(0); 598 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 599 message, F("map_fixed32_fixed32"), map_key, &map_val)); 600 map_val.SetUInt32Value(0); 601 602 map_key.SetUInt64Value(0); 603 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 604 message, F("map_fixed64_fixed64"), map_key, &map_val)); 605 map_val.SetUInt64Value(0); 606 607 map_key.SetInt32Value(0); 608 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 609 message, F("map_sfixed32_sfixed32"), map_key, &map_val)); 610 map_val.SetInt32Value(0); 611 612 map_key.SetInt64Value(0); 613 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 614 message, F("map_sfixed64_sfixed64"), map_key, &map_val)); 615 map_val.SetInt64Value(0); 616 617 map_key.SetInt32Value(0); 618 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 619 message, F("map_int32_float"), map_key, &map_val)); 620 map_val.SetFloatValue(0.0); 621 622 map_key.SetInt32Value(0); 623 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 624 message, F("map_int32_double"), map_key, &map_val)); 625 map_val.SetDoubleValue(0.0); 626 627 map_key.SetBoolValue(false); 628 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 629 message, F("map_bool_bool"), map_key, &map_val)); 630 map_val.SetBoolValue(false); 631 632 map_key.SetStringValue("0"); 633 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 634 message, F("map_string_string"), map_key, &map_val)); 635 map_val.SetStringValue("0"); 636 637 map_key.SetInt32Value(0); 638 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 639 message, F("map_int32_bytes"), map_key, &map_val)); 640 map_val.SetStringValue("0"); 641 642 map_key.SetInt32Value(0); 643 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 644 message, F("map_int32_enum"), map_key, &map_val)); 645 map_val.SetEnumValue(map_enum_bar_->number()); 646 647 map_key.SetInt32Value(0); 648 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 649 message, F("map_int32_foreign_message"), map_key, &map_val)); 650 sub_foreign_message = map_val.MutableMessageValue(); 651 sub_foreign_message->GetReflection()->SetInt32( 652 sub_foreign_message, foreign_c_, 0); 653 654 // Add second element 655 map_key.SetInt32Value(1); 656 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 657 message, F("map_int32_int32"), map_key, &map_val)); 658 map_val.SetInt32Value(1); 659 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 660 message, F("map_int32_int32"), map_key, &map_val)); 661 662 map_key.SetInt64Value(1); 663 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 664 message, F("map_int64_int64"), map_key, &map_val)); 665 map_val.SetInt64Value(1); 666 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 667 message, F("map_int64_int64"), map_key, &map_val)); 668 669 map_key.SetUInt32Value(1); 670 reflection->InsertOrLookupMapValue( 671 message, F("map_uint32_uint32"), map_key, &map_val); 672 map_val.SetUInt32Value(1); 673 674 map_key.SetUInt64Value(1); 675 reflection->InsertOrLookupMapValue( 676 message, F("map_uint64_uint64"), map_key, &map_val); 677 map_val.SetUInt64Value(1); 678 679 map_key.SetInt32Value(1); 680 reflection->InsertOrLookupMapValue( 681 message, F("map_sint32_sint32"), map_key, &map_val); 682 map_val.SetInt32Value(1); 683 684 map_key.SetInt64Value(1); 685 reflection->InsertOrLookupMapValue( 686 message, F("map_sint64_sint64"), map_key, &map_val); 687 map_val.SetInt64Value(1); 688 689 map_key.SetUInt32Value(1); 690 reflection->InsertOrLookupMapValue( 691 message, F("map_fixed32_fixed32"), map_key, &map_val); 692 map_val.SetUInt32Value(1); 693 694 map_key.SetUInt64Value(1); 695 reflection->InsertOrLookupMapValue( 696 message, F("map_fixed64_fixed64"), map_key, &map_val); 697 map_val.SetUInt64Value(1); 698 699 map_key.SetInt32Value(1); 700 reflection->InsertOrLookupMapValue( 701 message, F("map_sfixed32_sfixed32"), map_key, &map_val); 702 map_val.SetInt32Value(1); 703 704 map_key.SetInt64Value(1); 705 reflection->InsertOrLookupMapValue( 706 message, F("map_sfixed64_sfixed64"), map_key, &map_val); 707 map_val.SetInt64Value(1); 708 709 map_key.SetInt32Value(1); 710 reflection->InsertOrLookupMapValue( 711 message, F("map_int32_float"), map_key, &map_val); 712 map_val.SetFloatValue(1.0); 713 714 map_key.SetInt32Value(1); 715 reflection->InsertOrLookupMapValue( 716 message, F("map_int32_double"), map_key, &map_val); 717 map_val.SetDoubleValue(1.0); 718 719 map_key.SetBoolValue(true); 720 reflection->InsertOrLookupMapValue( 721 message, F("map_bool_bool"), map_key, &map_val); 722 map_val.SetBoolValue(true); 723 724 map_key.SetStringValue("1"); 725 reflection->InsertOrLookupMapValue( 726 message, F("map_string_string"), map_key, &map_val); 727 map_val.SetStringValue("1"); 728 729 map_key.SetInt32Value(1); 730 reflection->InsertOrLookupMapValue( 731 message, F("map_int32_bytes"), map_key, &map_val); 732 map_val.SetStringValue("1"); 733 734 map_key.SetInt32Value(1); 735 reflection->InsertOrLookupMapValue( 736 message, F("map_int32_enum"), map_key, &map_val); 737 map_val.SetEnumValue(map_enum_baz_->number()); 738 739 map_key.SetInt32Value(1); 740 EXPECT_TRUE(reflection->InsertOrLookupMapValue( 741 message, F("map_int32_foreign_message"), map_key, &map_val)); 742 sub_foreign_message = map_val.MutableMessageValue(); 743 sub_foreign_message->GetReflection()->SetInt32( 744 sub_foreign_message, foreign_c_, 1); 745 } 746 747 void MapReflectionTester::ClearMapFieldsViaReflection( 748 Message* message) { 749 const Reflection* reflection = message->GetReflection(); 750 751 reflection->ClearField(message, F("map_int32_int32")); 752 reflection->ClearField(message, F("map_int64_int64")); 753 reflection->ClearField(message, F("map_uint32_uint32")); 754 reflection->ClearField(message, F("map_uint64_uint64")); 755 reflection->ClearField(message, F("map_sint32_sint32")); 756 reflection->ClearField(message, F("map_sint64_sint64")); 757 reflection->ClearField(message, F("map_fixed32_fixed32")); 758 reflection->ClearField(message, F("map_fixed64_fixed64")); 759 reflection->ClearField(message, F("map_sfixed32_sfixed32")); 760 reflection->ClearField(message, F("map_sfixed64_sfixed64")); 761 reflection->ClearField(message, F("map_int32_float")); 762 reflection->ClearField(message, F("map_int32_double")); 763 reflection->ClearField(message, F("map_bool_bool")); 764 reflection->ClearField(message, F("map_string_string")); 765 reflection->ClearField(message, F("map_int32_bytes")); 766 reflection->ClearField(message, F("map_int32_enum")); 767 reflection->ClearField(message, F("map_int32_foreign_message")); 768 } 769 770 void MapReflectionTester::ModifyMapFieldsViaReflection( 771 Message* message) { 772 const Reflection* reflection = message->GetReflection(); 773 MapValueRef map_val; 774 Message* sub_foreign_message; 775 776 // Modify the second element 777 MapKey map_key; 778 map_key.SetInt32Value(1); 779 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 780 message, F("map_int32_int32"), map_key, &map_val)); 781 map_val.SetInt32Value(2); 782 783 map_key.SetInt64Value(1); 784 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 785 message, F("map_int64_int64"), map_key, &map_val)); 786 map_val.SetInt64Value(2); 787 788 map_key.SetUInt32Value(1); 789 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 790 message, F("map_uint32_uint32"), map_key, &map_val)); 791 map_val.SetUInt32Value(2); 792 793 map_key.SetUInt64Value(1); 794 reflection->InsertOrLookupMapValue( 795 message, F("map_uint64_uint64"), map_key, &map_val); 796 map_val.SetUInt64Value(2); 797 798 map_key.SetInt32Value(1); 799 reflection->InsertOrLookupMapValue( 800 message, F("map_sint32_sint32"), map_key, &map_val); 801 map_val.SetInt32Value(2); 802 803 map_key.SetInt64Value(1); 804 reflection->InsertOrLookupMapValue( 805 message, F("map_sint64_sint64"), map_key, &map_val); 806 map_val.SetInt64Value(2); 807 808 map_key.SetUInt32Value(1); 809 reflection->InsertOrLookupMapValue( 810 message, F("map_fixed32_fixed32"), map_key, &map_val); 811 map_val.SetUInt32Value(2); 812 813 map_key.SetUInt64Value(1); 814 reflection->InsertOrLookupMapValue( 815 message, F("map_fixed64_fixed64"), map_key, &map_val); 816 map_val.SetUInt64Value(2); 817 818 map_key.SetInt32Value(1); 819 reflection->InsertOrLookupMapValue( 820 message, F("map_sfixed32_sfixed32"), map_key, &map_val); 821 map_val.SetInt32Value(2); 822 823 map_key.SetInt64Value(1); 824 reflection->InsertOrLookupMapValue( 825 message, F("map_sfixed64_sfixed64"), map_key, &map_val); 826 map_val.SetInt64Value(2); 827 828 map_key.SetInt32Value(1); 829 reflection->InsertOrLookupMapValue( 830 message, F("map_int32_float"), map_key, &map_val); 831 map_val.SetFloatValue(2.0); 832 833 map_key.SetInt32Value(1); 834 reflection->InsertOrLookupMapValue( 835 message, F("map_int32_double"), map_key, &map_val); 836 map_val.SetDoubleValue(2.0); 837 838 map_key.SetBoolValue(true); 839 reflection->InsertOrLookupMapValue( 840 message, F("map_bool_bool"), map_key, &map_val); 841 map_val.SetBoolValue(false); 842 843 map_key.SetStringValue("1"); 844 reflection->InsertOrLookupMapValue( 845 message, F("map_string_string"), map_key, &map_val); 846 map_val.SetStringValue("2"); 847 848 map_key.SetInt32Value(1); 849 reflection->InsertOrLookupMapValue( 850 message, F("map_int32_bytes"), map_key, &map_val); 851 map_val.SetStringValue("2"); 852 853 map_key.SetInt32Value(1); 854 reflection->InsertOrLookupMapValue( 855 message, F("map_int32_enum"), map_key, &map_val); 856 map_val.SetEnumValue(map_enum_foo_->number()); 857 858 map_key.SetInt32Value(1); 859 EXPECT_FALSE(reflection->InsertOrLookupMapValue( 860 message, F("map_int32_foreign_message"), map_key, &map_val)); 861 sub_foreign_message = map_val.MutableMessageValue(); 862 sub_foreign_message->GetReflection()->SetInt32( 863 sub_foreign_message, foreign_c_, 2); 864 } 865 866 void MapReflectionTester::RemoveLastMapsViaReflection( 867 Message* message) { 868 const Reflection* reflection = message->GetReflection(); 869 870 vector<const FieldDescriptor*> output; 871 reflection->ListFields(*message, &output); 872 for (int i = 0; i < output.size(); ++i) { 873 const FieldDescriptor* field = output[i]; 874 if (!field->is_repeated()) continue; 875 reflection->RemoveLast(message, field); 876 } 877 } 878 879 void MapReflectionTester::ReleaseLastMapsViaReflection( 880 Message* message) { 881 const Reflection* reflection = message->GetReflection(); 882 883 vector<const FieldDescriptor*> output; 884 reflection->ListFields(*message, &output); 885 for (int i = 0; i < output.size(); ++i) { 886 const FieldDescriptor* field = output[i]; 887 if (!field->is_repeated()) continue; 888 if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue; 889 890 Message* released = reflection->ReleaseLast(message, field); 891 ASSERT_TRUE(released != NULL) << "ReleaseLast returned NULL for: " 892 << field->name(); 893 delete released; 894 } 895 } 896 897 void MapReflectionTester::SwapMapsViaReflection(Message* message) { 898 const Reflection* reflection = message->GetReflection(); 899 vector<const FieldDescriptor*> output; 900 reflection->ListFields(*message, &output); 901 for (int i = 0; i < output.size(); ++i) { 902 const FieldDescriptor* field = output[i]; 903 if (!field->is_repeated()) continue; 904 reflection->SwapElements(message, field, 0, 1); 905 } 906 } 907 908 void MapReflectionTester:: 909 MutableUnknownFieldsOfMapFieldsViaReflection(Message* message) { 910 const Reflection* reflection = message->GetReflection(); 911 Message* sub_message = NULL; 912 913 sub_message = reflection->AddMessage(message, F("map_int32_int32")); 914 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 915 NULL); 916 sub_message = reflection->AddMessage(message, F("map_int64_int64")); 917 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 918 NULL); 919 sub_message = reflection->AddMessage(message, F("map_uint32_uint32")); 920 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 921 NULL); 922 sub_message = reflection->AddMessage(message, F("map_uint64_uint64")); 923 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 924 NULL); 925 sub_message = reflection->AddMessage(message, F("map_sint32_sint32")); 926 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 927 NULL); 928 sub_message = reflection->AddMessage(message, F("map_sint64_sint64")); 929 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 930 NULL); 931 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32")); 932 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 933 NULL); 934 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64")); 935 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 936 NULL); 937 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32")); 938 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 939 NULL); 940 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64")); 941 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 942 NULL); 943 sub_message = reflection->AddMessage(message, F("map_int32_float")); 944 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 945 NULL); 946 sub_message = reflection->AddMessage(message, F("map_int32_double")); 947 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 948 NULL); 949 sub_message = reflection->AddMessage(message, F("map_bool_bool")); 950 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 951 NULL); 952 sub_message = reflection->AddMessage(message, F("map_string_string")); 953 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 954 NULL); 955 sub_message = reflection->AddMessage(message, F("map_int32_bytes")); 956 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 957 NULL); 958 sub_message = reflection->AddMessage(message, F("map_int32_enum")); 959 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 960 NULL); 961 sub_message = reflection->AddMessage(message, F("map_int32_foreign_message")); 962 EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) != 963 NULL); 964 } 965 966 void MapReflectionTester::ExpectMapFieldsSetViaReflection( 967 const Message& message) { 968 string scratch; 969 const Reflection* reflection = message.GetReflection(); 970 const Message* sub_message; 971 MapKey map_key; 972 973 // ----------------------------------------------------------------- 974 975 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_int32"))); 976 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int64_int64"))); 977 ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint32_uint32"))); 978 ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint64_uint64"))); 979 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint32_sint32"))); 980 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint64_sint64"))); 981 ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed32_fixed32"))); 982 ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed64_fixed64"))); 983 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed32_sfixed32"))); 984 ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed64_sfixed64"))); 985 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_float"))); 986 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_double"))); 987 ASSERT_EQ(2, reflection->FieldSize(message, F("map_bool_bool"))); 988 ASSERT_EQ(2, reflection->FieldSize(message, F("map_string_string"))); 989 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_bytes"))); 990 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_enum"))); 991 ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_foreign_message"))); 992 993 { 994 std::map<int32, int32> map; 995 map[0] = 0; 996 map[1] = 1; 997 for (int i = 0; i < 2; i++) { 998 // Check with RepeatedField Reflection 999 sub_message = 1000 &reflection->GetRepeatedMessage(message, F("map_int32_int32"), i); 1001 int32 key = sub_message->GetReflection()->GetInt32( 1002 *sub_message, map_int32_int32_key_); 1003 int32 val = sub_message->GetReflection()->GetInt32( 1004 *sub_message, map_int32_int32_val_); 1005 EXPECT_EQ(map[key], val); 1006 // Check with Map Reflection 1007 map_key.SetInt32Value(key); 1008 EXPECT_TRUE(reflection->ContainsMapKey( 1009 message, F("map_int32_int32"), map_key)); 1010 } 1011 } 1012 { 1013 std::map<int64, int64> map; 1014 map[0] = 0; 1015 map[1] = 1; 1016 for (int i = 0; i < 2; i++) { 1017 // Check with RepeatedField Reflection 1018 sub_message = 1019 &reflection->GetRepeatedMessage(message, F("map_int64_int64"), i); 1020 int64 key = sub_message->GetReflection()->GetInt64( 1021 *sub_message, map_int64_int64_key_); 1022 int64 val = sub_message->GetReflection()->GetInt64( 1023 *sub_message, map_int64_int64_val_); 1024 EXPECT_EQ(map[key], val); 1025 // Check with Map Reflection 1026 map_key.SetInt64Value(key); 1027 EXPECT_TRUE(reflection->ContainsMapKey( 1028 message, F("map_int64_int64"), map_key)); 1029 } 1030 } 1031 { 1032 std::map<uint32, uint32> map; 1033 map[0] = 0; 1034 map[1] = 1; 1035 for (int i = 0; i < 2; i++) { 1036 // Check with RepeatedField Reflection 1037 sub_message = 1038 &reflection->GetRepeatedMessage(message, F("map_uint32_uint32"), i); 1039 uint32 key = sub_message->GetReflection()->GetUInt32( 1040 *sub_message, map_uint32_uint32_key_); 1041 uint32 val = sub_message->GetReflection()->GetUInt32( 1042 *sub_message, map_uint32_uint32_val_); 1043 EXPECT_EQ(map[key], val); 1044 // Check with Map Reflection 1045 map_key.SetUInt32Value(key); 1046 EXPECT_TRUE(reflection->ContainsMapKey( 1047 message, F("map_uint32_uint32"), map_key)); 1048 } 1049 } 1050 { 1051 std::map<uint64, uint64> map; 1052 map[0] = 0; 1053 map[1] = 1; 1054 for (int i = 0; i < 2; i++) { 1055 sub_message = 1056 &reflection->GetRepeatedMessage(message, F("map_uint64_uint64"), i); 1057 uint64 key = sub_message->GetReflection()->GetUInt64( 1058 *sub_message, map_uint64_uint64_key_); 1059 uint64 val = sub_message->GetReflection()->GetUInt64( 1060 *sub_message, map_uint64_uint64_val_); 1061 EXPECT_EQ(map[key], val); 1062 // Check with Map Reflection 1063 map_key.SetUInt64Value(key); 1064 EXPECT_TRUE(reflection->ContainsMapKey( 1065 message, F("map_uint64_uint64"), map_key)); 1066 } 1067 } 1068 { 1069 std::map<int32, int32> map; 1070 map[0] = 0; 1071 map[1] = 1; 1072 for (int i = 0; i < 2; i++) { 1073 sub_message = 1074 &reflection->GetRepeatedMessage(message, F("map_sint32_sint32"), i); 1075 int32 key = sub_message->GetReflection()->GetInt32( 1076 *sub_message, map_sint32_sint32_key_); 1077 int32 val = sub_message->GetReflection()->GetInt32( 1078 *sub_message, map_sint32_sint32_val_); 1079 EXPECT_EQ(map[key], val); 1080 // Check with Map Reflection 1081 map_key.SetInt32Value(key); 1082 EXPECT_EQ(true, reflection->ContainsMapKey( 1083 message, F("map_sint32_sint32"), map_key)); 1084 } 1085 } 1086 { 1087 std::map<int64, int64> map; 1088 map[0] = 0; 1089 map[1] = 1; 1090 for (int i = 0; i < 2; i++) { 1091 sub_message = 1092 &reflection->GetRepeatedMessage(message, F("map_sint64_sint64"), i); 1093 int64 key = sub_message->GetReflection()->GetInt64( 1094 *sub_message, map_sint64_sint64_key_); 1095 int64 val = sub_message->GetReflection()->GetInt64( 1096 *sub_message, map_sint64_sint64_val_); 1097 EXPECT_EQ(map[key], val); 1098 // Check with Map Reflection 1099 map_key.SetInt64Value(key); 1100 EXPECT_EQ(true, reflection->ContainsMapKey( 1101 message, F("map_sint64_sint64"), map_key)); 1102 } 1103 } 1104 { 1105 std::map<uint32, uint32> map; 1106 map[0] = 0; 1107 map[1] = 1; 1108 for (int i = 0; i < 2; i++) { 1109 sub_message = 1110 &reflection->GetRepeatedMessage(message, F("map_fixed32_fixed32"), i); 1111 uint32 key = sub_message->GetReflection()->GetUInt32( 1112 *sub_message, map_fixed32_fixed32_key_); 1113 uint32 val = sub_message->GetReflection()->GetUInt32( 1114 *sub_message, map_fixed32_fixed32_val_); 1115 EXPECT_EQ(map[key], val); 1116 // Check with Map Reflection 1117 map_key.SetUInt32Value(key); 1118 EXPECT_EQ(true, reflection->ContainsMapKey( 1119 message, F("map_fixed32_fixed32"), map_key)); 1120 } 1121 } 1122 { 1123 std::map<uint64, uint64> map; 1124 map[0] = 0; 1125 map[1] = 1; 1126 for (int i = 0; i < 2; i++) { 1127 sub_message = 1128 &reflection->GetRepeatedMessage(message, F("map_fixed64_fixed64"), i); 1129 uint64 key = sub_message->GetReflection()->GetUInt64( 1130 *sub_message, map_fixed64_fixed64_key_); 1131 uint64 val = sub_message->GetReflection()->GetUInt64( 1132 *sub_message, map_fixed64_fixed64_val_); 1133 EXPECT_EQ(map[key], val); 1134 // Check with Map Reflection 1135 map_key.SetUInt64Value(key); 1136 EXPECT_EQ(true, reflection->ContainsMapKey( 1137 message, F("map_fixed64_fixed64"), map_key)); 1138 } 1139 } 1140 { 1141 std::map<int32, int32> map; 1142 map[0] = 0; 1143 map[1] = 1; 1144 for (int i = 0; i < 2; i++) { 1145 sub_message = &reflection->GetRepeatedMessage( 1146 message, F("map_sfixed32_sfixed32"), i); 1147 int32 key = sub_message->GetReflection()->GetInt32( 1148 *sub_message, map_sfixed32_sfixed32_key_); 1149 int32 val = sub_message->GetReflection()->GetInt32( 1150 *sub_message, map_sfixed32_sfixed32_val_); 1151 EXPECT_EQ(map[key], val); 1152 // Check with Map Reflection 1153 map_key.SetInt32Value(key); 1154 EXPECT_EQ(true, reflection->ContainsMapKey( 1155 message, F("map_sfixed32_sfixed32"), map_key)); 1156 } 1157 } 1158 { 1159 std::map<int64, int64> map; 1160 map[0] = 0; 1161 map[1] = 1; 1162 for (int i = 0; i < 2; i++) { 1163 sub_message = &reflection->GetRepeatedMessage( 1164 message, F("map_sfixed64_sfixed64"), i); 1165 int64 key = sub_message->GetReflection()->GetInt64( 1166 *sub_message, map_sfixed64_sfixed64_key_); 1167 int64 val = sub_message->GetReflection()->GetInt64( 1168 *sub_message, map_sfixed64_sfixed64_val_); 1169 EXPECT_EQ(map[key], val); 1170 // Check with Map Reflection 1171 map_key.SetInt64Value(key); 1172 EXPECT_EQ(true, reflection->ContainsMapKey( 1173 message, F("map_sfixed64_sfixed64"), map_key)); 1174 } 1175 } 1176 { 1177 std::map<int32, float> map; 1178 map[0] = 0.0; 1179 map[1] = 1.0; 1180 for (int i = 0; i < 2; i++) { 1181 sub_message = 1182 &reflection->GetRepeatedMessage(message, F("map_int32_float"), i); 1183 int32 key = sub_message->GetReflection()->GetInt32( 1184 *sub_message, map_int32_float_key_); 1185 float val = sub_message->GetReflection()->GetFloat( 1186 *sub_message, map_int32_float_val_); 1187 EXPECT_EQ(map[key], val); 1188 // Check with Map Reflection 1189 map_key.SetInt32Value(key); 1190 EXPECT_EQ(true, reflection->ContainsMapKey( 1191 message, F("map_int32_float"), map_key)); 1192 } 1193 } 1194 { 1195 std::map<int32, double> map; 1196 map[0] = 0.0; 1197 map[1] = 1.0; 1198 for (int i = 0; i < 2; i++) { 1199 sub_message = 1200 &reflection->GetRepeatedMessage(message, F("map_int32_double"), i); 1201 int32 key = sub_message->GetReflection()->GetInt32( 1202 *sub_message, map_int32_double_key_); 1203 double val = sub_message->GetReflection()->GetDouble( 1204 *sub_message, map_int32_double_val_); 1205 EXPECT_EQ(map[key], val); 1206 // Check with Map Reflection 1207 map_key.SetInt32Value(key); 1208 EXPECT_EQ(true, reflection->ContainsMapKey( 1209 message, F("map_int32_double"), map_key)); 1210 } 1211 } 1212 { 1213 std::map<bool, bool> map; 1214 map[false] = false; 1215 map[true] = true; 1216 for (int i = 0; i < 2; i++) { 1217 sub_message = 1218 &reflection->GetRepeatedMessage(message, F("map_bool_bool"), i); 1219 bool key = sub_message->GetReflection()->GetBool( 1220 *sub_message, map_bool_bool_key_); 1221 bool val = sub_message->GetReflection()->GetBool( 1222 *sub_message, map_bool_bool_val_); 1223 EXPECT_EQ(map[key], val); 1224 // Check with Map Reflection 1225 map_key.SetBoolValue(key); 1226 EXPECT_EQ(true, reflection->ContainsMapKey( 1227 message, F("map_bool_bool"), map_key)); 1228 } 1229 } 1230 { 1231 std::map<string, string> map; 1232 map["0"] = "0"; 1233 map["1"] = "1"; 1234 for (int i = 0; i < 2; i++) { 1235 sub_message = 1236 &reflection->GetRepeatedMessage(message, F("map_string_string"), i); 1237 string key = sub_message->GetReflection()->GetString( 1238 *sub_message, map_string_string_key_); 1239 string val = sub_message->GetReflection()->GetString( 1240 *sub_message, map_string_string_val_); 1241 EXPECT_EQ(map[key], val); 1242 // Check with Map Reflection 1243 map_key.SetStringValue(key); 1244 EXPECT_EQ(true, reflection->ContainsMapKey( 1245 message, F("map_string_string"), map_key)); 1246 } 1247 } 1248 { 1249 std::map<int32, string> map; 1250 map[0] = "0"; 1251 map[1] = "1"; 1252 for (int i = 0; i < 2; i++) { 1253 sub_message = 1254 &reflection->GetRepeatedMessage(message, F("map_int32_bytes"), i); 1255 int32 key = sub_message->GetReflection()->GetInt32( 1256 *sub_message, map_int32_bytes_key_); 1257 string val = sub_message->GetReflection()->GetString( 1258 *sub_message, map_int32_bytes_val_); 1259 EXPECT_EQ(map[key], val); 1260 // Check with Map Reflection 1261 map_key.SetInt32Value(key); 1262 EXPECT_EQ(true, reflection->ContainsMapKey( 1263 message, F("map_int32_bytes"), map_key)); 1264 } 1265 } 1266 { 1267 std::map<int32, const EnumValueDescriptor*> map; 1268 map[0] = map_enum_bar_; 1269 map[1] = map_enum_baz_; 1270 for (int i = 0; i < 2; i++) { 1271 sub_message = &reflection->GetRepeatedMessage( 1272 message, F("map_int32_enum"), i); 1273 int32 key = sub_message->GetReflection()->GetInt32( 1274 *sub_message, map_int32_enum_key_); 1275 const EnumValueDescriptor* val = sub_message->GetReflection()->GetEnum( 1276 *sub_message, map_int32_enum_val_); 1277 EXPECT_EQ(map[key], val); 1278 // Check with Map Reflection 1279 map_key.SetInt32Value(key); 1280 EXPECT_EQ(true, reflection->ContainsMapKey( 1281 message, F("map_int32_enum"), map_key)); 1282 } 1283 } 1284 { 1285 std::map<int32, int32> map; 1286 map[0] = 0; 1287 map[1] = 1; 1288 for (int i = 0; i < 2; i++) { 1289 sub_message = &reflection->GetRepeatedMessage( 1290 message, F("map_int32_foreign_message"), i); 1291 int32 key = sub_message->GetReflection()->GetInt32( 1292 *sub_message, map_int32_foreign_message_key_); 1293 const Message& foreign_message = sub_message->GetReflection()->GetMessage( 1294 *sub_message, map_int32_foreign_message_val_); 1295 int32 val = foreign_message.GetReflection()->GetInt32( 1296 foreign_message, foreign_c_); 1297 EXPECT_EQ(map[key], val); 1298 // Check with Map Reflection 1299 map_key.SetInt32Value(key); 1300 EXPECT_EQ(true, reflection->ContainsMapKey( 1301 message, F("map_int32_foreign_message"), map_key)); 1302 } 1303 } 1304 } 1305 1306 void MapReflectionTester::ExpectMapFieldsSetViaReflectionIterator( 1307 Message* message) { 1308 string scratch; 1309 string serialized; 1310 const Reflection* reflection = message->GetReflection(); 1311 1312 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_int32"))); 1313 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int64_int64"))); 1314 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_uint32_uint32"))); 1315 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_uint64_uint64"))); 1316 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sint32_sint32"))); 1317 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sint64_sint64"))); 1318 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_fixed32_fixed32"))); 1319 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_fixed64_fixed64"))); 1320 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sfixed32_sfixed32"))); 1321 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sfixed64_sfixed64"))); 1322 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_float"))); 1323 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_double"))); 1324 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_bool_bool"))); 1325 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_string_string"))); 1326 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_bytes"))); 1327 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_enum"))); 1328 ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_foreign_message"))); 1329 1330 { 1331 std::map<int32, int32> map; 1332 map[0] = 0; 1333 map[1] = 1; 1334 int size = 0; 1335 for (MapIterator iter = reflection->MapBegin(message, F("map_int32_int32")); 1336 iter != reflection->MapEnd(message, F("map_int32_int32")); 1337 ++iter, ++size) { 1338 // Check const methods do not invalidate map. 1339 message->DebugString(); 1340 message->ShortDebugString(); 1341 message->SerializeToString(&serialized); 1342 message->SpaceUsed(); 1343 message->ByteSize(); 1344 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1345 iter.GetValueRef().GetInt32Value()); 1346 } 1347 EXPECT_EQ(size, 2); 1348 } 1349 { 1350 std::map<int64, int64> map; 1351 map[0] = 0; 1352 map[1] = 1; 1353 for (MapIterator iter = reflection->MapBegin(message, F("map_int64_int64")); 1354 iter != reflection->MapEnd(message, F("map_int64_int64")); ++iter) { 1355 EXPECT_EQ(map[iter.GetKey().GetInt64Value()], 1356 iter.GetValueRef().GetInt64Value()); 1357 } 1358 } 1359 { 1360 std::map<uint32, uint32> map; 1361 map[0] = 0; 1362 map[1] = 1; 1363 for (MapIterator iter = reflection->MapBegin( 1364 message, F("map_uint32_uint32")); 1365 iter != reflection->MapEnd(message, F("map_uint32_uint32")); 1366 ++iter) { 1367 EXPECT_EQ(map[iter.GetKey().GetUInt32Value()], 1368 iter.GetValueRef().GetUInt32Value()); 1369 } 1370 } 1371 { 1372 std::map<uint64, uint64> map; 1373 map[0] = 0; 1374 map[1] = 1; 1375 for (MapIterator iter = reflection->MapBegin( 1376 message, F("map_uint64_uint64")); 1377 iter != reflection->MapEnd(message, F("map_uint64_uint64")); 1378 ++iter) { 1379 EXPECT_EQ(map[iter.GetKey().GetUInt64Value()], 1380 iter.GetValueRef().GetUInt64Value()); 1381 } 1382 } 1383 { 1384 std::map<int32, int32> map; 1385 map[0] = 0; 1386 map[1] = 1; 1387 for (MapIterator iter = reflection->MapBegin( 1388 message, F("map_sint32_sint32")); 1389 iter != reflection->MapEnd(message, F("map_sint32_sint32")); 1390 ++iter) { 1391 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1392 iter.GetValueRef().GetInt32Value()); 1393 } 1394 } 1395 { 1396 std::map<int64, int64> map; 1397 map[0] = 0; 1398 map[1] = 1; 1399 for (MapIterator iter = reflection->MapBegin( 1400 message, F("map_sint64_sint64")); 1401 iter != reflection->MapEnd(message, F("map_sint64_sint64")); ++iter) { 1402 EXPECT_EQ(map[iter.GetKey().GetInt64Value()], 1403 iter.GetValueRef().GetInt64Value()); 1404 } 1405 } 1406 { 1407 std::map<uint32, uint32> map; 1408 map[0] = 0; 1409 map[1] = 1; 1410 for (MapIterator iter = reflection->MapBegin( 1411 message, F("map_fixed32_fixed32")); 1412 iter != reflection->MapEnd(message, F("map_fixed32_fixed32")); 1413 ++iter) { 1414 EXPECT_EQ(map[iter.GetKey().GetUInt32Value()], 1415 iter.GetValueRef().GetUInt32Value()); 1416 } 1417 } 1418 { 1419 std::map<uint64, uint64> map; 1420 map[0] = 0; 1421 map[1] = 1; 1422 for (MapIterator iter = reflection->MapBegin( 1423 message, F("map_fixed64_fixed64")); 1424 iter != reflection->MapEnd(message, F("map_fixed64_fixed64")); 1425 ++iter) { 1426 EXPECT_EQ(map[iter.GetKey().GetUInt64Value()], 1427 iter.GetValueRef().GetUInt64Value()); 1428 } 1429 } 1430 { 1431 std::map<int32, int32> map; 1432 map[0] = 0; 1433 map[1] = 1; 1434 for (MapIterator iter = reflection->MapBegin( 1435 message, F("map_sfixed32_sfixed32")); 1436 iter != reflection->MapEnd(message, F("map_sfixed32_sfixed32")); 1437 ++iter) { 1438 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1439 iter.GetValueRef().GetInt32Value()); 1440 } 1441 } 1442 { 1443 std::map<int32, float> map; 1444 map[0] = 0.0; 1445 map[1] = 1.0; 1446 for (MapIterator iter = reflection->MapBegin(message, F("map_int32_float")); 1447 iter != reflection->MapEnd(message, F("map_int32_float")); ++iter) { 1448 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1449 iter.GetValueRef().GetFloatValue()); 1450 } 1451 } 1452 { 1453 std::map<int32, double> map; 1454 map[0] = 0.0; 1455 map[1] = 1.0; 1456 for (MapIterator iter = reflection->MapBegin( 1457 message, F("map_int32_double")); 1458 iter != reflection->MapEnd(message, F("map_int32_double")); ++iter) { 1459 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1460 iter.GetValueRef().GetDoubleValue()); 1461 } 1462 } 1463 { 1464 std::map<bool, bool> map; 1465 map[false] = false; 1466 map[true] = true; 1467 for (MapIterator iter = reflection->MapBegin(message, F("map_bool_bool")); 1468 iter != reflection->MapEnd(message, F("map_bool_bool")); ++iter) { 1469 EXPECT_EQ(map[iter.GetKey().GetBoolValue()], 1470 iter.GetValueRef().GetBoolValue()); 1471 } 1472 } 1473 { 1474 std::map<string, string> map; 1475 map["0"] = "0"; 1476 map["1"] = "1"; 1477 int size = 0; 1478 for (MapIterator iter = reflection->MapBegin( 1479 message, F("map_string_string")); 1480 iter != reflection->MapEnd(message, F("map_string_string")); 1481 ++iter, ++size) { 1482 // Check const methods do not invalidate map. 1483 message->DebugString(); 1484 message->ShortDebugString(); 1485 message->SerializeToString(&serialized); 1486 message->SpaceUsed(); 1487 message->ByteSize(); 1488 EXPECT_EQ(map[iter.GetKey().GetStringValue()], 1489 iter.GetValueRef().GetStringValue()); 1490 } 1491 EXPECT_EQ(size, 2); 1492 } 1493 { 1494 std::map<int32, string> map; 1495 map[0] = "0"; 1496 map[1] = "1"; 1497 for (MapIterator iter = reflection->MapBegin(message, F("map_int32_bytes")); 1498 iter != reflection->MapEnd(message, F("map_int32_bytes")); ++iter) { 1499 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1500 iter.GetValueRef().GetStringValue()); 1501 } 1502 } 1503 { 1504 std::map<int32, const EnumValueDescriptor*> map; 1505 map[0] = map_enum_bar_; 1506 map[1] = map_enum_baz_; 1507 for (MapIterator iter = reflection->MapBegin(message, F("map_int32_enum")); 1508 iter != reflection->MapEnd(message, F("map_int32_enum")); ++iter) { 1509 EXPECT_EQ(map[iter.GetKey().GetInt32Value()]->number(), 1510 iter.GetValueRef().GetEnumValue()); 1511 } 1512 } 1513 { 1514 std::map<int32, int32> map; 1515 map[0] = 0; 1516 map[1] = 1; 1517 int size = 0; 1518 for (MapIterator iter = reflection->MapBegin( 1519 message, F("map_int32_foreign_message")); 1520 iter != reflection->MapEnd(message, F("map_int32_foreign_message")); 1521 ++iter, ++size) { 1522 // Check const methods do not invalidate map. 1523 message->DebugString(); 1524 message->ShortDebugString(); 1525 message->SerializeToString(&serialized); 1526 message->SpaceUsed(); 1527 message->ByteSize(); 1528 const Message& sub_message = iter.GetValueRef().GetMessageValue(); 1529 EXPECT_EQ(map[iter.GetKey().GetInt32Value()], 1530 sub_message.GetReflection()->GetInt32(sub_message, foreign_c_)); 1531 } 1532 EXPECT_EQ(size, 2); 1533 } 1534 } 1535 1536 void MapReflectionTester::ExpectClearViaReflection( 1537 const Message& message) { 1538 const Reflection* reflection = message.GetReflection(); 1539 // Map fields are empty. 1540 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_int32"))); 1541 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int64_int64"))); 1542 EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint32_uint32"))); 1543 EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint64_uint64"))); 1544 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint32_sint32"))); 1545 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint64_sint64"))); 1546 EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed32_fixed32"))); 1547 EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed64_fixed64"))); 1548 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed32_sfixed32"))); 1549 EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed64_sfixed64"))); 1550 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_float"))); 1551 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_double"))); 1552 EXPECT_EQ(0, reflection->FieldSize(message, F("map_bool_bool"))); 1553 EXPECT_EQ(0, reflection->FieldSize(message, F("map_string_string"))); 1554 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_bytes"))); 1555 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_enum"))); 1556 EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_foreign_message"))); 1557 } 1558 1559 void MapReflectionTester::ExpectClearViaReflectionIterator( 1560 Message* message) { 1561 const Reflection* reflection = message->GetReflection(); 1562 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_int32")) == 1563 reflection->MapEnd(message, F("map_int32_int32"))); 1564 EXPECT_TRUE(reflection->MapBegin(message, F("map_int64_int64")) == 1565 reflection->MapEnd(message, F("map_int64_int64"))); 1566 EXPECT_TRUE(reflection->MapBegin(message, F("map_uint32_uint32")) == 1567 reflection->MapEnd(message, F("map_uint32_uint32"))); 1568 EXPECT_TRUE(reflection->MapBegin(message, F("map_uint64_uint64")) == 1569 reflection->MapEnd(message, F("map_uint64_uint64"))); 1570 EXPECT_TRUE(reflection->MapBegin(message, F("map_sint32_sint32")) == 1571 reflection->MapEnd(message, F("map_sint32_sint32"))); 1572 EXPECT_TRUE(reflection->MapBegin(message, F("map_sint64_sint64")) == 1573 reflection->MapEnd(message, F("map_sint64_sint64"))); 1574 EXPECT_TRUE(reflection->MapBegin(message, F("map_fixed32_fixed32")) == 1575 reflection->MapEnd(message, F("map_fixed32_fixed32"))); 1576 EXPECT_TRUE(reflection->MapBegin(message, F("map_fixed64_fixed64")) == 1577 reflection->MapEnd(message, F("map_fixed64_fixed64"))); 1578 EXPECT_TRUE(reflection->MapBegin(message, F("map_sfixed32_sfixed32")) == 1579 reflection->MapEnd(message, F("map_sfixed32_sfixed32"))); 1580 EXPECT_TRUE(reflection->MapBegin(message, F("map_sfixed64_sfixed64")) == 1581 reflection->MapEnd(message, F("map_sfixed64_sfixed64"))); 1582 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_float")) == 1583 reflection->MapEnd(message, F("map_int32_float"))); 1584 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_double")) == 1585 reflection->MapEnd(message, F("map_int32_double"))); 1586 EXPECT_TRUE(reflection->MapBegin(message, F("map_bool_bool")) == 1587 reflection->MapEnd(message, F("map_bool_bool"))); 1588 EXPECT_TRUE(reflection->MapBegin(message, F("map_string_string")) == 1589 reflection->MapEnd(message, F("map_string_string"))); 1590 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_bytes")) == 1591 reflection->MapEnd(message, F("map_int32_bytes"))); 1592 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_enum")) == 1593 reflection->MapEnd(message, F("map_int32_enum"))); 1594 EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_foreign_message")) == 1595 reflection->MapEnd(message, F("map_int32_foreign_message"))); 1596 } 1597 1598 void MapReflectionTester::ExpectMapEntryClearViaReflection( 1599 Message* message) { 1600 const Reflection* reflection = message->GetReflection(); 1601 const Message* sub_message; 1602 1603 { 1604 const FieldDescriptor* descriptor = F("map_int32_int32"); 1605 const FieldDescriptor* key_descriptor = 1606 descriptor->message_type()->FindFieldByName("key"); 1607 const FieldDescriptor* value_descriptor = 1608 descriptor->message_type()->FindFieldByName("value"); 1609 sub_message = reflection->AddMessage(message, F("map_int32_int32")); 1610 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1611 key_descriptor)); 1612 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1613 value_descriptor)); 1614 } 1615 { 1616 const FieldDescriptor* descriptor = F("map_int64_int64"); 1617 const FieldDescriptor* key_descriptor = 1618 descriptor->message_type()->FindFieldByName("key"); 1619 const FieldDescriptor* value_descriptor = 1620 descriptor->message_type()->FindFieldByName("value"); 1621 sub_message = reflection->AddMessage(message, F("map_int64_int64")); 1622 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1623 key_descriptor)); 1624 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1625 value_descriptor)); 1626 } 1627 { 1628 const FieldDescriptor* descriptor = F("map_uint32_uint32"); 1629 const FieldDescriptor* key_descriptor = 1630 descriptor->message_type()->FindFieldByName("key"); 1631 const FieldDescriptor* value_descriptor = 1632 descriptor->message_type()->FindFieldByName("value"); 1633 sub_message = reflection->AddMessage(message, F("map_uint32_uint32")); 1634 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message, 1635 key_descriptor)); 1636 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message, 1637 value_descriptor)); 1638 } 1639 { 1640 const FieldDescriptor* descriptor = F("map_uint64_uint64"); 1641 const FieldDescriptor* key_descriptor = 1642 descriptor->message_type()->FindFieldByName("key"); 1643 const FieldDescriptor* value_descriptor = 1644 descriptor->message_type()->FindFieldByName("value"); 1645 sub_message = reflection->AddMessage(message, F("map_uint64_uint64")); 1646 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message, 1647 key_descriptor)); 1648 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message, 1649 value_descriptor)); 1650 } 1651 { 1652 const FieldDescriptor* descriptor = F("map_sint32_sint32"); 1653 const FieldDescriptor* key_descriptor = 1654 descriptor->message_type()->FindFieldByName("key"); 1655 const FieldDescriptor* value_descriptor = 1656 descriptor->message_type()->FindFieldByName("value"); 1657 sub_message = reflection->AddMessage(message, F("map_sint32_sint32")); 1658 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1659 key_descriptor)); 1660 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1661 value_descriptor)); 1662 } 1663 { 1664 const FieldDescriptor* descriptor = F("map_sint64_sint64"); 1665 const FieldDescriptor* key_descriptor = 1666 descriptor->message_type()->FindFieldByName("key"); 1667 const FieldDescriptor* value_descriptor = 1668 descriptor->message_type()->FindFieldByName("value"); 1669 sub_message = reflection->AddMessage(message, F("map_sint64_sint64")); 1670 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1671 key_descriptor)); 1672 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1673 value_descriptor)); 1674 } 1675 { 1676 const FieldDescriptor* descriptor = F("map_fixed32_fixed32"); 1677 const FieldDescriptor* key_descriptor = 1678 descriptor->message_type()->FindFieldByName("key"); 1679 const FieldDescriptor* value_descriptor = 1680 descriptor->message_type()->FindFieldByName("value"); 1681 sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32")); 1682 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message, 1683 key_descriptor)); 1684 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt32(*sub_message, 1685 value_descriptor)); 1686 } 1687 { 1688 const FieldDescriptor* descriptor = F("map_fixed64_fixed64"); 1689 const FieldDescriptor* key_descriptor = 1690 descriptor->message_type()->FindFieldByName("key"); 1691 const FieldDescriptor* value_descriptor = 1692 descriptor->message_type()->FindFieldByName("value"); 1693 sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64")); 1694 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message, 1695 key_descriptor)); 1696 EXPECT_EQ(0, sub_message->GetReflection()->GetUInt64(*sub_message, 1697 value_descriptor)); 1698 } 1699 { 1700 const FieldDescriptor* descriptor = F("map_sfixed32_sfixed32"); 1701 const FieldDescriptor* key_descriptor = 1702 descriptor->message_type()->FindFieldByName("key"); 1703 const FieldDescriptor* value_descriptor = 1704 descriptor->message_type()->FindFieldByName("value"); 1705 sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32")); 1706 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1707 key_descriptor)); 1708 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1709 value_descriptor)); 1710 } 1711 { 1712 const FieldDescriptor* descriptor = F("map_sfixed64_sfixed64"); 1713 const FieldDescriptor* key_descriptor = 1714 descriptor->message_type()->FindFieldByName("key"); 1715 const FieldDescriptor* value_descriptor = 1716 descriptor->message_type()->FindFieldByName("value"); 1717 sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64")); 1718 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1719 key_descriptor)); 1720 EXPECT_EQ(0, sub_message->GetReflection()->GetInt64(*sub_message, 1721 value_descriptor)); 1722 } 1723 { 1724 const FieldDescriptor* descriptor = F("map_int32_float"); 1725 const FieldDescriptor* key_descriptor = 1726 descriptor->message_type()->FindFieldByName("key"); 1727 const FieldDescriptor* value_descriptor = 1728 descriptor->message_type()->FindFieldByName("value"); 1729 sub_message = reflection->AddMessage(message, F("map_int32_float")); 1730 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1731 key_descriptor)); 1732 EXPECT_EQ(0, sub_message->GetReflection()->GetFloat(*sub_message, 1733 value_descriptor)); 1734 } 1735 { 1736 const FieldDescriptor* descriptor = F("map_int32_double"); 1737 const FieldDescriptor* key_descriptor = 1738 descriptor->message_type()->FindFieldByName("key"); 1739 const FieldDescriptor* value_descriptor = 1740 descriptor->message_type()->FindFieldByName("value"); 1741 sub_message = reflection->AddMessage(message, F("map_int32_double")); 1742 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1743 key_descriptor)); 1744 EXPECT_EQ(0, sub_message->GetReflection()->GetDouble(*sub_message, 1745 value_descriptor)); 1746 } 1747 { 1748 const FieldDescriptor* descriptor = F("map_bool_bool"); 1749 const FieldDescriptor* key_descriptor = 1750 descriptor->message_type()->FindFieldByName("key"); 1751 const FieldDescriptor* value_descriptor = 1752 descriptor->message_type()->FindFieldByName("value"); 1753 sub_message = reflection->AddMessage(message, F("map_bool_bool")); 1754 EXPECT_EQ(false, sub_message->GetReflection()->GetBool(*sub_message, 1755 key_descriptor)); 1756 EXPECT_EQ(false, sub_message->GetReflection()->GetBool(*sub_message, 1757 value_descriptor)); 1758 } 1759 { 1760 const FieldDescriptor* descriptor = F("map_string_string"); 1761 const FieldDescriptor* key_descriptor = 1762 descriptor->message_type()->FindFieldByName("key"); 1763 const FieldDescriptor* value_descriptor = 1764 descriptor->message_type()->FindFieldByName("value"); 1765 sub_message = reflection->AddMessage(message, F("map_string_string")); 1766 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message, 1767 key_descriptor)); 1768 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message, 1769 value_descriptor)); 1770 } 1771 { 1772 const FieldDescriptor* descriptor = F("map_int32_bytes"); 1773 const FieldDescriptor* key_descriptor = 1774 descriptor->message_type()->FindFieldByName("key"); 1775 const FieldDescriptor* value_descriptor = 1776 descriptor->message_type()->FindFieldByName("value"); 1777 sub_message = reflection->AddMessage(message, F("map_int32_bytes")); 1778 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1779 key_descriptor)); 1780 EXPECT_EQ("", sub_message->GetReflection()->GetString(*sub_message, 1781 value_descriptor)); 1782 } 1783 { 1784 const FieldDescriptor* descriptor = F("map_int32_enum"); 1785 const FieldDescriptor* key_descriptor = 1786 descriptor->message_type()->FindFieldByName("key"); 1787 const FieldDescriptor* value_descriptor = 1788 descriptor->message_type()->FindFieldByName("value"); 1789 sub_message = reflection->AddMessage(message, F("map_int32_enum")); 1790 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, 1791 key_descriptor)); 1792 EXPECT_EQ(0, sub_message->GetReflection() 1793 ->GetEnum(*sub_message, value_descriptor) 1794 ->number()); 1795 } 1796 // Map using message as value has been tested in other place. Thus, we don't 1797 // test it here. 1798 } 1799 1800 } // namespace protobuf 1801 } // namespace google 1802
