1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // http://code.google.com/p/protobuf/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 // Author: kenton (at) google.com (Kenton Varda) 32 // Based on original Protocol Buffers design by 33 // Sanjay Ghemawat, Jeff Dean, and others. 34 35 #ifdef _WIN32 36 // Verify that #including windows.h does not break anything (e.g. because 37 // windows.h #defines GetMessage() as a macro). 38 #include <windows.h> 39 #endif 40 41 #include <google/protobuf/test_util.h> 42 #include <google/protobuf/descriptor.h> 43 #include <google/protobuf/message.h> 44 45 #include <google/protobuf/stubs/common.h> 46 #include <google/protobuf/testing/googletest.h> 47 #include <gtest/gtest.h> 48 49 namespace google { 50 namespace protobuf { 51 52 void TestUtil::SetAllFields(unittest::TestAllTypes* message) { 53 message->set_optional_int32 (101); 54 message->set_optional_int64 (102); 55 message->set_optional_uint32 (103); 56 message->set_optional_uint64 (104); 57 message->set_optional_sint32 (105); 58 message->set_optional_sint64 (106); 59 message->set_optional_fixed32 (107); 60 message->set_optional_fixed64 (108); 61 message->set_optional_sfixed32(109); 62 message->set_optional_sfixed64(110); 63 message->set_optional_float (111); 64 message->set_optional_double (112); 65 message->set_optional_bool (true); 66 message->set_optional_string ("115"); 67 message->set_optional_bytes ("116"); 68 69 message->mutable_optionalgroup ()->set_a(117); 70 message->mutable_optional_nested_message ()->set_bb(118); 71 message->mutable_optional_foreign_message()->set_c(119); 72 message->mutable_optional_import_message ()->set_d(120); 73 74 message->set_optional_nested_enum (unittest::TestAllTypes::BAZ); 75 message->set_optional_foreign_enum(unittest::FOREIGN_BAZ ); 76 message->set_optional_import_enum (unittest_import::IMPORT_BAZ); 77 78 // StringPiece and Cord fields are only accessible via reflection in the 79 // open source release; see comments in compiler/cpp/string_field.cc. 80 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 81 message->GetReflection()->SetString( 82 message, 83 message->GetDescriptor()->FindFieldByName("optional_string_piece"), 84 "124"); 85 message->GetReflection()->SetString( 86 message, 87 message->GetDescriptor()->FindFieldByName("optional_cord"), 88 "125"); 89 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 90 91 // ----------------------------------------------------------------- 92 93 message->add_repeated_int32 (201); 94 message->add_repeated_int64 (202); 95 message->add_repeated_uint32 (203); 96 message->add_repeated_uint64 (204); 97 message->add_repeated_sint32 (205); 98 message->add_repeated_sint64 (206); 99 message->add_repeated_fixed32 (207); 100 message->add_repeated_fixed64 (208); 101 message->add_repeated_sfixed32(209); 102 message->add_repeated_sfixed64(210); 103 message->add_repeated_float (211); 104 message->add_repeated_double (212); 105 message->add_repeated_bool (true); 106 message->add_repeated_string ("215"); 107 message->add_repeated_bytes ("216"); 108 109 message->add_repeatedgroup ()->set_a(217); 110 message->add_repeated_nested_message ()->set_bb(218); 111 message->add_repeated_foreign_message()->set_c(219); 112 message->add_repeated_import_message ()->set_d(220); 113 114 message->add_repeated_nested_enum (unittest::TestAllTypes::BAR); 115 message->add_repeated_foreign_enum(unittest::FOREIGN_BAR ); 116 message->add_repeated_import_enum (unittest_import::IMPORT_BAR); 117 118 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 119 message->GetReflection()->AddString( 120 message, 121 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 122 "224"); 123 message->GetReflection()->AddString( 124 message, 125 message->GetDescriptor()->FindFieldByName("repeated_cord"), 126 "225"); 127 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 128 129 // Add a second one of each field. 130 message->add_repeated_int32 (301); 131 message->add_repeated_int64 (302); 132 message->add_repeated_uint32 (303); 133 message->add_repeated_uint64 (304); 134 message->add_repeated_sint32 (305); 135 message->add_repeated_sint64 (306); 136 message->add_repeated_fixed32 (307); 137 message->add_repeated_fixed64 (308); 138 message->add_repeated_sfixed32(309); 139 message->add_repeated_sfixed64(310); 140 message->add_repeated_float (311); 141 message->add_repeated_double (312); 142 message->add_repeated_bool (false); 143 message->add_repeated_string ("315"); 144 message->add_repeated_bytes ("316"); 145 146 message->add_repeatedgroup ()->set_a(317); 147 message->add_repeated_nested_message ()->set_bb(318); 148 message->add_repeated_foreign_message()->set_c(319); 149 message->add_repeated_import_message ()->set_d(320); 150 151 message->add_repeated_nested_enum (unittest::TestAllTypes::BAZ); 152 message->add_repeated_foreign_enum(unittest::FOREIGN_BAZ ); 153 message->add_repeated_import_enum (unittest_import::IMPORT_BAZ); 154 155 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 156 message->GetReflection()->AddString( 157 message, 158 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 159 "324"); 160 message->GetReflection()->AddString( 161 message, 162 message->GetDescriptor()->FindFieldByName("repeated_cord"), 163 "325"); 164 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 165 166 // ----------------------------------------------------------------- 167 168 message->set_default_int32 (401); 169 message->set_default_int64 (402); 170 message->set_default_uint32 (403); 171 message->set_default_uint64 (404); 172 message->set_default_sint32 (405); 173 message->set_default_sint64 (406); 174 message->set_default_fixed32 (407); 175 message->set_default_fixed64 (408); 176 message->set_default_sfixed32(409); 177 message->set_default_sfixed64(410); 178 message->set_default_float (411); 179 message->set_default_double (412); 180 message->set_default_bool (false); 181 message->set_default_string ("415"); 182 message->set_default_bytes ("416"); 183 184 message->set_default_nested_enum (unittest::TestAllTypes::FOO); 185 message->set_default_foreign_enum(unittest::FOREIGN_FOO ); 186 message->set_default_import_enum (unittest_import::IMPORT_FOO); 187 188 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 189 message->GetReflection()->SetString( 190 message, 191 message->GetDescriptor()->FindFieldByName("default_string_piece"), 192 "424"); 193 message->GetReflection()->SetString( 194 message, 195 message->GetDescriptor()->FindFieldByName("default_cord"), 196 "425"); 197 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 198 } 199 200 // ------------------------------------------------------------------- 201 202 void TestUtil::ModifyRepeatedFields(unittest::TestAllTypes* message) { 203 message->set_repeated_int32 (1, 501); 204 message->set_repeated_int64 (1, 502); 205 message->set_repeated_uint32 (1, 503); 206 message->set_repeated_uint64 (1, 504); 207 message->set_repeated_sint32 (1, 505); 208 message->set_repeated_sint64 (1, 506); 209 message->set_repeated_fixed32 (1, 507); 210 message->set_repeated_fixed64 (1, 508); 211 message->set_repeated_sfixed32(1, 509); 212 message->set_repeated_sfixed64(1, 510); 213 message->set_repeated_float (1, 511); 214 message->set_repeated_double (1, 512); 215 message->set_repeated_bool (1, true); 216 message->set_repeated_string (1, "515"); 217 message->set_repeated_bytes (1, "516"); 218 219 message->mutable_repeatedgroup (1)->set_a(517); 220 message->mutable_repeated_nested_message (1)->set_bb(518); 221 message->mutable_repeated_foreign_message(1)->set_c(519); 222 message->mutable_repeated_import_message (1)->set_d(520); 223 224 message->set_repeated_nested_enum (1, unittest::TestAllTypes::FOO); 225 message->set_repeated_foreign_enum(1, unittest::FOREIGN_FOO ); 226 message->set_repeated_import_enum (1, unittest_import::IMPORT_FOO); 227 228 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 229 message->GetReflection()->SetRepeatedString( 230 message, 231 message->GetDescriptor()->FindFieldByName("repeated_string_piece"), 232 1, "524"); 233 message->GetReflection()->SetRepeatedString( 234 message, 235 message->GetDescriptor()->FindFieldByName("repeated_cord"), 236 1, "525"); 237 #endif // !PROTOBUF_TEST_NO_DESCRIPTORS 238 } 239 240 // ------------------------------------------------------------------- 241 242 void TestUtil::ExpectAllFieldsSet(const unittest::TestAllTypes& message) { 243 EXPECT_TRUE(message.has_optional_int32 ()); 244 EXPECT_TRUE(message.has_optional_int64 ()); 245 EXPECT_TRUE(message.has_optional_uint32 ()); 246 EXPECT_TRUE(message.has_optional_uint64 ()); 247 EXPECT_TRUE(message.has_optional_sint32 ()); 248 EXPECT_TRUE(message.has_optional_sint64 ()); 249 EXPECT_TRUE(message.has_optional_fixed32 ()); 250 EXPECT_TRUE(message.has_optional_fixed64 ()); 251 EXPECT_TRUE(message.has_optional_sfixed32()); 252 EXPECT_TRUE(message.has_optional_sfixed64()); 253 EXPECT_TRUE(message.has_optional_float ()); 254 EXPECT_TRUE(message.has_optional_double ()); 255 EXPECT_TRUE(message.has_optional_bool ()); 256 EXPECT_TRUE(message.has_optional_string ()); 257 EXPECT_TRUE(message.has_optional_bytes ()); 258 259 EXPECT_TRUE(message.has_optionalgroup ()); 260 EXPECT_TRUE(message.has_optional_nested_message ()); 261 EXPECT_TRUE(message.has_optional_foreign_message()); 262 EXPECT_TRUE(message.has_optional_import_message ()); 263 264 EXPECT_TRUE(message.optionalgroup ().has_a()); 265 EXPECT_TRUE(message.optional_nested_message ().has_bb()); 266 EXPECT_TRUE(message.optional_foreign_message().has_c()); 267 EXPECT_TRUE(message.optional_import_message ().has_d()); 268 269 EXPECT_TRUE(message.has_optional_nested_enum ()); 270 EXPECT_TRUE(message.has_optional_foreign_enum()); 271 EXPECT_TRUE(message.has_optional_import_enum ()); 272 273 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 274 EXPECT_TRUE(message.has_optional_string_piece()); 275 EXPECT_TRUE(message.has_optional_cord()); 276 #endif 277 278 EXPECT_EQ(101 , message.optional_int32 ()); 279 EXPECT_EQ(102 , message.optional_int64 ()); 280 EXPECT_EQ(103 , message.optional_uint32 ()); 281 EXPECT_EQ(104 , message.optional_uint64 ()); 282 EXPECT_EQ(105 , message.optional_sint32 ()); 283 EXPECT_EQ(106 , message.optional_sint64 ()); 284 EXPECT_EQ(107 , message.optional_fixed32 ()); 285 EXPECT_EQ(108 , message.optional_fixed64 ()); 286 EXPECT_EQ(109 , message.optional_sfixed32()); 287 EXPECT_EQ(110 , message.optional_sfixed64()); 288 EXPECT_EQ(111 , message.optional_float ()); 289 EXPECT_EQ(112 , message.optional_double ()); 290 EXPECT_EQ(true , message.optional_bool ()); 291 EXPECT_EQ("115", message.optional_string ()); 292 EXPECT_EQ("116", message.optional_bytes ()); 293 294 EXPECT_EQ(117, message.optionalgroup ().a()); 295 EXPECT_EQ(118, message.optional_nested_message ().bb()); 296 EXPECT_EQ(119, message.optional_foreign_message().c()); 297 EXPECT_EQ(120, message.optional_import_message ().d()); 298 299 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.optional_nested_enum ()); 300 EXPECT_EQ(unittest::FOREIGN_BAZ , message.optional_foreign_enum()); 301 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.optional_import_enum ()); 302 303 304 // ----------------------------------------------------------------- 305 306 ASSERT_EQ(2, message.repeated_int32_size ()); 307 ASSERT_EQ(2, message.repeated_int64_size ()); 308 ASSERT_EQ(2, message.repeated_uint32_size ()); 309 ASSERT_EQ(2, message.repeated_uint64_size ()); 310 ASSERT_EQ(2, message.repeated_sint32_size ()); 311 ASSERT_EQ(2, message.repeated_sint64_size ()); 312 ASSERT_EQ(2, message.repeated_fixed32_size ()); 313 ASSERT_EQ(2, message.repeated_fixed64_size ()); 314 ASSERT_EQ(2, message.repeated_sfixed32_size()); 315 ASSERT_EQ(2, message.repeated_sfixed64_size()); 316 ASSERT_EQ(2, message.repeated_float_size ()); 317 ASSERT_EQ(2, message.repeated_double_size ()); 318 ASSERT_EQ(2, message.repeated_bool_size ()); 319 ASSERT_EQ(2, message.repeated_string_size ()); 320 ASSERT_EQ(2, message.repeated_bytes_size ()); 321 322 ASSERT_EQ(2, message.repeatedgroup_size ()); 323 ASSERT_EQ(2, message.repeated_nested_message_size ()); 324 ASSERT_EQ(2, message.repeated_foreign_message_size()); 325 ASSERT_EQ(2, message.repeated_import_message_size ()); 326 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 327 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 328 ASSERT_EQ(2, message.repeated_import_enum_size ()); 329 330 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 331 ASSERT_EQ(2, message.repeated_string_piece_size()); 332 ASSERT_EQ(2, message.repeated_cord_size()); 333 #endif 334 335 EXPECT_EQ(201 , message.repeated_int32 (0)); 336 EXPECT_EQ(202 , message.repeated_int64 (0)); 337 EXPECT_EQ(203 , message.repeated_uint32 (0)); 338 EXPECT_EQ(204 , message.repeated_uint64 (0)); 339 EXPECT_EQ(205 , message.repeated_sint32 (0)); 340 EXPECT_EQ(206 , message.repeated_sint64 (0)); 341 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 342 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 343 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 344 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 345 EXPECT_EQ(211 , message.repeated_float (0)); 346 EXPECT_EQ(212 , message.repeated_double (0)); 347 EXPECT_EQ(true , message.repeated_bool (0)); 348 EXPECT_EQ("215", message.repeated_string (0)); 349 EXPECT_EQ("216", message.repeated_bytes (0)); 350 351 EXPECT_EQ(217, message.repeatedgroup (0).a()); 352 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 353 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 354 EXPECT_EQ(220, message.repeated_import_message (0).d()); 355 356 357 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 358 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 359 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 360 361 EXPECT_EQ(301 , message.repeated_int32 (1)); 362 EXPECT_EQ(302 , message.repeated_int64 (1)); 363 EXPECT_EQ(303 , message.repeated_uint32 (1)); 364 EXPECT_EQ(304 , message.repeated_uint64 (1)); 365 EXPECT_EQ(305 , message.repeated_sint32 (1)); 366 EXPECT_EQ(306 , message.repeated_sint64 (1)); 367 EXPECT_EQ(307 , message.repeated_fixed32 (1)); 368 EXPECT_EQ(308 , message.repeated_fixed64 (1)); 369 EXPECT_EQ(309 , message.repeated_sfixed32(1)); 370 EXPECT_EQ(310 , message.repeated_sfixed64(1)); 371 EXPECT_EQ(311 , message.repeated_float (1)); 372 EXPECT_EQ(312 , message.repeated_double (1)); 373 EXPECT_EQ(false, message.repeated_bool (1)); 374 EXPECT_EQ("315", message.repeated_string (1)); 375 EXPECT_EQ("316", message.repeated_bytes (1)); 376 377 EXPECT_EQ(317, message.repeatedgroup (1).a()); 378 EXPECT_EQ(318, message.repeated_nested_message (1).bb()); 379 EXPECT_EQ(319, message.repeated_foreign_message(1).c()); 380 EXPECT_EQ(320, message.repeated_import_message (1).d()); 381 382 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (1)); 383 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(1)); 384 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (1)); 385 386 387 // ----------------------------------------------------------------- 388 389 EXPECT_TRUE(message.has_default_int32 ()); 390 EXPECT_TRUE(message.has_default_int64 ()); 391 EXPECT_TRUE(message.has_default_uint32 ()); 392 EXPECT_TRUE(message.has_default_uint64 ()); 393 EXPECT_TRUE(message.has_default_sint32 ()); 394 EXPECT_TRUE(message.has_default_sint64 ()); 395 EXPECT_TRUE(message.has_default_fixed32 ()); 396 EXPECT_TRUE(message.has_default_fixed64 ()); 397 EXPECT_TRUE(message.has_default_sfixed32()); 398 EXPECT_TRUE(message.has_default_sfixed64()); 399 EXPECT_TRUE(message.has_default_float ()); 400 EXPECT_TRUE(message.has_default_double ()); 401 EXPECT_TRUE(message.has_default_bool ()); 402 EXPECT_TRUE(message.has_default_string ()); 403 EXPECT_TRUE(message.has_default_bytes ()); 404 405 EXPECT_TRUE(message.has_default_nested_enum ()); 406 EXPECT_TRUE(message.has_default_foreign_enum()); 407 EXPECT_TRUE(message.has_default_import_enum ()); 408 409 410 EXPECT_EQ(401 , message.default_int32 ()); 411 EXPECT_EQ(402 , message.default_int64 ()); 412 EXPECT_EQ(403 , message.default_uint32 ()); 413 EXPECT_EQ(404 , message.default_uint64 ()); 414 EXPECT_EQ(405 , message.default_sint32 ()); 415 EXPECT_EQ(406 , message.default_sint64 ()); 416 EXPECT_EQ(407 , message.default_fixed32 ()); 417 EXPECT_EQ(408 , message.default_fixed64 ()); 418 EXPECT_EQ(409 , message.default_sfixed32()); 419 EXPECT_EQ(410 , message.default_sfixed64()); 420 EXPECT_EQ(411 , message.default_float ()); 421 EXPECT_EQ(412 , message.default_double ()); 422 EXPECT_EQ(false, message.default_bool ()); 423 EXPECT_EQ("415", message.default_string ()); 424 EXPECT_EQ("416", message.default_bytes ()); 425 426 EXPECT_EQ(unittest::TestAllTypes::FOO, message.default_nested_enum ()); 427 EXPECT_EQ(unittest::FOREIGN_FOO , message.default_foreign_enum()); 428 EXPECT_EQ(unittest_import::IMPORT_FOO, message.default_import_enum ()); 429 430 } 431 432 // ------------------------------------------------------------------- 433 434 void TestUtil::ExpectClear(const unittest::TestAllTypes& message) { 435 // has_blah() should initially be false for all optional fields. 436 EXPECT_FALSE(message.has_optional_int32 ()); 437 EXPECT_FALSE(message.has_optional_int64 ()); 438 EXPECT_FALSE(message.has_optional_uint32 ()); 439 EXPECT_FALSE(message.has_optional_uint64 ()); 440 EXPECT_FALSE(message.has_optional_sint32 ()); 441 EXPECT_FALSE(message.has_optional_sint64 ()); 442 EXPECT_FALSE(message.has_optional_fixed32 ()); 443 EXPECT_FALSE(message.has_optional_fixed64 ()); 444 EXPECT_FALSE(message.has_optional_sfixed32()); 445 EXPECT_FALSE(message.has_optional_sfixed64()); 446 EXPECT_FALSE(message.has_optional_float ()); 447 EXPECT_FALSE(message.has_optional_double ()); 448 EXPECT_FALSE(message.has_optional_bool ()); 449 EXPECT_FALSE(message.has_optional_string ()); 450 EXPECT_FALSE(message.has_optional_bytes ()); 451 452 EXPECT_FALSE(message.has_optionalgroup ()); 453 EXPECT_FALSE(message.has_optional_nested_message ()); 454 EXPECT_FALSE(message.has_optional_foreign_message()); 455 EXPECT_FALSE(message.has_optional_import_message ()); 456 457 EXPECT_FALSE(message.has_optional_nested_enum ()); 458 EXPECT_FALSE(message.has_optional_foreign_enum()); 459 EXPECT_FALSE(message.has_optional_import_enum ()); 460 461 EXPECT_FALSE(message.has_optional_string_piece()); 462 EXPECT_FALSE(message.has_optional_cord()); 463 464 // Optional fields without defaults are set to zero or something like it. 465 EXPECT_EQ(0 , message.optional_int32 ()); 466 EXPECT_EQ(0 , message.optional_int64 ()); 467 EXPECT_EQ(0 , message.optional_uint32 ()); 468 EXPECT_EQ(0 , message.optional_uint64 ()); 469 EXPECT_EQ(0 , message.optional_sint32 ()); 470 EXPECT_EQ(0 , message.optional_sint64 ()); 471 EXPECT_EQ(0 , message.optional_fixed32 ()); 472 EXPECT_EQ(0 , message.optional_fixed64 ()); 473 EXPECT_EQ(0 , message.optional_sfixed32()); 474 EXPECT_EQ(0 , message.optional_sfixed64()); 475 EXPECT_EQ(0 , message.optional_float ()); 476 EXPECT_EQ(0 , message.optional_double ()); 477 EXPECT_EQ(false, message.optional_bool ()); 478 EXPECT_EQ("" , message.optional_string ()); 479 EXPECT_EQ("" , message.optional_bytes ()); 480 481 // Embedded messages should also be clear. 482 EXPECT_FALSE(message.optionalgroup ().has_a()); 483 EXPECT_FALSE(message.optional_nested_message ().has_bb()); 484 EXPECT_FALSE(message.optional_foreign_message().has_c()); 485 EXPECT_FALSE(message.optional_import_message ().has_d()); 486 487 EXPECT_EQ(0, message.optionalgroup ().a()); 488 EXPECT_EQ(0, message.optional_nested_message ().bb()); 489 EXPECT_EQ(0, message.optional_foreign_message().c()); 490 EXPECT_EQ(0, message.optional_import_message ().d()); 491 492 // Enums without defaults are set to the first value in the enum. 493 EXPECT_EQ(unittest::TestAllTypes::FOO, message.optional_nested_enum ()); 494 EXPECT_EQ(unittest::FOREIGN_FOO , message.optional_foreign_enum()); 495 EXPECT_EQ(unittest_import::IMPORT_FOO, message.optional_import_enum ()); 496 497 498 // Repeated fields are empty. 499 EXPECT_EQ(0, message.repeated_int32_size ()); 500 EXPECT_EQ(0, message.repeated_int64_size ()); 501 EXPECT_EQ(0, message.repeated_uint32_size ()); 502 EXPECT_EQ(0, message.repeated_uint64_size ()); 503 EXPECT_EQ(0, message.repeated_sint32_size ()); 504 EXPECT_EQ(0, message.repeated_sint64_size ()); 505 EXPECT_EQ(0, message.repeated_fixed32_size ()); 506 EXPECT_EQ(0, message.repeated_fixed64_size ()); 507 EXPECT_EQ(0, message.repeated_sfixed32_size()); 508 EXPECT_EQ(0, message.repeated_sfixed64_size()); 509 EXPECT_EQ(0, message.repeated_float_size ()); 510 EXPECT_EQ(0, message.repeated_double_size ()); 511 EXPECT_EQ(0, message.repeated_bool_size ()); 512 EXPECT_EQ(0, message.repeated_string_size ()); 513 EXPECT_EQ(0, message.repeated_bytes_size ()); 514 515 EXPECT_EQ(0, message.repeatedgroup_size ()); 516 EXPECT_EQ(0, message.repeated_nested_message_size ()); 517 EXPECT_EQ(0, message.repeated_foreign_message_size()); 518 EXPECT_EQ(0, message.repeated_import_message_size ()); 519 EXPECT_EQ(0, message.repeated_nested_enum_size ()); 520 EXPECT_EQ(0, message.repeated_foreign_enum_size ()); 521 EXPECT_EQ(0, message.repeated_import_enum_size ()); 522 523 EXPECT_EQ(0, message.repeated_string_piece_size()); 524 EXPECT_EQ(0, message.repeated_cord_size()); 525 526 // has_blah() should also be false for all default fields. 527 EXPECT_FALSE(message.has_default_int32 ()); 528 EXPECT_FALSE(message.has_default_int64 ()); 529 EXPECT_FALSE(message.has_default_uint32 ()); 530 EXPECT_FALSE(message.has_default_uint64 ()); 531 EXPECT_FALSE(message.has_default_sint32 ()); 532 EXPECT_FALSE(message.has_default_sint64 ()); 533 EXPECT_FALSE(message.has_default_fixed32 ()); 534 EXPECT_FALSE(message.has_default_fixed64 ()); 535 EXPECT_FALSE(message.has_default_sfixed32()); 536 EXPECT_FALSE(message.has_default_sfixed64()); 537 EXPECT_FALSE(message.has_default_float ()); 538 EXPECT_FALSE(message.has_default_double ()); 539 EXPECT_FALSE(message.has_default_bool ()); 540 EXPECT_FALSE(message.has_default_string ()); 541 EXPECT_FALSE(message.has_default_bytes ()); 542 543 EXPECT_FALSE(message.has_default_nested_enum ()); 544 EXPECT_FALSE(message.has_default_foreign_enum()); 545 EXPECT_FALSE(message.has_default_import_enum ()); 546 547 548 // Fields with defaults have their default values (duh). 549 EXPECT_EQ( 41 , message.default_int32 ()); 550 EXPECT_EQ( 42 , message.default_int64 ()); 551 EXPECT_EQ( 43 , message.default_uint32 ()); 552 EXPECT_EQ( 44 , message.default_uint64 ()); 553 EXPECT_EQ(-45 , message.default_sint32 ()); 554 EXPECT_EQ( 46 , message.default_sint64 ()); 555 EXPECT_EQ( 47 , message.default_fixed32 ()); 556 EXPECT_EQ( 48 , message.default_fixed64 ()); 557 EXPECT_EQ( 49 , message.default_sfixed32()); 558 EXPECT_EQ(-50 , message.default_sfixed64()); 559 EXPECT_EQ( 51.5 , message.default_float ()); 560 EXPECT_EQ( 52e3 , message.default_double ()); 561 EXPECT_EQ(true , message.default_bool ()); 562 EXPECT_EQ("hello", message.default_string ()); 563 EXPECT_EQ("world", message.default_bytes ()); 564 565 EXPECT_EQ(unittest::TestAllTypes::BAR, message.default_nested_enum ()); 566 EXPECT_EQ(unittest::FOREIGN_BAR , message.default_foreign_enum()); 567 EXPECT_EQ(unittest_import::IMPORT_BAR, message.default_import_enum ()); 568 569 } 570 571 // ------------------------------------------------------------------- 572 573 void TestUtil::ExpectRepeatedFieldsModified( 574 const unittest::TestAllTypes& message) { 575 // ModifyRepeatedFields only sets the second repeated element of each 576 // field. In addition to verifying this, we also verify that the first 577 // element and size were *not* modified. 578 ASSERT_EQ(2, message.repeated_int32_size ()); 579 ASSERT_EQ(2, message.repeated_int64_size ()); 580 ASSERT_EQ(2, message.repeated_uint32_size ()); 581 ASSERT_EQ(2, message.repeated_uint64_size ()); 582 ASSERT_EQ(2, message.repeated_sint32_size ()); 583 ASSERT_EQ(2, message.repeated_sint64_size ()); 584 ASSERT_EQ(2, message.repeated_fixed32_size ()); 585 ASSERT_EQ(2, message.repeated_fixed64_size ()); 586 ASSERT_EQ(2, message.repeated_sfixed32_size()); 587 ASSERT_EQ(2, message.repeated_sfixed64_size()); 588 ASSERT_EQ(2, message.repeated_float_size ()); 589 ASSERT_EQ(2, message.repeated_double_size ()); 590 ASSERT_EQ(2, message.repeated_bool_size ()); 591 ASSERT_EQ(2, message.repeated_string_size ()); 592 ASSERT_EQ(2, message.repeated_bytes_size ()); 593 594 ASSERT_EQ(2, message.repeatedgroup_size ()); 595 ASSERT_EQ(2, message.repeated_nested_message_size ()); 596 ASSERT_EQ(2, message.repeated_foreign_message_size()); 597 ASSERT_EQ(2, message.repeated_import_message_size ()); 598 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 599 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 600 ASSERT_EQ(2, message.repeated_import_enum_size ()); 601 602 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 603 ASSERT_EQ(2, message.repeated_string_piece_size()); 604 ASSERT_EQ(2, message.repeated_cord_size()); 605 #endif 606 607 EXPECT_EQ(201 , message.repeated_int32 (0)); 608 EXPECT_EQ(202 , message.repeated_int64 (0)); 609 EXPECT_EQ(203 , message.repeated_uint32 (0)); 610 EXPECT_EQ(204 , message.repeated_uint64 (0)); 611 EXPECT_EQ(205 , message.repeated_sint32 (0)); 612 EXPECT_EQ(206 , message.repeated_sint64 (0)); 613 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 614 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 615 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 616 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 617 EXPECT_EQ(211 , message.repeated_float (0)); 618 EXPECT_EQ(212 , message.repeated_double (0)); 619 EXPECT_EQ(true , message.repeated_bool (0)); 620 EXPECT_EQ("215", message.repeated_string (0)); 621 EXPECT_EQ("216", message.repeated_bytes (0)); 622 623 EXPECT_EQ(217, message.repeatedgroup (0).a()); 624 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 625 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 626 EXPECT_EQ(220, message.repeated_import_message (0).d()); 627 628 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 629 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 630 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 631 632 633 // Actually verify the second (modified) elements now. 634 EXPECT_EQ(501 , message.repeated_int32 (1)); 635 EXPECT_EQ(502 , message.repeated_int64 (1)); 636 EXPECT_EQ(503 , message.repeated_uint32 (1)); 637 EXPECT_EQ(504 , message.repeated_uint64 (1)); 638 EXPECT_EQ(505 , message.repeated_sint32 (1)); 639 EXPECT_EQ(506 , message.repeated_sint64 (1)); 640 EXPECT_EQ(507 , message.repeated_fixed32 (1)); 641 EXPECT_EQ(508 , message.repeated_fixed64 (1)); 642 EXPECT_EQ(509 , message.repeated_sfixed32(1)); 643 EXPECT_EQ(510 , message.repeated_sfixed64(1)); 644 EXPECT_EQ(511 , message.repeated_float (1)); 645 EXPECT_EQ(512 , message.repeated_double (1)); 646 EXPECT_EQ(true , message.repeated_bool (1)); 647 EXPECT_EQ("515", message.repeated_string (1)); 648 EXPECT_EQ("516", message.repeated_bytes (1)); 649 650 EXPECT_EQ(517, message.repeatedgroup (1).a()); 651 EXPECT_EQ(518, message.repeated_nested_message (1).bb()); 652 EXPECT_EQ(519, message.repeated_foreign_message(1).c()); 653 EXPECT_EQ(520, message.repeated_import_message (1).d()); 654 655 EXPECT_EQ(unittest::TestAllTypes::FOO, message.repeated_nested_enum (1)); 656 EXPECT_EQ(unittest::FOREIGN_FOO , message.repeated_foreign_enum(1)); 657 EXPECT_EQ(unittest_import::IMPORT_FOO, message.repeated_import_enum (1)); 658 659 } 660 661 // ------------------------------------------------------------------- 662 663 void TestUtil::SetPackedFields(unittest::TestPackedTypes* message) { 664 message->add_packed_int32 (601); 665 message->add_packed_int64 (602); 666 message->add_packed_uint32 (603); 667 message->add_packed_uint64 (604); 668 message->add_packed_sint32 (605); 669 message->add_packed_sint64 (606); 670 message->add_packed_fixed32 (607); 671 message->add_packed_fixed64 (608); 672 message->add_packed_sfixed32(609); 673 message->add_packed_sfixed64(610); 674 message->add_packed_float (611); 675 message->add_packed_double (612); 676 message->add_packed_bool (true); 677 message->add_packed_enum (unittest::FOREIGN_BAR); 678 // add a second one of each field 679 message->add_packed_int32 (701); 680 message->add_packed_int64 (702); 681 message->add_packed_uint32 (703); 682 message->add_packed_uint64 (704); 683 message->add_packed_sint32 (705); 684 message->add_packed_sint64 (706); 685 message->add_packed_fixed32 (707); 686 message->add_packed_fixed64 (708); 687 message->add_packed_sfixed32(709); 688 message->add_packed_sfixed64(710); 689 message->add_packed_float (711); 690 message->add_packed_double (712); 691 message->add_packed_bool (false); 692 message->add_packed_enum (unittest::FOREIGN_BAZ); 693 } 694 695 void TestUtil::SetUnpackedFields(unittest::TestUnpackedTypes* message) { 696 // The values applied here must match those of SetPackedFields. 697 698 message->add_unpacked_int32 (601); 699 message->add_unpacked_int64 (602); 700 message->add_unpacked_uint32 (603); 701 message->add_unpacked_uint64 (604); 702 message->add_unpacked_sint32 (605); 703 message->add_unpacked_sint64 (606); 704 message->add_unpacked_fixed32 (607); 705 message->add_unpacked_fixed64 (608); 706 message->add_unpacked_sfixed32(609); 707 message->add_unpacked_sfixed64(610); 708 message->add_unpacked_float (611); 709 message->add_unpacked_double (612); 710 message->add_unpacked_bool (true); 711 message->add_unpacked_enum (unittest::FOREIGN_BAR); 712 // add a second one of each field 713 message->add_unpacked_int32 (701); 714 message->add_unpacked_int64 (702); 715 message->add_unpacked_uint32 (703); 716 message->add_unpacked_uint64 (704); 717 message->add_unpacked_sint32 (705); 718 message->add_unpacked_sint64 (706); 719 message->add_unpacked_fixed32 (707); 720 message->add_unpacked_fixed64 (708); 721 message->add_unpacked_sfixed32(709); 722 message->add_unpacked_sfixed64(710); 723 message->add_unpacked_float (711); 724 message->add_unpacked_double (712); 725 message->add_unpacked_bool (false); 726 message->add_unpacked_enum (unittest::FOREIGN_BAZ); 727 } 728 729 // ------------------------------------------------------------------- 730 731 void TestUtil::ModifyPackedFields(unittest::TestPackedTypes* message) { 732 message->set_packed_int32 (1, 801); 733 message->set_packed_int64 (1, 802); 734 message->set_packed_uint32 (1, 803); 735 message->set_packed_uint64 (1, 804); 736 message->set_packed_sint32 (1, 805); 737 message->set_packed_sint64 (1, 806); 738 message->set_packed_fixed32 (1, 807); 739 message->set_packed_fixed64 (1, 808); 740 message->set_packed_sfixed32(1, 809); 741 message->set_packed_sfixed64(1, 810); 742 message->set_packed_float (1, 811); 743 message->set_packed_double (1, 812); 744 message->set_packed_bool (1, true); 745 message->set_packed_enum (1, unittest::FOREIGN_FOO); 746 } 747 748 // ------------------------------------------------------------------- 749 750 void TestUtil::ExpectPackedFieldsSet(const unittest::TestPackedTypes& message) { 751 ASSERT_EQ(2, message.packed_int32_size ()); 752 ASSERT_EQ(2, message.packed_int64_size ()); 753 ASSERT_EQ(2, message.packed_uint32_size ()); 754 ASSERT_EQ(2, message.packed_uint64_size ()); 755 ASSERT_EQ(2, message.packed_sint32_size ()); 756 ASSERT_EQ(2, message.packed_sint64_size ()); 757 ASSERT_EQ(2, message.packed_fixed32_size ()); 758 ASSERT_EQ(2, message.packed_fixed64_size ()); 759 ASSERT_EQ(2, message.packed_sfixed32_size()); 760 ASSERT_EQ(2, message.packed_sfixed64_size()); 761 ASSERT_EQ(2, message.packed_float_size ()); 762 ASSERT_EQ(2, message.packed_double_size ()); 763 ASSERT_EQ(2, message.packed_bool_size ()); 764 ASSERT_EQ(2, message.packed_enum_size ()); 765 766 EXPECT_EQ(601 , message.packed_int32 (0)); 767 EXPECT_EQ(602 , message.packed_int64 (0)); 768 EXPECT_EQ(603 , message.packed_uint32 (0)); 769 EXPECT_EQ(604 , message.packed_uint64 (0)); 770 EXPECT_EQ(605 , message.packed_sint32 (0)); 771 EXPECT_EQ(606 , message.packed_sint64 (0)); 772 EXPECT_EQ(607 , message.packed_fixed32 (0)); 773 EXPECT_EQ(608 , message.packed_fixed64 (0)); 774 EXPECT_EQ(609 , message.packed_sfixed32(0)); 775 EXPECT_EQ(610 , message.packed_sfixed64(0)); 776 EXPECT_EQ(611 , message.packed_float (0)); 777 EXPECT_EQ(612 , message.packed_double (0)); 778 EXPECT_EQ(true , message.packed_bool (0)); 779 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); 780 781 EXPECT_EQ(701 , message.packed_int32 (1)); 782 EXPECT_EQ(702 , message.packed_int64 (1)); 783 EXPECT_EQ(703 , message.packed_uint32 (1)); 784 EXPECT_EQ(704 , message.packed_uint64 (1)); 785 EXPECT_EQ(705 , message.packed_sint32 (1)); 786 EXPECT_EQ(706 , message.packed_sint64 (1)); 787 EXPECT_EQ(707 , message.packed_fixed32 (1)); 788 EXPECT_EQ(708 , message.packed_fixed64 (1)); 789 EXPECT_EQ(709 , message.packed_sfixed32(1)); 790 EXPECT_EQ(710 , message.packed_sfixed64(1)); 791 EXPECT_EQ(711 , message.packed_float (1)); 792 EXPECT_EQ(712 , message.packed_double (1)); 793 EXPECT_EQ(false, message.packed_bool (1)); 794 EXPECT_EQ(unittest::FOREIGN_BAZ, message.packed_enum(1)); 795 } 796 797 void TestUtil::ExpectUnpackedFieldsSet( 798 const unittest::TestUnpackedTypes& message) { 799 // The values expected here must match those of ExpectPackedFieldsSet. 800 801 ASSERT_EQ(2, message.unpacked_int32_size ()); 802 ASSERT_EQ(2, message.unpacked_int64_size ()); 803 ASSERT_EQ(2, message.unpacked_uint32_size ()); 804 ASSERT_EQ(2, message.unpacked_uint64_size ()); 805 ASSERT_EQ(2, message.unpacked_sint32_size ()); 806 ASSERT_EQ(2, message.unpacked_sint64_size ()); 807 ASSERT_EQ(2, message.unpacked_fixed32_size ()); 808 ASSERT_EQ(2, message.unpacked_fixed64_size ()); 809 ASSERT_EQ(2, message.unpacked_sfixed32_size()); 810 ASSERT_EQ(2, message.unpacked_sfixed64_size()); 811 ASSERT_EQ(2, message.unpacked_float_size ()); 812 ASSERT_EQ(2, message.unpacked_double_size ()); 813 ASSERT_EQ(2, message.unpacked_bool_size ()); 814 ASSERT_EQ(2, message.unpacked_enum_size ()); 815 816 EXPECT_EQ(601 , message.unpacked_int32 (0)); 817 EXPECT_EQ(602 , message.unpacked_int64 (0)); 818 EXPECT_EQ(603 , message.unpacked_uint32 (0)); 819 EXPECT_EQ(604 , message.unpacked_uint64 (0)); 820 EXPECT_EQ(605 , message.unpacked_sint32 (0)); 821 EXPECT_EQ(606 , message.unpacked_sint64 (0)); 822 EXPECT_EQ(607 , message.unpacked_fixed32 (0)); 823 EXPECT_EQ(608 , message.unpacked_fixed64 (0)); 824 EXPECT_EQ(609 , message.unpacked_sfixed32(0)); 825 EXPECT_EQ(610 , message.unpacked_sfixed64(0)); 826 EXPECT_EQ(611 , message.unpacked_float (0)); 827 EXPECT_EQ(612 , message.unpacked_double (0)); 828 EXPECT_EQ(true , message.unpacked_bool (0)); 829 EXPECT_EQ(unittest::FOREIGN_BAR, message.unpacked_enum(0)); 830 831 EXPECT_EQ(701 , message.unpacked_int32 (1)); 832 EXPECT_EQ(702 , message.unpacked_int64 (1)); 833 EXPECT_EQ(703 , message.unpacked_uint32 (1)); 834 EXPECT_EQ(704 , message.unpacked_uint64 (1)); 835 EXPECT_EQ(705 , message.unpacked_sint32 (1)); 836 EXPECT_EQ(706 , message.unpacked_sint64 (1)); 837 EXPECT_EQ(707 , message.unpacked_fixed32 (1)); 838 EXPECT_EQ(708 , message.unpacked_fixed64 (1)); 839 EXPECT_EQ(709 , message.unpacked_sfixed32(1)); 840 EXPECT_EQ(710 , message.unpacked_sfixed64(1)); 841 EXPECT_EQ(711 , message.unpacked_float (1)); 842 EXPECT_EQ(712 , message.unpacked_double (1)); 843 EXPECT_EQ(false, message.unpacked_bool (1)); 844 EXPECT_EQ(unittest::FOREIGN_BAZ, message.unpacked_enum(1)); 845 } 846 847 // ------------------------------------------------------------------- 848 849 void TestUtil::ExpectPackedClear( 850 const unittest::TestPackedTypes& message) { 851 // Packed repeated fields are empty. 852 EXPECT_EQ(0, message.packed_int32_size ()); 853 EXPECT_EQ(0, message.packed_int64_size ()); 854 EXPECT_EQ(0, message.packed_uint32_size ()); 855 EXPECT_EQ(0, message.packed_uint64_size ()); 856 EXPECT_EQ(0, message.packed_sint32_size ()); 857 EXPECT_EQ(0, message.packed_sint64_size ()); 858 EXPECT_EQ(0, message.packed_fixed32_size ()); 859 EXPECT_EQ(0, message.packed_fixed64_size ()); 860 EXPECT_EQ(0, message.packed_sfixed32_size()); 861 EXPECT_EQ(0, message.packed_sfixed64_size()); 862 EXPECT_EQ(0, message.packed_float_size ()); 863 EXPECT_EQ(0, message.packed_double_size ()); 864 EXPECT_EQ(0, message.packed_bool_size ()); 865 EXPECT_EQ(0, message.packed_enum_size ()); 866 } 867 868 // ------------------------------------------------------------------- 869 870 void TestUtil::ExpectPackedFieldsModified( 871 const unittest::TestPackedTypes& message) { 872 // Do the same for packed repeated fields. 873 ASSERT_EQ(2, message.packed_int32_size ()); 874 ASSERT_EQ(2, message.packed_int64_size ()); 875 ASSERT_EQ(2, message.packed_uint32_size ()); 876 ASSERT_EQ(2, message.packed_uint64_size ()); 877 ASSERT_EQ(2, message.packed_sint32_size ()); 878 ASSERT_EQ(2, message.packed_sint64_size ()); 879 ASSERT_EQ(2, message.packed_fixed32_size ()); 880 ASSERT_EQ(2, message.packed_fixed64_size ()); 881 ASSERT_EQ(2, message.packed_sfixed32_size()); 882 ASSERT_EQ(2, message.packed_sfixed64_size()); 883 ASSERT_EQ(2, message.packed_float_size ()); 884 ASSERT_EQ(2, message.packed_double_size ()); 885 ASSERT_EQ(2, message.packed_bool_size ()); 886 ASSERT_EQ(2, message.packed_enum_size ()); 887 888 EXPECT_EQ(601 , message.packed_int32 (0)); 889 EXPECT_EQ(602 , message.packed_int64 (0)); 890 EXPECT_EQ(603 , message.packed_uint32 (0)); 891 EXPECT_EQ(604 , message.packed_uint64 (0)); 892 EXPECT_EQ(605 , message.packed_sint32 (0)); 893 EXPECT_EQ(606 , message.packed_sint64 (0)); 894 EXPECT_EQ(607 , message.packed_fixed32 (0)); 895 EXPECT_EQ(608 , message.packed_fixed64 (0)); 896 EXPECT_EQ(609 , message.packed_sfixed32(0)); 897 EXPECT_EQ(610 , message.packed_sfixed64(0)); 898 EXPECT_EQ(611 , message.packed_float (0)); 899 EXPECT_EQ(612 , message.packed_double (0)); 900 EXPECT_EQ(true , message.packed_bool (0)); 901 EXPECT_EQ(unittest::FOREIGN_BAR, message.packed_enum(0)); 902 // Actually verify the second (modified) elements now. 903 EXPECT_EQ(801 , message.packed_int32 (1)); 904 EXPECT_EQ(802 , message.packed_int64 (1)); 905 EXPECT_EQ(803 , message.packed_uint32 (1)); 906 EXPECT_EQ(804 , message.packed_uint64 (1)); 907 EXPECT_EQ(805 , message.packed_sint32 (1)); 908 EXPECT_EQ(806 , message.packed_sint64 (1)); 909 EXPECT_EQ(807 , message.packed_fixed32 (1)); 910 EXPECT_EQ(808 , message.packed_fixed64 (1)); 911 EXPECT_EQ(809 , message.packed_sfixed32(1)); 912 EXPECT_EQ(810 , message.packed_sfixed64(1)); 913 EXPECT_EQ(811 , message.packed_float (1)); 914 EXPECT_EQ(812 , message.packed_double (1)); 915 EXPECT_EQ(true , message.packed_bool (1)); 916 EXPECT_EQ(unittest::FOREIGN_FOO, message.packed_enum(1)); 917 } 918 919 // =================================================================== 920 // Extensions 921 // 922 // All this code is exactly equivalent to the above code except that it's 923 // manipulating extension fields instead of normal ones. 924 // 925 // I gave up on the 80-char limit here. Sorry. 926 927 void TestUtil::SetAllExtensions(unittest::TestAllExtensions* message) { 928 message->SetExtension(unittest::optional_int32_extension , 101); 929 message->SetExtension(unittest::optional_int64_extension , 102); 930 message->SetExtension(unittest::optional_uint32_extension , 103); 931 message->SetExtension(unittest::optional_uint64_extension , 104); 932 message->SetExtension(unittest::optional_sint32_extension , 105); 933 message->SetExtension(unittest::optional_sint64_extension , 106); 934 message->SetExtension(unittest::optional_fixed32_extension , 107); 935 message->SetExtension(unittest::optional_fixed64_extension , 108); 936 message->SetExtension(unittest::optional_sfixed32_extension, 109); 937 message->SetExtension(unittest::optional_sfixed64_extension, 110); 938 message->SetExtension(unittest::optional_float_extension , 111); 939 message->SetExtension(unittest::optional_double_extension , 112); 940 message->SetExtension(unittest::optional_bool_extension , true); 941 message->SetExtension(unittest::optional_string_extension , "115"); 942 message->SetExtension(unittest::optional_bytes_extension , "116"); 943 944 message->MutableExtension(unittest::optionalgroup_extension )->set_a(117); 945 message->MutableExtension(unittest::optional_nested_message_extension )->set_bb(118); 946 message->MutableExtension(unittest::optional_foreign_message_extension)->set_c(119); 947 message->MutableExtension(unittest::optional_import_message_extension )->set_d(120); 948 949 message->SetExtension(unittest::optional_nested_enum_extension , unittest::TestAllTypes::BAZ); 950 message->SetExtension(unittest::optional_foreign_enum_extension, unittest::FOREIGN_BAZ ); 951 message->SetExtension(unittest::optional_import_enum_extension , unittest_import::IMPORT_BAZ); 952 953 message->SetExtension(unittest::optional_string_piece_extension, "124"); 954 message->SetExtension(unittest::optional_cord_extension, "125"); 955 956 // ----------------------------------------------------------------- 957 958 message->AddExtension(unittest::repeated_int32_extension , 201); 959 message->AddExtension(unittest::repeated_int64_extension , 202); 960 message->AddExtension(unittest::repeated_uint32_extension , 203); 961 message->AddExtension(unittest::repeated_uint64_extension , 204); 962 message->AddExtension(unittest::repeated_sint32_extension , 205); 963 message->AddExtension(unittest::repeated_sint64_extension , 206); 964 message->AddExtension(unittest::repeated_fixed32_extension , 207); 965 message->AddExtension(unittest::repeated_fixed64_extension , 208); 966 message->AddExtension(unittest::repeated_sfixed32_extension, 209); 967 message->AddExtension(unittest::repeated_sfixed64_extension, 210); 968 message->AddExtension(unittest::repeated_float_extension , 211); 969 message->AddExtension(unittest::repeated_double_extension , 212); 970 message->AddExtension(unittest::repeated_bool_extension , true); 971 message->AddExtension(unittest::repeated_string_extension , "215"); 972 message->AddExtension(unittest::repeated_bytes_extension , "216"); 973 974 message->AddExtension(unittest::repeatedgroup_extension )->set_a(217); 975 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(218); 976 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(219); 977 message->AddExtension(unittest::repeated_import_message_extension )->set_d(220); 978 979 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAR); 980 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAR ); 981 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAR); 982 983 message->AddExtension(unittest::repeated_string_piece_extension, "224"); 984 message->AddExtension(unittest::repeated_cord_extension, "225"); 985 986 // Add a second one of each field. 987 message->AddExtension(unittest::repeated_int32_extension , 301); 988 message->AddExtension(unittest::repeated_int64_extension , 302); 989 message->AddExtension(unittest::repeated_uint32_extension , 303); 990 message->AddExtension(unittest::repeated_uint64_extension , 304); 991 message->AddExtension(unittest::repeated_sint32_extension , 305); 992 message->AddExtension(unittest::repeated_sint64_extension , 306); 993 message->AddExtension(unittest::repeated_fixed32_extension , 307); 994 message->AddExtension(unittest::repeated_fixed64_extension , 308); 995 message->AddExtension(unittest::repeated_sfixed32_extension, 309); 996 message->AddExtension(unittest::repeated_sfixed64_extension, 310); 997 message->AddExtension(unittest::repeated_float_extension , 311); 998 message->AddExtension(unittest::repeated_double_extension , 312); 999 message->AddExtension(unittest::repeated_bool_extension , false); 1000 message->AddExtension(unittest::repeated_string_extension , "315"); 1001 message->AddExtension(unittest::repeated_bytes_extension , "316"); 1002 1003 message->AddExtension(unittest::repeatedgroup_extension )->set_a(317); 1004 message->AddExtension(unittest::repeated_nested_message_extension )->set_bb(318); 1005 message->AddExtension(unittest::repeated_foreign_message_extension)->set_c(319); 1006 message->AddExtension(unittest::repeated_import_message_extension )->set_d(320); 1007 1008 message->AddExtension(unittest::repeated_nested_enum_extension , unittest::TestAllTypes::BAZ); 1009 message->AddExtension(unittest::repeated_foreign_enum_extension, unittest::FOREIGN_BAZ ); 1010 message->AddExtension(unittest::repeated_import_enum_extension , unittest_import::IMPORT_BAZ); 1011 1012 message->AddExtension(unittest::repeated_string_piece_extension, "324"); 1013 message->AddExtension(unittest::repeated_cord_extension, "325"); 1014 1015 // ----------------------------------------------------------------- 1016 1017 message->SetExtension(unittest::default_int32_extension , 401); 1018 message->SetExtension(unittest::default_int64_extension , 402); 1019 message->SetExtension(unittest::default_uint32_extension , 403); 1020 message->SetExtension(unittest::default_uint64_extension , 404); 1021 message->SetExtension(unittest::default_sint32_extension , 405); 1022 message->SetExtension(unittest::default_sint64_extension , 406); 1023 message->SetExtension(unittest::default_fixed32_extension , 407); 1024 message->SetExtension(unittest::default_fixed64_extension , 408); 1025 message->SetExtension(unittest::default_sfixed32_extension, 409); 1026 message->SetExtension(unittest::default_sfixed64_extension, 410); 1027 message->SetExtension(unittest::default_float_extension , 411); 1028 message->SetExtension(unittest::default_double_extension , 412); 1029 message->SetExtension(unittest::default_bool_extension , false); 1030 message->SetExtension(unittest::default_string_extension , "415"); 1031 message->SetExtension(unittest::default_bytes_extension , "416"); 1032 1033 message->SetExtension(unittest::default_nested_enum_extension , unittest::TestAllTypes::FOO); 1034 message->SetExtension(unittest::default_foreign_enum_extension, unittest::FOREIGN_FOO ); 1035 message->SetExtension(unittest::default_import_enum_extension , unittest_import::IMPORT_FOO); 1036 1037 message->SetExtension(unittest::default_string_piece_extension, "424"); 1038 message->SetExtension(unittest::default_cord_extension, "425"); 1039 } 1040 1041 // ------------------------------------------------------------------- 1042 1043 void TestUtil::SetAllFieldsAndExtensions( 1044 unittest::TestFieldOrderings* message) { 1045 GOOGLE_CHECK(message); 1046 message->set_my_int(1); 1047 message->set_my_string("foo"); 1048 message->set_my_float(1.0); 1049 message->SetExtension(unittest::my_extension_int, 23); 1050 message->SetExtension(unittest::my_extension_string, "bar"); 1051 } 1052 1053 // ------------------------------------------------------------------- 1054 1055 void TestUtil::ModifyRepeatedExtensions(unittest::TestAllExtensions* message) { 1056 message->SetExtension(unittest::repeated_int32_extension , 1, 501); 1057 message->SetExtension(unittest::repeated_int64_extension , 1, 502); 1058 message->SetExtension(unittest::repeated_uint32_extension , 1, 503); 1059 message->SetExtension(unittest::repeated_uint64_extension , 1, 504); 1060 message->SetExtension(unittest::repeated_sint32_extension , 1, 505); 1061 message->SetExtension(unittest::repeated_sint64_extension , 1, 506); 1062 message->SetExtension(unittest::repeated_fixed32_extension , 1, 507); 1063 message->SetExtension(unittest::repeated_fixed64_extension , 1, 508); 1064 message->SetExtension(unittest::repeated_sfixed32_extension, 1, 509); 1065 message->SetExtension(unittest::repeated_sfixed64_extension, 1, 510); 1066 message->SetExtension(unittest::repeated_float_extension , 1, 511); 1067 message->SetExtension(unittest::repeated_double_extension , 1, 512); 1068 message->SetExtension(unittest::repeated_bool_extension , 1, true); 1069 message->SetExtension(unittest::repeated_string_extension , 1, "515"); 1070 message->SetExtension(unittest::repeated_bytes_extension , 1, "516"); 1071 1072 message->MutableExtension(unittest::repeatedgroup_extension , 1)->set_a(517); 1073 message->MutableExtension(unittest::repeated_nested_message_extension , 1)->set_bb(518); 1074 message->MutableExtension(unittest::repeated_foreign_message_extension, 1)->set_c(519); 1075 message->MutableExtension(unittest::repeated_import_message_extension , 1)->set_d(520); 1076 1077 message->SetExtension(unittest::repeated_nested_enum_extension , 1, unittest::TestAllTypes::FOO); 1078 message->SetExtension(unittest::repeated_foreign_enum_extension, 1, unittest::FOREIGN_FOO ); 1079 message->SetExtension(unittest::repeated_import_enum_extension , 1, unittest_import::IMPORT_FOO); 1080 1081 message->SetExtension(unittest::repeated_string_piece_extension, 1, "524"); 1082 message->SetExtension(unittest::repeated_cord_extension, 1, "525"); 1083 } 1084 1085 // ------------------------------------------------------------------- 1086 1087 void TestUtil::ExpectAllExtensionsSet( 1088 const unittest::TestAllExtensions& message) { 1089 EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension )); 1090 EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension )); 1091 EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension )); 1092 EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension )); 1093 EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension )); 1094 EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension )); 1095 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension )); 1096 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension )); 1097 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension)); 1098 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension)); 1099 EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension )); 1100 EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension )); 1101 EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension )); 1102 EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension )); 1103 EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension )); 1104 1105 EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension )); 1106 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension )); 1107 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension)); 1108 EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension )); 1109 1110 EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); 1111 EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); 1112 EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension).has_c()); 1113 EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); 1114 1115 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension )); 1116 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension)); 1117 EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension )); 1118 1119 EXPECT_TRUE(message.HasExtension(unittest::optional_string_piece_extension)); 1120 EXPECT_TRUE(message.HasExtension(unittest::optional_cord_extension)); 1121 1122 EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension )); 1123 EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension )); 1124 EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension )); 1125 EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension )); 1126 EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension )); 1127 EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension )); 1128 EXPECT_EQ(107 , message.GetExtension(unittest::optional_fixed32_extension )); 1129 EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension )); 1130 EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension)); 1131 EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension)); 1132 EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension )); 1133 EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension )); 1134 EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension )); 1135 EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension )); 1136 EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension )); 1137 1138 EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension ).a()); 1139 EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension ).bb()); 1140 EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension).c()); 1141 EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension ).d()); 1142 1143 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::optional_nested_enum_extension )); 1144 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension)); 1145 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::optional_import_enum_extension )); 1146 1147 EXPECT_EQ("124", message.GetExtension(unittest::optional_string_piece_extension)); 1148 EXPECT_EQ("125", message.GetExtension(unittest::optional_cord_extension)); 1149 1150 // ----------------------------------------------------------------- 1151 1152 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 1153 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 1154 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 1155 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 1156 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 1157 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 1158 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1159 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1160 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1161 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1162 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 1163 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 1164 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 1165 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 1166 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 1167 1168 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 1169 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1170 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1171 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 1172 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1173 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1174 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1175 1176 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1177 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 1178 1179 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1180 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1181 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1182 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1183 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1184 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1185 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1186 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1187 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1188 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1189 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1190 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1191 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); 1192 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1193 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1194 1195 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 1196 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 1197 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 1198 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 1199 1200 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 1201 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 1202 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 1203 1204 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 1205 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 1206 1207 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 1)); 1208 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 1)); 1209 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 1210 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 1211 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 1212 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 1213 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 1214 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 1215 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 1216 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 1217 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 1)); 1218 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 1)); 1219 EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension , 1)); 1220 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 1)); 1221 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 1)); 1222 1223 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 1224 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 1225 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 1226 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 1227 1228 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 1229 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 1230 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 1231 1232 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 1233 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 1)); 1234 1235 // ----------------------------------------------------------------- 1236 1237 EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension )); 1238 EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension )); 1239 EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension )); 1240 EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension )); 1241 EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension )); 1242 EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension )); 1243 EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension )); 1244 EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension )); 1245 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension)); 1246 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension)); 1247 EXPECT_TRUE(message.HasExtension(unittest::default_float_extension )); 1248 EXPECT_TRUE(message.HasExtension(unittest::default_double_extension )); 1249 EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension )); 1250 EXPECT_TRUE(message.HasExtension(unittest::default_string_extension )); 1251 EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension )); 1252 1253 EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension )); 1254 EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension)); 1255 EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension )); 1256 1257 EXPECT_TRUE(message.HasExtension(unittest::default_string_piece_extension)); 1258 EXPECT_TRUE(message.HasExtension(unittest::default_cord_extension)); 1259 1260 EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension )); 1261 EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension )); 1262 EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension )); 1263 EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension )); 1264 EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension )); 1265 EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension )); 1266 EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension )); 1267 EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension )); 1268 EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension)); 1269 EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension)); 1270 EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension )); 1271 EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension )); 1272 EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension )); 1273 EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension )); 1274 EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension )); 1275 1276 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::default_nested_enum_extension )); 1277 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::default_foreign_enum_extension)); 1278 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::default_import_enum_extension )); 1279 1280 EXPECT_EQ("424", message.GetExtension(unittest::default_string_piece_extension)); 1281 EXPECT_EQ("425", message.GetExtension(unittest::default_cord_extension)); 1282 } 1283 1284 // ------------------------------------------------------------------- 1285 1286 void TestUtil::ExpectExtensionsClear( 1287 const unittest::TestAllExtensions& message) { 1288 string serialized; 1289 ASSERT_TRUE(message.SerializeToString(&serialized)); 1290 EXPECT_EQ("", serialized); 1291 EXPECT_EQ(0, message.ByteSize()); 1292 1293 // has_blah() should initially be false for all optional fields. 1294 EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension )); 1295 EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension )); 1296 EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension )); 1297 EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension )); 1298 EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension )); 1299 EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension )); 1300 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension )); 1301 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension )); 1302 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension)); 1303 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension)); 1304 EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension )); 1305 EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension )); 1306 EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension )); 1307 EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension )); 1308 EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension )); 1309 1310 EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension )); 1311 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension )); 1312 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension)); 1313 EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension )); 1314 1315 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension )); 1316 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension)); 1317 EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension )); 1318 1319 EXPECT_FALSE(message.HasExtension(unittest::optional_string_piece_extension)); 1320 EXPECT_FALSE(message.HasExtension(unittest::optional_cord_extension)); 1321 1322 // Optional fields without defaults are set to zero or something like it. 1323 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension )); 1324 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension )); 1325 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension )); 1326 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension )); 1327 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension )); 1328 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension )); 1329 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension )); 1330 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension )); 1331 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension)); 1332 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension)); 1333 EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension )); 1334 EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension )); 1335 EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension )); 1336 EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension )); 1337 EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension )); 1338 1339 // Embedded messages should also be clear. 1340 EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension ).has_a()); 1341 EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension ).has_bb()); 1342 EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension).has_c()); 1343 EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension ).has_d()); 1344 1345 EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension ).a()); 1346 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension ).bb()); 1347 EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension).c()); 1348 EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension ).d()); 1349 1350 // Enums without defaults are set to the first value in the enum. 1351 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::optional_nested_enum_extension )); 1352 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::optional_foreign_enum_extension)); 1353 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::optional_import_enum_extension )); 1354 1355 EXPECT_EQ("", message.GetExtension(unittest::optional_string_piece_extension)); 1356 EXPECT_EQ("", message.GetExtension(unittest::optional_cord_extension)); 1357 1358 // Repeated fields are empty. 1359 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension )); 1360 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension )); 1361 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension )); 1362 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension )); 1363 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension )); 1364 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension )); 1365 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1366 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1367 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1368 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1369 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension )); 1370 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension )); 1371 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension )); 1372 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension )); 1373 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension )); 1374 1375 EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension )); 1376 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1377 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1378 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension )); 1379 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1380 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1381 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1382 1383 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1384 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_cord_extension)); 1385 1386 // has_blah() should also be false for all default fields. 1387 EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension )); 1388 EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension )); 1389 EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension )); 1390 EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension )); 1391 EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension )); 1392 EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension )); 1393 EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension )); 1394 EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension )); 1395 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension)); 1396 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension)); 1397 EXPECT_FALSE(message.HasExtension(unittest::default_float_extension )); 1398 EXPECT_FALSE(message.HasExtension(unittest::default_double_extension )); 1399 EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension )); 1400 EXPECT_FALSE(message.HasExtension(unittest::default_string_extension )); 1401 EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension )); 1402 1403 EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension )); 1404 EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension)); 1405 EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension )); 1406 1407 EXPECT_FALSE(message.HasExtension(unittest::default_string_piece_extension)); 1408 EXPECT_FALSE(message.HasExtension(unittest::default_cord_extension)); 1409 1410 // Fields with defaults have their default values (duh). 1411 EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension )); 1412 EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension )); 1413 EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension )); 1414 EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension )); 1415 EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension )); 1416 EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension )); 1417 EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension )); 1418 EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension )); 1419 EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension)); 1420 EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension)); 1421 EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension )); 1422 EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension )); 1423 EXPECT_EQ(true , message.GetExtension(unittest::default_bool_extension )); 1424 EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension )); 1425 EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension )); 1426 1427 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::default_nested_enum_extension )); 1428 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::default_foreign_enum_extension)); 1429 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::default_import_enum_extension )); 1430 1431 EXPECT_EQ("abc", message.GetExtension(unittest::default_string_piece_extension)); 1432 EXPECT_EQ("123", message.GetExtension(unittest::default_cord_extension)); 1433 } 1434 1435 // ------------------------------------------------------------------- 1436 1437 void TestUtil::ExpectRepeatedExtensionsModified( 1438 const unittest::TestAllExtensions& message) { 1439 // ModifyRepeatedFields only sets the second repeated element of each 1440 // field. In addition to verifying this, we also verify that the first 1441 // element and size were *not* modified. 1442 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 1443 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 1444 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 1445 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 1446 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 1447 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 1448 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1449 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1450 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1451 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1452 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 1453 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 1454 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 1455 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 1456 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 1457 1458 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 1459 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1460 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1461 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 1462 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1463 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1464 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1465 1466 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1467 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 1468 1469 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1470 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1471 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1472 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1473 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1474 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1475 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1476 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1477 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1478 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1479 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1480 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1481 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); 1482 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1483 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1484 1485 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 1486 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 1487 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 1488 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 1489 1490 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 1491 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 1492 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 1493 1494 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 1495 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 1496 1497 // Actually verify the second (modified) elements now. 1498 EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension , 1)); 1499 EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension , 1)); 1500 EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 1501 EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 1502 EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 1503 EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 1504 EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 1505 EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 1506 EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 1507 EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 1508 EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension , 1)); 1509 EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension , 1)); 1510 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 1)); 1511 EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension , 1)); 1512 EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension , 1)); 1513 1514 EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 1515 EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 1516 EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 1517 EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 1518 1519 EXPECT_EQ(unittest::TestAllTypes::FOO, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 1520 EXPECT_EQ(unittest::FOREIGN_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 1521 EXPECT_EQ(unittest_import::IMPORT_FOO, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 1522 1523 EXPECT_EQ("524", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 1524 EXPECT_EQ("525", message.GetExtension(unittest::repeated_cord_extension, 1)); 1525 } 1526 1527 // ------------------------------------------------------------------- 1528 1529 void TestUtil::SetPackedExtensions(unittest::TestPackedExtensions* message) { 1530 message->AddExtension(unittest::packed_int32_extension , 601); 1531 message->AddExtension(unittest::packed_int64_extension , 602); 1532 message->AddExtension(unittest::packed_uint32_extension , 603); 1533 message->AddExtension(unittest::packed_uint64_extension , 604); 1534 message->AddExtension(unittest::packed_sint32_extension , 605); 1535 message->AddExtension(unittest::packed_sint64_extension , 606); 1536 message->AddExtension(unittest::packed_fixed32_extension , 607); 1537 message->AddExtension(unittest::packed_fixed64_extension , 608); 1538 message->AddExtension(unittest::packed_sfixed32_extension, 609); 1539 message->AddExtension(unittest::packed_sfixed64_extension, 610); 1540 message->AddExtension(unittest::packed_float_extension , 611); 1541 message->AddExtension(unittest::packed_double_extension , 612); 1542 message->AddExtension(unittest::packed_bool_extension , true); 1543 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAR); 1544 // add a second one of each field 1545 message->AddExtension(unittest::packed_int32_extension , 701); 1546 message->AddExtension(unittest::packed_int64_extension , 702); 1547 message->AddExtension(unittest::packed_uint32_extension , 703); 1548 message->AddExtension(unittest::packed_uint64_extension , 704); 1549 message->AddExtension(unittest::packed_sint32_extension , 705); 1550 message->AddExtension(unittest::packed_sint64_extension , 706); 1551 message->AddExtension(unittest::packed_fixed32_extension , 707); 1552 message->AddExtension(unittest::packed_fixed64_extension , 708); 1553 message->AddExtension(unittest::packed_sfixed32_extension, 709); 1554 message->AddExtension(unittest::packed_sfixed64_extension, 710); 1555 message->AddExtension(unittest::packed_float_extension , 711); 1556 message->AddExtension(unittest::packed_double_extension , 712); 1557 message->AddExtension(unittest::packed_bool_extension , false); 1558 message->AddExtension(unittest::packed_enum_extension, unittest::FOREIGN_BAZ); 1559 } 1560 1561 // ------------------------------------------------------------------- 1562 1563 void TestUtil::ModifyPackedExtensions(unittest::TestPackedExtensions* message) { 1564 message->SetExtension(unittest::packed_int32_extension , 1, 801); 1565 message->SetExtension(unittest::packed_int64_extension , 1, 802); 1566 message->SetExtension(unittest::packed_uint32_extension , 1, 803); 1567 message->SetExtension(unittest::packed_uint64_extension , 1, 804); 1568 message->SetExtension(unittest::packed_sint32_extension , 1, 805); 1569 message->SetExtension(unittest::packed_sint64_extension , 1, 806); 1570 message->SetExtension(unittest::packed_fixed32_extension , 1, 807); 1571 message->SetExtension(unittest::packed_fixed64_extension , 1, 808); 1572 message->SetExtension(unittest::packed_sfixed32_extension, 1, 809); 1573 message->SetExtension(unittest::packed_sfixed64_extension, 1, 810); 1574 message->SetExtension(unittest::packed_float_extension , 1, 811); 1575 message->SetExtension(unittest::packed_double_extension , 1, 812); 1576 message->SetExtension(unittest::packed_bool_extension , 1, true); 1577 message->SetExtension(unittest::packed_enum_extension , 1, 1578 unittest::FOREIGN_FOO); 1579 } 1580 1581 // ------------------------------------------------------------------- 1582 1583 void TestUtil::ExpectPackedExtensionsSet( 1584 const unittest::TestPackedExtensions& message) { 1585 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension )); 1586 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension )); 1587 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension )); 1588 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension )); 1589 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension )); 1590 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension )); 1591 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension )); 1592 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension )); 1593 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1594 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1595 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension )); 1596 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension )); 1597 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension )); 1598 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension )); 1599 1600 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0)); 1601 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0)); 1602 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0)); 1603 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0)); 1604 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0)); 1605 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0)); 1606 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0)); 1607 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0)); 1608 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0)); 1609 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); 1610 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); 1611 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); 1612 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 0)); 1613 EXPECT_EQ(unittest::FOREIGN_BAR, 1614 message.GetExtension(unittest::packed_enum_extension, 0)); 1615 EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension , 1)); 1616 EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension , 1)); 1617 EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension , 1)); 1618 EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension , 1)); 1619 EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension , 1)); 1620 EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension , 1)); 1621 EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension , 1)); 1622 EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension , 1)); 1623 EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension, 1)); 1624 EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); 1625 EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension , 1)); 1626 EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension , 1)); 1627 EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension , 1)); 1628 EXPECT_EQ(unittest::FOREIGN_BAZ, 1629 message.GetExtension(unittest::packed_enum_extension, 1)); 1630 } 1631 1632 // ------------------------------------------------------------------- 1633 1634 void TestUtil::ExpectPackedExtensionsClear( 1635 const unittest::TestPackedExtensions& message) { 1636 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension )); 1637 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension )); 1638 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension )); 1639 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension )); 1640 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension )); 1641 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension )); 1642 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension )); 1643 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension )); 1644 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1645 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1646 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension )); 1647 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension )); 1648 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension )); 1649 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension )); 1650 } 1651 1652 // ------------------------------------------------------------------- 1653 1654 void TestUtil::ExpectPackedExtensionsModified( 1655 const unittest::TestPackedExtensions& message) { 1656 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension )); 1657 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension )); 1658 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension )); 1659 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension )); 1660 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension )); 1661 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension )); 1662 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension )); 1663 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension )); 1664 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension)); 1665 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension)); 1666 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension )); 1667 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension )); 1668 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension )); 1669 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension )); 1670 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension , 0)); 1671 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension , 0)); 1672 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension , 0)); 1673 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension , 0)); 1674 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension , 0)); 1675 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension , 0)); 1676 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension , 0)); 1677 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension , 0)); 1678 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension, 0)); 1679 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension, 0)); 1680 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension , 0)); 1681 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension , 0)); 1682 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 0)); 1683 EXPECT_EQ(unittest::FOREIGN_BAR, 1684 message.GetExtension(unittest::packed_enum_extension, 0)); 1685 1686 // Actually verify the second (modified) elements now. 1687 EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension , 1)); 1688 EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension , 1)); 1689 EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension , 1)); 1690 EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension , 1)); 1691 EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension , 1)); 1692 EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension , 1)); 1693 EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension , 1)); 1694 EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension , 1)); 1695 EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension, 1)); 1696 EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension, 1)); 1697 EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension , 1)); 1698 EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension , 1)); 1699 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension , 1)); 1700 EXPECT_EQ(unittest::FOREIGN_FOO, 1701 message.GetExtension(unittest::packed_enum_extension, 1)); 1702 } 1703 1704 // ------------------------------------------------------------------- 1705 1706 void TestUtil::ExpectAllFieldsAndExtensionsInOrder(const string& serialized) { 1707 // We set each field individually, serialize separately, and concatenate all 1708 // the strings in canonical order to determine the expected serialization. 1709 string expected; 1710 unittest::TestFieldOrderings message; 1711 message.set_my_int(1); // Field 1. 1712 message.AppendToString(&expected); 1713 message.Clear(); 1714 message.SetExtension(unittest::my_extension_int, 23); // Field 5. 1715 message.AppendToString(&expected); 1716 message.Clear(); 1717 message.set_my_string("foo"); // Field 11. 1718 message.AppendToString(&expected); 1719 message.Clear(); 1720 message.SetExtension(unittest::my_extension_string, "bar"); // Field 50. 1721 message.AppendToString(&expected); 1722 message.Clear(); 1723 message.set_my_float(1.0); // Field 101. 1724 message.AppendToString(&expected); 1725 message.Clear(); 1726 1727 // We don't EXPECT_EQ() since we don't want to print raw bytes to stdout. 1728 EXPECT_TRUE(serialized == expected); 1729 } 1730 1731 void TestUtil::ExpectLastRepeatedsRemoved( 1732 const unittest::TestAllTypes& message) { 1733 ASSERT_EQ(1, message.repeated_int32_size ()); 1734 ASSERT_EQ(1, message.repeated_int64_size ()); 1735 ASSERT_EQ(1, message.repeated_uint32_size ()); 1736 ASSERT_EQ(1, message.repeated_uint64_size ()); 1737 ASSERT_EQ(1, message.repeated_sint32_size ()); 1738 ASSERT_EQ(1, message.repeated_sint64_size ()); 1739 ASSERT_EQ(1, message.repeated_fixed32_size ()); 1740 ASSERT_EQ(1, message.repeated_fixed64_size ()); 1741 ASSERT_EQ(1, message.repeated_sfixed32_size()); 1742 ASSERT_EQ(1, message.repeated_sfixed64_size()); 1743 ASSERT_EQ(1, message.repeated_float_size ()); 1744 ASSERT_EQ(1, message.repeated_double_size ()); 1745 ASSERT_EQ(1, message.repeated_bool_size ()); 1746 ASSERT_EQ(1, message.repeated_string_size ()); 1747 ASSERT_EQ(1, message.repeated_bytes_size ()); 1748 1749 ASSERT_EQ(1, message.repeatedgroup_size ()); 1750 ASSERT_EQ(1, message.repeated_nested_message_size ()); 1751 ASSERT_EQ(1, message.repeated_foreign_message_size()); 1752 ASSERT_EQ(1, message.repeated_import_message_size ()); 1753 ASSERT_EQ(1, message.repeated_nested_enum_size ()); 1754 ASSERT_EQ(1, message.repeated_foreign_enum_size ()); 1755 ASSERT_EQ(1, message.repeated_import_enum_size ()); 1756 1757 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 1758 ASSERT_EQ(1, message.repeated_string_piece_size()); 1759 ASSERT_EQ(1, message.repeated_cord_size()); 1760 #endif 1761 1762 // Test that the remaining element is the correct one. 1763 EXPECT_EQ(201 , message.repeated_int32 (0)); 1764 EXPECT_EQ(202 , message.repeated_int64 (0)); 1765 EXPECT_EQ(203 , message.repeated_uint32 (0)); 1766 EXPECT_EQ(204 , message.repeated_uint64 (0)); 1767 EXPECT_EQ(205 , message.repeated_sint32 (0)); 1768 EXPECT_EQ(206 , message.repeated_sint64 (0)); 1769 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 1770 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 1771 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 1772 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 1773 EXPECT_EQ(211 , message.repeated_float (0)); 1774 EXPECT_EQ(212 , message.repeated_double (0)); 1775 EXPECT_EQ(true , message.repeated_bool (0)); 1776 EXPECT_EQ("215", message.repeated_string (0)); 1777 EXPECT_EQ("216", message.repeated_bytes (0)); 1778 1779 EXPECT_EQ(217, message.repeatedgroup (0).a()); 1780 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 1781 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 1782 EXPECT_EQ(220, message.repeated_import_message (0).d()); 1783 1784 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0)); 1785 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(0)); 1786 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0)); 1787 } 1788 1789 void TestUtil::ExpectLastRepeatedExtensionsRemoved( 1790 const unittest::TestAllExtensions& message) { 1791 1792 // Test that one element was removed. 1793 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int32_extension )); 1794 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int64_extension )); 1795 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint32_extension )); 1796 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint64_extension )); 1797 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint32_extension )); 1798 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint64_extension )); 1799 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1800 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1801 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1802 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1803 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_float_extension )); 1804 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_double_extension )); 1805 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bool_extension )); 1806 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_extension )); 1807 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bytes_extension )); 1808 1809 ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension )); 1810 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1811 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1812 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension )); 1813 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1814 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1815 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1816 1817 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1818 ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_cord_extension)); 1819 1820 // Test that the remaining element is the correct one. 1821 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1822 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1823 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1824 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1825 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1826 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1827 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1828 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1829 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 1830 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 1831 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 0)); 1832 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 0)); 1833 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 0)); 1834 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 0)); 1835 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 0)); 1836 1837 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 1838 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 1839 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 1840 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 1841 1842 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 1843 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 1844 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 1845 1846 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 1847 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0)); 1848 } 1849 1850 void TestUtil::ExpectRepeatedsSwapped( 1851 const unittest::TestAllTypes& message) { 1852 ASSERT_EQ(2, message.repeated_int32_size ()); 1853 ASSERT_EQ(2, message.repeated_int64_size ()); 1854 ASSERT_EQ(2, message.repeated_uint32_size ()); 1855 ASSERT_EQ(2, message.repeated_uint64_size ()); 1856 ASSERT_EQ(2, message.repeated_sint32_size ()); 1857 ASSERT_EQ(2, message.repeated_sint64_size ()); 1858 ASSERT_EQ(2, message.repeated_fixed32_size ()); 1859 ASSERT_EQ(2, message.repeated_fixed64_size ()); 1860 ASSERT_EQ(2, message.repeated_sfixed32_size()); 1861 ASSERT_EQ(2, message.repeated_sfixed64_size()); 1862 ASSERT_EQ(2, message.repeated_float_size ()); 1863 ASSERT_EQ(2, message.repeated_double_size ()); 1864 ASSERT_EQ(2, message.repeated_bool_size ()); 1865 ASSERT_EQ(2, message.repeated_string_size ()); 1866 ASSERT_EQ(2, message.repeated_bytes_size ()); 1867 1868 ASSERT_EQ(2, message.repeatedgroup_size ()); 1869 ASSERT_EQ(2, message.repeated_nested_message_size ()); 1870 ASSERT_EQ(2, message.repeated_foreign_message_size()); 1871 ASSERT_EQ(2, message.repeated_import_message_size ()); 1872 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 1873 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 1874 ASSERT_EQ(2, message.repeated_import_enum_size ()); 1875 1876 #ifndef PROTOBUF_TEST_NO_DESCRIPTORS 1877 ASSERT_EQ(2, message.repeated_string_piece_size()); 1878 ASSERT_EQ(2, message.repeated_cord_size()); 1879 #endif 1880 1881 // Test that the first element and second element are flipped. 1882 EXPECT_EQ(201 , message.repeated_int32 (1)); 1883 EXPECT_EQ(202 , message.repeated_int64 (1)); 1884 EXPECT_EQ(203 , message.repeated_uint32 (1)); 1885 EXPECT_EQ(204 , message.repeated_uint64 (1)); 1886 EXPECT_EQ(205 , message.repeated_sint32 (1)); 1887 EXPECT_EQ(206 , message.repeated_sint64 (1)); 1888 EXPECT_EQ(207 , message.repeated_fixed32 (1)); 1889 EXPECT_EQ(208 , message.repeated_fixed64 (1)); 1890 EXPECT_EQ(209 , message.repeated_sfixed32(1)); 1891 EXPECT_EQ(210 , message.repeated_sfixed64(1)); 1892 EXPECT_EQ(211 , message.repeated_float (1)); 1893 EXPECT_EQ(212 , message.repeated_double (1)); 1894 EXPECT_EQ(true , message.repeated_bool (1)); 1895 EXPECT_EQ("215", message.repeated_string (1)); 1896 EXPECT_EQ("216", message.repeated_bytes (1)); 1897 1898 EXPECT_EQ(217, message.repeatedgroup (1).a()); 1899 EXPECT_EQ(218, message.repeated_nested_message (1).bb()); 1900 EXPECT_EQ(219, message.repeated_foreign_message(1).c()); 1901 EXPECT_EQ(220, message.repeated_import_message (1).d()); 1902 1903 EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (1)); 1904 EXPECT_EQ(unittest::FOREIGN_BAR , message.repeated_foreign_enum(1)); 1905 EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (1)); 1906 1907 EXPECT_EQ(301 , message.repeated_int32 (0)); 1908 EXPECT_EQ(302 , message.repeated_int64 (0)); 1909 EXPECT_EQ(303 , message.repeated_uint32 (0)); 1910 EXPECT_EQ(304 , message.repeated_uint64 (0)); 1911 EXPECT_EQ(305 , message.repeated_sint32 (0)); 1912 EXPECT_EQ(306 , message.repeated_sint64 (0)); 1913 EXPECT_EQ(307 , message.repeated_fixed32 (0)); 1914 EXPECT_EQ(308 , message.repeated_fixed64 (0)); 1915 EXPECT_EQ(309 , message.repeated_sfixed32(0)); 1916 EXPECT_EQ(310 , message.repeated_sfixed64(0)); 1917 EXPECT_EQ(311 , message.repeated_float (0)); 1918 EXPECT_EQ(312 , message.repeated_double (0)); 1919 EXPECT_EQ(false, message.repeated_bool (0)); 1920 EXPECT_EQ("315", message.repeated_string (0)); 1921 EXPECT_EQ("316", message.repeated_bytes (0)); 1922 1923 EXPECT_EQ(317, message.repeatedgroup (0).a()); 1924 EXPECT_EQ(318, message.repeated_nested_message (0).bb()); 1925 EXPECT_EQ(319, message.repeated_foreign_message(0).c()); 1926 EXPECT_EQ(320, message.repeated_import_message (0).d()); 1927 1928 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (0)); 1929 EXPECT_EQ(unittest::FOREIGN_BAZ , message.repeated_foreign_enum(0)); 1930 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (0)); 1931 } 1932 1933 void TestUtil::ExpectRepeatedExtensionsSwapped( 1934 const unittest::TestAllExtensions& message) { 1935 1936 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension )); 1937 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension )); 1938 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension )); 1939 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension )); 1940 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension )); 1941 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension )); 1942 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension )); 1943 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension )); 1944 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension)); 1945 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension)); 1946 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension )); 1947 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension )); 1948 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension )); 1949 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension )); 1950 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension )); 1951 1952 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension )); 1953 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension )); 1954 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension)); 1955 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension )); 1956 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension )); 1957 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension )); 1958 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension )); 1959 1960 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension)); 1961 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension)); 1962 1963 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension , 1)); 1964 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension , 1)); 1965 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension , 1)); 1966 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension , 1)); 1967 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension , 1)); 1968 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension , 1)); 1969 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension , 1)); 1970 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension , 1)); 1971 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension, 1)); 1972 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension, 1)); 1973 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension , 1)); 1974 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension , 1)); 1975 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension , 1)); 1976 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension , 1)); 1977 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension , 1)); 1978 1979 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension , 1).a()); 1980 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb()); 1981 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c()); 1982 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 1).d()); 1983 1984 EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 1)); 1985 EXPECT_EQ(unittest::FOREIGN_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension, 1)); 1986 EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 1)); 1987 1988 EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 1)); 1989 EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 1)); 1990 1991 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension , 0)); 1992 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension , 0)); 1993 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension , 0)); 1994 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension , 0)); 1995 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension , 0)); 1996 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension , 0)); 1997 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension , 0)); 1998 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension , 0)); 1999 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension, 0)); 2000 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension, 0)); 2001 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension , 0)); 2002 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension , 0)); 2003 EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension , 0)); 2004 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension , 0)); 2005 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension , 0)); 2006 2007 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension , 0).a()); 2008 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb()); 2009 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c()); 2010 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 0).d()); 2011 2012 EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 0)); 2013 EXPECT_EQ(unittest::FOREIGN_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension, 0)); 2014 EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 0)); 2015 2016 EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 0)); 2017 EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 0)); 2018 } 2019 2020 // =================================================================== 2021 2022 TestUtil::ReflectionTester::ReflectionTester( 2023 const Descriptor* base_descriptor) 2024 : base_descriptor_(base_descriptor) { 2025 2026 const DescriptorPool* pool = base_descriptor->file()->pool(); 2027 2028 nested_b_ = 2029 pool->FindFieldByName("protobuf_unittest.TestAllTypes.NestedMessage.bb"); 2030 foreign_c_ = 2031 pool->FindFieldByName("protobuf_unittest.ForeignMessage.c"); 2032 import_d_ = 2033 pool->FindFieldByName("protobuf_unittest_import.ImportMessage.d"); 2034 nested_foo_ = 2035 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.FOO"); 2036 nested_bar_ = 2037 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.BAR"); 2038 nested_baz_ = 2039 pool->FindEnumValueByName("protobuf_unittest.TestAllTypes.BAZ"); 2040 foreign_foo_ = 2041 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_FOO"); 2042 foreign_bar_ = 2043 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_BAR"); 2044 foreign_baz_ = 2045 pool->FindEnumValueByName("protobuf_unittest.FOREIGN_BAZ"); 2046 import_foo_ = 2047 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_FOO"); 2048 import_bar_ = 2049 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_BAR"); 2050 import_baz_ = 2051 pool->FindEnumValueByName("protobuf_unittest_import.IMPORT_BAZ"); 2052 2053 if (base_descriptor_->name() == "TestAllExtensions") { 2054 group_a_ = 2055 pool->FindFieldByName("protobuf_unittest.OptionalGroup_extension.a"); 2056 repeated_group_a_ = 2057 pool->FindFieldByName("protobuf_unittest.RepeatedGroup_extension.a"); 2058 } else { 2059 group_a_ = 2060 pool->FindFieldByName("protobuf_unittest.TestAllTypes.OptionalGroup.a"); 2061 repeated_group_a_ = 2062 pool->FindFieldByName("protobuf_unittest.TestAllTypes.RepeatedGroup.a"); 2063 } 2064 2065 EXPECT_TRUE(group_a_ != NULL); 2066 EXPECT_TRUE(repeated_group_a_ != NULL); 2067 EXPECT_TRUE(nested_b_ != NULL); 2068 EXPECT_TRUE(foreign_c_ != NULL); 2069 EXPECT_TRUE(import_d_ != NULL); 2070 EXPECT_TRUE(nested_foo_ != NULL); 2071 EXPECT_TRUE(nested_bar_ != NULL); 2072 EXPECT_TRUE(nested_baz_ != NULL); 2073 EXPECT_TRUE(foreign_foo_ != NULL); 2074 EXPECT_TRUE(foreign_bar_ != NULL); 2075 EXPECT_TRUE(foreign_baz_ != NULL); 2076 EXPECT_TRUE(import_foo_ != NULL); 2077 EXPECT_TRUE(import_bar_ != NULL); 2078 EXPECT_TRUE(import_baz_ != NULL); 2079 } 2080 2081 // Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. 2082 const FieldDescriptor* TestUtil::ReflectionTester::F(const string& name) { 2083 const FieldDescriptor* result = NULL; 2084 if (base_descriptor_->name() == "TestAllExtensions" || 2085 base_descriptor_->name() == "TestPackedExtensions") { 2086 result = base_descriptor_->file()->FindExtensionByName(name + "_extension"); 2087 } else { 2088 result = base_descriptor_->FindFieldByName(name); 2089 } 2090 GOOGLE_CHECK(result != NULL); 2091 return result; 2092 } 2093 2094 // ------------------------------------------------------------------- 2095 2096 void TestUtil::ReflectionTester::SetAllFieldsViaReflection(Message* message) { 2097 const Reflection* reflection = message->GetReflection(); 2098 Message* sub_message; 2099 2100 reflection->SetInt32 (message, F("optional_int32" ), 101); 2101 reflection->SetInt64 (message, F("optional_int64" ), 102); 2102 reflection->SetUInt32(message, F("optional_uint32" ), 103); 2103 reflection->SetUInt64(message, F("optional_uint64" ), 104); 2104 reflection->SetInt32 (message, F("optional_sint32" ), 105); 2105 reflection->SetInt64 (message, F("optional_sint64" ), 106); 2106 reflection->SetUInt32(message, F("optional_fixed32" ), 107); 2107 reflection->SetUInt64(message, F("optional_fixed64" ), 108); 2108 reflection->SetInt32 (message, F("optional_sfixed32"), 109); 2109 reflection->SetInt64 (message, F("optional_sfixed64"), 110); 2110 reflection->SetFloat (message, F("optional_float" ), 111); 2111 reflection->SetDouble(message, F("optional_double" ), 112); 2112 reflection->SetBool (message, F("optional_bool" ), true); 2113 reflection->SetString(message, F("optional_string" ), "115"); 2114 reflection->SetString(message, F("optional_bytes" ), "116"); 2115 2116 sub_message = reflection->MutableMessage(message, F("optionalgroup")); 2117 sub_message->GetReflection()->SetInt32(sub_message, group_a_, 117); 2118 sub_message = reflection->MutableMessage(message, F("optional_nested_message")); 2119 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 118); 2120 sub_message = reflection->MutableMessage(message, F("optional_foreign_message")); 2121 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 119); 2122 sub_message = reflection->MutableMessage(message, F("optional_import_message")); 2123 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 120); 2124 2125 reflection->SetEnum(message, F("optional_nested_enum" ), nested_baz_); 2126 reflection->SetEnum(message, F("optional_foreign_enum"), foreign_baz_); 2127 reflection->SetEnum(message, F("optional_import_enum" ), import_baz_); 2128 2129 reflection->SetString(message, F("optional_string_piece"), "124"); 2130 reflection->SetString(message, F("optional_cord"), "125"); 2131 2132 // ----------------------------------------------------------------- 2133 2134 reflection->AddInt32 (message, F("repeated_int32" ), 201); 2135 reflection->AddInt64 (message, F("repeated_int64" ), 202); 2136 reflection->AddUInt32(message, F("repeated_uint32" ), 203); 2137 reflection->AddUInt64(message, F("repeated_uint64" ), 204); 2138 reflection->AddInt32 (message, F("repeated_sint32" ), 205); 2139 reflection->AddInt64 (message, F("repeated_sint64" ), 206); 2140 reflection->AddUInt32(message, F("repeated_fixed32" ), 207); 2141 reflection->AddUInt64(message, F("repeated_fixed64" ), 208); 2142 reflection->AddInt32 (message, F("repeated_sfixed32"), 209); 2143 reflection->AddInt64 (message, F("repeated_sfixed64"), 210); 2144 reflection->AddFloat (message, F("repeated_float" ), 211); 2145 reflection->AddDouble(message, F("repeated_double" ), 212); 2146 reflection->AddBool (message, F("repeated_bool" ), true); 2147 reflection->AddString(message, F("repeated_string" ), "215"); 2148 reflection->AddString(message, F("repeated_bytes" ), "216"); 2149 2150 sub_message = reflection->AddMessage(message, F("repeatedgroup")); 2151 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 217); 2152 sub_message = reflection->AddMessage(message, F("repeated_nested_message")); 2153 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 218); 2154 sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); 2155 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 219); 2156 sub_message = reflection->AddMessage(message, F("repeated_import_message")); 2157 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 220); 2158 2159 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_bar_); 2160 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_bar_); 2161 reflection->AddEnum(message, F("repeated_import_enum" ), import_bar_); 2162 2163 reflection->AddString(message, F("repeated_string_piece"), "224"); 2164 reflection->AddString(message, F("repeated_cord"), "225"); 2165 2166 // Add a second one of each field. 2167 reflection->AddInt32 (message, F("repeated_int32" ), 301); 2168 reflection->AddInt64 (message, F("repeated_int64" ), 302); 2169 reflection->AddUInt32(message, F("repeated_uint32" ), 303); 2170 reflection->AddUInt64(message, F("repeated_uint64" ), 304); 2171 reflection->AddInt32 (message, F("repeated_sint32" ), 305); 2172 reflection->AddInt64 (message, F("repeated_sint64" ), 306); 2173 reflection->AddUInt32(message, F("repeated_fixed32" ), 307); 2174 reflection->AddUInt64(message, F("repeated_fixed64" ), 308); 2175 reflection->AddInt32 (message, F("repeated_sfixed32"), 309); 2176 reflection->AddInt64 (message, F("repeated_sfixed64"), 310); 2177 reflection->AddFloat (message, F("repeated_float" ), 311); 2178 reflection->AddDouble(message, F("repeated_double" ), 312); 2179 reflection->AddBool (message, F("repeated_bool" ), false); 2180 reflection->AddString(message, F("repeated_string" ), "315"); 2181 reflection->AddString(message, F("repeated_bytes" ), "316"); 2182 2183 sub_message = reflection->AddMessage(message, F("repeatedgroup")); 2184 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 317); 2185 sub_message = reflection->AddMessage(message, F("repeated_nested_message")); 2186 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 318); 2187 sub_message = reflection->AddMessage(message, F("repeated_foreign_message")); 2188 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 319); 2189 sub_message = reflection->AddMessage(message, F("repeated_import_message")); 2190 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 320); 2191 2192 reflection->AddEnum(message, F("repeated_nested_enum" ), nested_baz_); 2193 reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_baz_); 2194 reflection->AddEnum(message, F("repeated_import_enum" ), import_baz_); 2195 2196 reflection->AddString(message, F("repeated_string_piece"), "324"); 2197 reflection->AddString(message, F("repeated_cord"), "325"); 2198 2199 // ----------------------------------------------------------------- 2200 2201 reflection->SetInt32 (message, F("default_int32" ), 401); 2202 reflection->SetInt64 (message, F("default_int64" ), 402); 2203 reflection->SetUInt32(message, F("default_uint32" ), 403); 2204 reflection->SetUInt64(message, F("default_uint64" ), 404); 2205 reflection->SetInt32 (message, F("default_sint32" ), 405); 2206 reflection->SetInt64 (message, F("default_sint64" ), 406); 2207 reflection->SetUInt32(message, F("default_fixed32" ), 407); 2208 reflection->SetUInt64(message, F("default_fixed64" ), 408); 2209 reflection->SetInt32 (message, F("default_sfixed32"), 409); 2210 reflection->SetInt64 (message, F("default_sfixed64"), 410); 2211 reflection->SetFloat (message, F("default_float" ), 411); 2212 reflection->SetDouble(message, F("default_double" ), 412); 2213 reflection->SetBool (message, F("default_bool" ), false); 2214 reflection->SetString(message, F("default_string" ), "415"); 2215 reflection->SetString(message, F("default_bytes" ), "416"); 2216 2217 reflection->SetEnum(message, F("default_nested_enum" ), nested_foo_); 2218 reflection->SetEnum(message, F("default_foreign_enum"), foreign_foo_); 2219 reflection->SetEnum(message, F("default_import_enum" ), import_foo_); 2220 2221 reflection->SetString(message, F("default_string_piece"), "424"); 2222 reflection->SetString(message, F("default_cord"), "425"); 2223 } 2224 2225 void TestUtil::ReflectionTester::SetPackedFieldsViaReflection( 2226 Message* message) { 2227 const Reflection* reflection = message->GetReflection(); 2228 reflection->AddInt32 (message, F("packed_int32" ), 601); 2229 reflection->AddInt64 (message, F("packed_int64" ), 602); 2230 reflection->AddUInt32(message, F("packed_uint32" ), 603); 2231 reflection->AddUInt64(message, F("packed_uint64" ), 604); 2232 reflection->AddInt32 (message, F("packed_sint32" ), 605); 2233 reflection->AddInt64 (message, F("packed_sint64" ), 606); 2234 reflection->AddUInt32(message, F("packed_fixed32" ), 607); 2235 reflection->AddUInt64(message, F("packed_fixed64" ), 608); 2236 reflection->AddInt32 (message, F("packed_sfixed32"), 609); 2237 reflection->AddInt64 (message, F("packed_sfixed64"), 610); 2238 reflection->AddFloat (message, F("packed_float" ), 611); 2239 reflection->AddDouble(message, F("packed_double" ), 612); 2240 reflection->AddBool (message, F("packed_bool" ), true); 2241 reflection->AddEnum (message, F("packed_enum" ), foreign_bar_); 2242 2243 reflection->AddInt32 (message, F("packed_int32" ), 701); 2244 reflection->AddInt64 (message, F("packed_int64" ), 702); 2245 reflection->AddUInt32(message, F("packed_uint32" ), 703); 2246 reflection->AddUInt64(message, F("packed_uint64" ), 704); 2247 reflection->AddInt32 (message, F("packed_sint32" ), 705); 2248 reflection->AddInt64 (message, F("packed_sint64" ), 706); 2249 reflection->AddUInt32(message, F("packed_fixed32" ), 707); 2250 reflection->AddUInt64(message, F("packed_fixed64" ), 708); 2251 reflection->AddInt32 (message, F("packed_sfixed32"), 709); 2252 reflection->AddInt64 (message, F("packed_sfixed64"), 710); 2253 reflection->AddFloat (message, F("packed_float" ), 711); 2254 reflection->AddDouble(message, F("packed_double" ), 712); 2255 reflection->AddBool (message, F("packed_bool" ), false); 2256 reflection->AddEnum (message, F("packed_enum" ), foreign_baz_); 2257 } 2258 2259 // ------------------------------------------------------------------- 2260 2261 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection( 2262 const Message& message) { 2263 // We have to split this into three function otherwise it creates a stack 2264 // frame so large that it triggers a warning. 2265 ExpectAllFieldsSetViaReflection1(message); 2266 ExpectAllFieldsSetViaReflection2(message); 2267 ExpectAllFieldsSetViaReflection3(message); 2268 } 2269 2270 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1( 2271 const Message& message) { 2272 const Reflection* reflection = message.GetReflection(); 2273 string scratch; 2274 const Message* sub_message; 2275 2276 EXPECT_TRUE(reflection->HasField(message, F("optional_int32" ))); 2277 EXPECT_TRUE(reflection->HasField(message, F("optional_int64" ))); 2278 EXPECT_TRUE(reflection->HasField(message, F("optional_uint32" ))); 2279 EXPECT_TRUE(reflection->HasField(message, F("optional_uint64" ))); 2280 EXPECT_TRUE(reflection->HasField(message, F("optional_sint32" ))); 2281 EXPECT_TRUE(reflection->HasField(message, F("optional_sint64" ))); 2282 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed32" ))); 2283 EXPECT_TRUE(reflection->HasField(message, F("optional_fixed64" ))); 2284 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed32"))); 2285 EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed64"))); 2286 EXPECT_TRUE(reflection->HasField(message, F("optional_float" ))); 2287 EXPECT_TRUE(reflection->HasField(message, F("optional_double" ))); 2288 EXPECT_TRUE(reflection->HasField(message, F("optional_bool" ))); 2289 EXPECT_TRUE(reflection->HasField(message, F("optional_string" ))); 2290 EXPECT_TRUE(reflection->HasField(message, F("optional_bytes" ))); 2291 2292 EXPECT_TRUE(reflection->HasField(message, F("optionalgroup" ))); 2293 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_message" ))); 2294 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_message"))); 2295 EXPECT_TRUE(reflection->HasField(message, F("optional_import_message" ))); 2296 2297 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 2298 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); 2299 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 2300 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 2301 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 2302 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); 2303 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 2304 EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); 2305 2306 EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum" ))); 2307 EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum"))); 2308 EXPECT_TRUE(reflection->HasField(message, F("optional_import_enum" ))); 2309 2310 EXPECT_TRUE(reflection->HasField(message, F("optional_string_piece"))); 2311 EXPECT_TRUE(reflection->HasField(message, F("optional_cord"))); 2312 2313 EXPECT_EQ(101 , reflection->GetInt32 (message, F("optional_int32" ))); 2314 EXPECT_EQ(102 , reflection->GetInt64 (message, F("optional_int64" ))); 2315 EXPECT_EQ(103 , reflection->GetUInt32(message, F("optional_uint32" ))); 2316 EXPECT_EQ(104 , reflection->GetUInt64(message, F("optional_uint64" ))); 2317 EXPECT_EQ(105 , reflection->GetInt32 (message, F("optional_sint32" ))); 2318 EXPECT_EQ(106 , reflection->GetInt64 (message, F("optional_sint64" ))); 2319 EXPECT_EQ(107 , reflection->GetUInt32(message, F("optional_fixed32" ))); 2320 EXPECT_EQ(108 , reflection->GetUInt64(message, F("optional_fixed64" ))); 2321 EXPECT_EQ(109 , reflection->GetInt32 (message, F("optional_sfixed32"))); 2322 EXPECT_EQ(110 , reflection->GetInt64 (message, F("optional_sfixed64"))); 2323 EXPECT_EQ(111 , reflection->GetFloat (message, F("optional_float" ))); 2324 EXPECT_EQ(112 , reflection->GetDouble(message, F("optional_double" ))); 2325 EXPECT_EQ(true , reflection->GetBool (message, F("optional_bool" ))); 2326 EXPECT_EQ("115", reflection->GetString(message, F("optional_string" ))); 2327 EXPECT_EQ("116", reflection->GetString(message, F("optional_bytes" ))); 2328 2329 EXPECT_EQ("115", reflection->GetStringReference(message, F("optional_string"), &scratch)); 2330 EXPECT_EQ("116", reflection->GetStringReference(message, F("optional_bytes" ), &scratch)); 2331 2332 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 2333 EXPECT_EQ(117, sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); 2334 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 2335 EXPECT_EQ(118, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2336 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 2337 EXPECT_EQ(119, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2338 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 2339 EXPECT_EQ(120, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2340 2341 EXPECT_EQ( nested_baz_, reflection->GetEnum(message, F("optional_nested_enum" ))); 2342 EXPECT_EQ(foreign_baz_, reflection->GetEnum(message, F("optional_foreign_enum"))); 2343 EXPECT_EQ( import_baz_, reflection->GetEnum(message, F("optional_import_enum" ))); 2344 2345 EXPECT_EQ("124", reflection->GetString(message, F("optional_string_piece"))); 2346 EXPECT_EQ("124", reflection->GetStringReference(message, F("optional_string_piece"), &scratch)); 2347 2348 EXPECT_EQ("125", reflection->GetString(message, F("optional_cord"))); 2349 EXPECT_EQ("125", reflection->GetStringReference(message, F("optional_cord"), &scratch)); 2350 } 2351 2352 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2( 2353 const Message& message) { 2354 const Reflection* reflection = message.GetReflection(); 2355 string scratch; 2356 const Message* sub_message; 2357 2358 // ----------------------------------------------------------------- 2359 2360 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int32" ))); 2361 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int64" ))); 2362 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint32" ))); 2363 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint64" ))); 2364 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint32" ))); 2365 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint64" ))); 2366 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed32" ))); 2367 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed64" ))); 2368 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed32"))); 2369 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed64"))); 2370 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_float" ))); 2371 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_double" ))); 2372 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bool" ))); 2373 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string" ))); 2374 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bytes" ))); 2375 2376 ASSERT_EQ(2, reflection->FieldSize(message, F("repeatedgroup" ))); 2377 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_message" ))); 2378 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_message"))); 2379 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_message" ))); 2380 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_enum" ))); 2381 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_enum" ))); 2382 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_enum" ))); 2383 2384 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string_piece"))); 2385 ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_cord"))); 2386 2387 EXPECT_EQ(201 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 0)); 2388 EXPECT_EQ(202 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 0)); 2389 EXPECT_EQ(203 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 0)); 2390 EXPECT_EQ(204 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 0)); 2391 EXPECT_EQ(205 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 0)); 2392 EXPECT_EQ(206 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 0)); 2393 EXPECT_EQ(207 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 0)); 2394 EXPECT_EQ(208 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 0)); 2395 EXPECT_EQ(209 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 0)); 2396 EXPECT_EQ(210 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 0)); 2397 EXPECT_EQ(211 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 0)); 2398 EXPECT_EQ(212 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 0)); 2399 EXPECT_EQ(true , reflection->GetRepeatedBool (message, F("repeated_bool" ), 0)); 2400 EXPECT_EQ("215", reflection->GetRepeatedString(message, F("repeated_string" ), 0)); 2401 EXPECT_EQ("216", reflection->GetRepeatedString(message, F("repeated_bytes" ), 0)); 2402 2403 EXPECT_EQ("215", reflection->GetRepeatedStringReference(message, F("repeated_string"), 0, &scratch)); 2404 EXPECT_EQ("216", reflection->GetRepeatedStringReference(message, F("repeated_bytes"), 0, &scratch)); 2405 2406 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 0); 2407 EXPECT_EQ(217, sub_message->GetReflection()->GetInt32(*sub_message, repeated_group_a_)); 2408 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 0); 2409 EXPECT_EQ(218, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2410 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 0); 2411 EXPECT_EQ(219, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2412 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 0); 2413 EXPECT_EQ(220, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2414 2415 EXPECT_EQ( nested_bar_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),0)); 2416 EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),0)); 2417 EXPECT_EQ( import_bar_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),0)); 2418 2419 EXPECT_EQ("224", reflection->GetRepeatedString(message, F("repeated_string_piece"), 0)); 2420 EXPECT_EQ("224", reflection->GetRepeatedStringReference( 2421 message, F("repeated_string_piece"), 0, &scratch)); 2422 2423 EXPECT_EQ("225", reflection->GetRepeatedString(message, F("repeated_cord"), 0)); 2424 EXPECT_EQ("225", reflection->GetRepeatedStringReference( 2425 message, F("repeated_cord"), 0, &scratch)); 2426 2427 EXPECT_EQ(301 , reflection->GetRepeatedInt32 (message, F("repeated_int32" ), 1)); 2428 EXPECT_EQ(302 , reflection->GetRepeatedInt64 (message, F("repeated_int64" ), 1)); 2429 EXPECT_EQ(303 , reflection->GetRepeatedUInt32(message, F("repeated_uint32" ), 1)); 2430 EXPECT_EQ(304 , reflection->GetRepeatedUInt64(message, F("repeated_uint64" ), 1)); 2431 EXPECT_EQ(305 , reflection->GetRepeatedInt32 (message, F("repeated_sint32" ), 1)); 2432 EXPECT_EQ(306 , reflection->GetRepeatedInt64 (message, F("repeated_sint64" ), 1)); 2433 EXPECT_EQ(307 , reflection->GetRepeatedUInt32(message, F("repeated_fixed32" ), 1)); 2434 EXPECT_EQ(308 , reflection->GetRepeatedUInt64(message, F("repeated_fixed64" ), 1)); 2435 EXPECT_EQ(309 , reflection->GetRepeatedInt32 (message, F("repeated_sfixed32"), 1)); 2436 EXPECT_EQ(310 , reflection->GetRepeatedInt64 (message, F("repeated_sfixed64"), 1)); 2437 EXPECT_EQ(311 , reflection->GetRepeatedFloat (message, F("repeated_float" ), 1)); 2438 EXPECT_EQ(312 , reflection->GetRepeatedDouble(message, F("repeated_double" ), 1)); 2439 EXPECT_EQ(false, reflection->GetRepeatedBool (message, F("repeated_bool" ), 1)); 2440 EXPECT_EQ("315", reflection->GetRepeatedString(message, F("repeated_string" ), 1)); 2441 EXPECT_EQ("316", reflection->GetRepeatedString(message, F("repeated_bytes" ), 1)); 2442 2443 EXPECT_EQ("315", reflection->GetRepeatedStringReference(message, F("repeated_string"), 2444 1, &scratch)); 2445 EXPECT_EQ("316", reflection->GetRepeatedStringReference(message, F("repeated_bytes"), 2446 1, &scratch)); 2447 2448 sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 1); 2449 EXPECT_EQ(317, sub_message->GetReflection()->GetInt32(*sub_message, repeated_group_a_)); 2450 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 1); 2451 EXPECT_EQ(318, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2452 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_foreign_message"), 1); 2453 EXPECT_EQ(319, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2454 sub_message = &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 1); 2455 EXPECT_EQ(320, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2456 2457 EXPECT_EQ( nested_baz_, reflection->GetRepeatedEnum(message, F("repeated_nested_enum" ),1)); 2458 EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum(message, F("repeated_foreign_enum"),1)); 2459 EXPECT_EQ( import_baz_, reflection->GetRepeatedEnum(message, F("repeated_import_enum" ),1)); 2460 2461 EXPECT_EQ("324", reflection->GetRepeatedString(message, F("repeated_string_piece"), 1)); 2462 EXPECT_EQ("324", reflection->GetRepeatedStringReference( 2463 message, F("repeated_string_piece"), 1, &scratch)); 2464 2465 EXPECT_EQ("325", reflection->GetRepeatedString(message, F("repeated_cord"), 1)); 2466 EXPECT_EQ("325", reflection->GetRepeatedStringReference( 2467 message, F("repeated_cord"), 1, &scratch)); 2468 } 2469 2470 void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection3( 2471 const Message& message) { 2472 const Reflection* reflection = message.GetReflection(); 2473 string scratch; 2474 2475 // ----------------------------------------------------------------- 2476 2477 EXPECT_TRUE(reflection->HasField(message, F("default_int32" ))); 2478 EXPECT_TRUE(reflection->HasField(message, F("default_int64" ))); 2479 EXPECT_TRUE(reflection->HasField(message, F("default_uint32" ))); 2480 EXPECT_TRUE(reflection->HasField(message, F("default_uint64" ))); 2481 EXPECT_TRUE(reflection->HasField(message, F("default_sint32" ))); 2482 EXPECT_TRUE(reflection->HasField(message, F("default_sint64" ))); 2483 EXPECT_TRUE(reflection->HasField(message, F("default_fixed32" ))); 2484 EXPECT_TRUE(reflection->HasField(message, F("default_fixed64" ))); 2485 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed32"))); 2486 EXPECT_TRUE(reflection->HasField(message, F("default_sfixed64"))); 2487 EXPECT_TRUE(reflection->HasField(message, F("default_float" ))); 2488 EXPECT_TRUE(reflection->HasField(message, F("default_double" ))); 2489 EXPECT_TRUE(reflection->HasField(message, F("default_bool" ))); 2490 EXPECT_TRUE(reflection->HasField(message, F("default_string" ))); 2491 EXPECT_TRUE(reflection->HasField(message, F("default_bytes" ))); 2492 2493 EXPECT_TRUE(reflection->HasField(message, F("default_nested_enum" ))); 2494 EXPECT_TRUE(reflection->HasField(message, F("default_foreign_enum"))); 2495 EXPECT_TRUE(reflection->HasField(message, F("default_import_enum" ))); 2496 2497 EXPECT_TRUE(reflection->HasField(message, F("default_string_piece"))); 2498 EXPECT_TRUE(reflection->HasField(message, F("default_cord"))); 2499 2500 EXPECT_EQ(401 , reflection->GetInt32 (message, F("default_int32" ))); 2501 EXPECT_EQ(402 , reflection->GetInt64 (message, F("default_int64" ))); 2502 EXPECT_EQ(403 , reflection->GetUInt32(message, F("default_uint32" ))); 2503 EXPECT_EQ(404 , reflection->GetUInt64(message, F("default_uint64" ))); 2504 EXPECT_EQ(405 , reflection->GetInt32 (message, F("default_sint32" ))); 2505 EXPECT_EQ(406 , reflection->GetInt64 (message, F("default_sint64" ))); 2506 EXPECT_EQ(407 , reflection->GetUInt32(message, F("default_fixed32" ))); 2507 EXPECT_EQ(408 , reflection->GetUInt64(message, F("default_fixed64" ))); 2508 EXPECT_EQ(409 , reflection->GetInt32 (message, F("default_sfixed32"))); 2509 EXPECT_EQ(410 , reflection->GetInt64 (message, F("default_sfixed64"))); 2510 EXPECT_EQ(411 , reflection->GetFloat (message, F("default_float" ))); 2511 EXPECT_EQ(412 , reflection->GetDouble(message, F("default_double" ))); 2512 EXPECT_EQ(false, reflection->GetBool (message, F("default_bool" ))); 2513 EXPECT_EQ("415", reflection->GetString(message, F("default_string" ))); 2514 EXPECT_EQ("416", reflection->GetString(message, F("default_bytes" ))); 2515 2516 EXPECT_EQ("415", reflection->GetStringReference(message, F("default_string"), &scratch)); 2517 EXPECT_EQ("416", reflection->GetStringReference(message, F("default_bytes" ), &scratch)); 2518 2519 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("default_nested_enum" ))); 2520 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("default_foreign_enum"))); 2521 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("default_import_enum" ))); 2522 2523 EXPECT_EQ("424", reflection->GetString(message, F("default_string_piece"))); 2524 EXPECT_EQ("424", reflection->GetStringReference(message, F("default_string_piece"), 2525 &scratch)); 2526 2527 EXPECT_EQ("425", reflection->GetString(message, F("default_cord"))); 2528 EXPECT_EQ("425", reflection->GetStringReference(message, F("default_cord"), &scratch)); 2529 } 2530 2531 void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection( 2532 const Message& message) { 2533 const Reflection* reflection = message.GetReflection(); 2534 2535 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int32" ))); 2536 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int64" ))); 2537 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint32" ))); 2538 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint64" ))); 2539 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint32" ))); 2540 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint64" ))); 2541 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed32" ))); 2542 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed64" ))); 2543 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed32"))); 2544 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed64"))); 2545 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_float" ))); 2546 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_double" ))); 2547 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_bool" ))); 2548 ASSERT_EQ(2, reflection->FieldSize(message, F("packed_enum" ))); 2549 2550 EXPECT_EQ(601 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 0)); 2551 EXPECT_EQ(602 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 0)); 2552 EXPECT_EQ(603 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 0)); 2553 EXPECT_EQ(604 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 0)); 2554 EXPECT_EQ(605 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 0)); 2555 EXPECT_EQ(606 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 0)); 2556 EXPECT_EQ(607 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 0)); 2557 EXPECT_EQ(608 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 0)); 2558 EXPECT_EQ(609 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 0)); 2559 EXPECT_EQ(610 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 0)); 2560 EXPECT_EQ(611 , reflection->GetRepeatedFloat (message, F("packed_float" ), 0)); 2561 EXPECT_EQ(612 , reflection->GetRepeatedDouble(message, F("packed_double" ), 0)); 2562 EXPECT_EQ(true , reflection->GetRepeatedBool (message, F("packed_bool" ), 0)); 2563 EXPECT_EQ(foreign_bar_, 2564 reflection->GetRepeatedEnum(message, F("packed_enum"), 0)); 2565 2566 EXPECT_EQ(701 , reflection->GetRepeatedInt32 (message, F("packed_int32" ), 1)); 2567 EXPECT_EQ(702 , reflection->GetRepeatedInt64 (message, F("packed_int64" ), 1)); 2568 EXPECT_EQ(703 , reflection->GetRepeatedUInt32(message, F("packed_uint32" ), 1)); 2569 EXPECT_EQ(704 , reflection->GetRepeatedUInt64(message, F("packed_uint64" ), 1)); 2570 EXPECT_EQ(705 , reflection->GetRepeatedInt32 (message, F("packed_sint32" ), 1)); 2571 EXPECT_EQ(706 , reflection->GetRepeatedInt64 (message, F("packed_sint64" ), 1)); 2572 EXPECT_EQ(707 , reflection->GetRepeatedUInt32(message, F("packed_fixed32" ), 1)); 2573 EXPECT_EQ(708 , reflection->GetRepeatedUInt64(message, F("packed_fixed64" ), 1)); 2574 EXPECT_EQ(709 , reflection->GetRepeatedInt32 (message, F("packed_sfixed32"), 1)); 2575 EXPECT_EQ(710 , reflection->GetRepeatedInt64 (message, F("packed_sfixed64"), 1)); 2576 EXPECT_EQ(711 , reflection->GetRepeatedFloat (message, F("packed_float" ), 1)); 2577 EXPECT_EQ(712 , reflection->GetRepeatedDouble(message, F("packed_double" ), 1)); 2578 EXPECT_EQ(false, reflection->GetRepeatedBool (message, F("packed_bool" ), 1)); 2579 EXPECT_EQ(foreign_baz_, 2580 reflection->GetRepeatedEnum(message, F("packed_enum"), 1)); 2581 } 2582 2583 // ------------------------------------------------------------------- 2584 2585 void TestUtil::ReflectionTester::ExpectClearViaReflection( 2586 const Message& message) { 2587 const Reflection* reflection = message.GetReflection(); 2588 string scratch; 2589 const Message* sub_message; 2590 2591 // has_blah() should initially be false for all optional fields. 2592 EXPECT_FALSE(reflection->HasField(message, F("optional_int32" ))); 2593 EXPECT_FALSE(reflection->HasField(message, F("optional_int64" ))); 2594 EXPECT_FALSE(reflection->HasField(message, F("optional_uint32" ))); 2595 EXPECT_FALSE(reflection->HasField(message, F("optional_uint64" ))); 2596 EXPECT_FALSE(reflection->HasField(message, F("optional_sint32" ))); 2597 EXPECT_FALSE(reflection->HasField(message, F("optional_sint64" ))); 2598 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed32" ))); 2599 EXPECT_FALSE(reflection->HasField(message, F("optional_fixed64" ))); 2600 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed32"))); 2601 EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed64"))); 2602 EXPECT_FALSE(reflection->HasField(message, F("optional_float" ))); 2603 EXPECT_FALSE(reflection->HasField(message, F("optional_double" ))); 2604 EXPECT_FALSE(reflection->HasField(message, F("optional_bool" ))); 2605 EXPECT_FALSE(reflection->HasField(message, F("optional_string" ))); 2606 EXPECT_FALSE(reflection->HasField(message, F("optional_bytes" ))); 2607 2608 EXPECT_FALSE(reflection->HasField(message, F("optionalgroup" ))); 2609 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_message" ))); 2610 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_message"))); 2611 EXPECT_FALSE(reflection->HasField(message, F("optional_import_message" ))); 2612 2613 EXPECT_FALSE(reflection->HasField(message, F("optional_nested_enum" ))); 2614 EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum"))); 2615 EXPECT_FALSE(reflection->HasField(message, F("optional_import_enum" ))); 2616 2617 EXPECT_FALSE(reflection->HasField(message, F("optional_string_piece"))); 2618 EXPECT_FALSE(reflection->HasField(message, F("optional_cord"))); 2619 2620 // Optional fields without defaults are set to zero or something like it. 2621 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_int32" ))); 2622 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_int64" ))); 2623 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_uint32" ))); 2624 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_uint64" ))); 2625 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sint32" ))); 2626 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sint64" ))); 2627 EXPECT_EQ(0 , reflection->GetUInt32(message, F("optional_fixed32" ))); 2628 EXPECT_EQ(0 , reflection->GetUInt64(message, F("optional_fixed64" ))); 2629 EXPECT_EQ(0 , reflection->GetInt32 (message, F("optional_sfixed32"))); 2630 EXPECT_EQ(0 , reflection->GetInt64 (message, F("optional_sfixed64"))); 2631 EXPECT_EQ(0 , reflection->GetFloat (message, F("optional_float" ))); 2632 EXPECT_EQ(0 , reflection->GetDouble(message, F("optional_double" ))); 2633 EXPECT_EQ(false, reflection->GetBool (message, F("optional_bool" ))); 2634 EXPECT_EQ("" , reflection->GetString(message, F("optional_string" ))); 2635 EXPECT_EQ("" , reflection->GetString(message, F("optional_bytes" ))); 2636 2637 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string"), &scratch)); 2638 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_bytes" ), &scratch)); 2639 2640 // Embedded messages should also be clear. 2641 sub_message = &reflection->GetMessage(message, F("optionalgroup")); 2642 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, group_a_)); 2643 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, group_a_)); 2644 sub_message = &reflection->GetMessage(message, F("optional_nested_message")); 2645 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_)); 2646 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_)); 2647 sub_message = &reflection->GetMessage(message, F("optional_foreign_message")); 2648 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_)); 2649 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_)); 2650 sub_message = &reflection->GetMessage(message, F("optional_import_message")); 2651 EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_d_)); 2652 EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_d_)); 2653 2654 // Enums without defaults are set to the first value in the enum. 2655 EXPECT_EQ( nested_foo_, reflection->GetEnum(message, F("optional_nested_enum" ))); 2656 EXPECT_EQ(foreign_foo_, reflection->GetEnum(message, F("optional_foreign_enum"))); 2657 EXPECT_EQ( import_foo_, reflection->GetEnum(message, F("optional_import_enum" ))); 2658 2659 EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece"))); 2660 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string_piece"), &scratch)); 2661 2662 EXPECT_EQ("", reflection->GetString(message, F("optional_cord"))); 2663 EXPECT_EQ("", reflection->GetStringReference(message, F("optional_cord"), &scratch)); 2664 2665 // Repeated fields are empty. 2666 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int32" ))); 2667 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int64" ))); 2668 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint32" ))); 2669 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint64" ))); 2670 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint32" ))); 2671 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint64" ))); 2672 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed32" ))); 2673 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed64" ))); 2674 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed32"))); 2675 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed64"))); 2676 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_float" ))); 2677 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_double" ))); 2678 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bool" ))); 2679 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string" ))); 2680 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bytes" ))); 2681 2682 EXPECT_EQ(0, reflection->FieldSize(message, F("repeatedgroup" ))); 2683 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_message" ))); 2684 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_message"))); 2685 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_message" ))); 2686 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_enum" ))); 2687 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_enum" ))); 2688 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_enum" ))); 2689 2690 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string_piece"))); 2691 EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_cord"))); 2692 2693 // has_blah() should also be false for all default fields. 2694 EXPECT_FALSE(reflection->HasField(message, F("default_int32" ))); 2695 EXPECT_FALSE(reflection->HasField(message, F("default_int64" ))); 2696 EXPECT_FALSE(reflection->HasField(message, F("default_uint32" ))); 2697 EXPECT_FALSE(reflection->HasField(message, F("default_uint64" ))); 2698 EXPECT_FALSE(reflection->HasField(message, F("default_sint32" ))); 2699 EXPECT_FALSE(reflection->HasField(message, F("default_sint64" ))); 2700 EXPECT_FALSE(reflection->HasField(message, F("default_fixed32" ))); 2701 EXPECT_FALSE(reflection->HasField(message, F("default_fixed64" ))); 2702 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed32"))); 2703 EXPECT_FALSE(reflection->HasField(message, F("default_sfixed64"))); 2704 EXPECT_FALSE(reflection->HasField(message, F("default_float" ))); 2705 EXPECT_FALSE(reflection->HasField(message, F("default_double" ))); 2706 EXPECT_FALSE(reflection->HasField(message, F("default_bool" ))); 2707 EXPECT_FALSE(reflection->HasField(message, F("default_string" ))); 2708 EXPECT_FALSE(reflection->HasField(message, F("default_bytes" ))); 2709 2710 EXPECT_FALSE(reflection->HasField(message, F("default_nested_enum" ))); 2711 EXPECT_FALSE(reflection->HasField(message, F("default_foreign_enum"))); 2712 EXPECT_FALSE(reflection->HasField(message, F("default_import_enum" ))); 2713 2714 EXPECT_FALSE(reflection->HasField(message, F("default_string_piece"))); 2715 EXPECT_FALSE(reflection->HasField(message, F("default_cord"))); 2716 2717 // Fields with defaults have their default values (duh). 2718 EXPECT_EQ( 41 , reflection->GetInt32 (message, F("default_int32" ))); 2719 EXPECT_EQ( 42 , reflection->GetInt64 (message, F("default_int64" ))); 2720 EXPECT_EQ( 43 , reflection->GetUInt32(message, F("default_uint32" ))); 2721 EXPECT_EQ( 44 , reflection->GetUInt64(message, F("default_uint64" ))); 2722 EXPECT_EQ(-45 , reflection->GetInt32 (message, F("default_sint32" ))); 2723 EXPECT_EQ( 46 , reflection->GetInt64 (message, F("default_sint64" ))); 2724 EXPECT_EQ( 47 , reflection->GetUInt32(message, F("default_fixed32" ))); 2725 EXPECT_EQ( 48 , reflection->GetUInt64(message, F("default_fixed64" ))); 2726 EXPECT_EQ( 49 , reflection->GetInt32 (message, F("default_sfixed32"))); 2727 EXPECT_EQ(-50 , reflection->GetInt64 (message, F("default_sfixed64"))); 2728 EXPECT_EQ( 51.5 , reflection->GetFloat (message, F("default_float" ))); 2729 EXPECT_EQ( 52e3 , reflection->GetDouble(message, F("default_double" ))); 2730 EXPECT_EQ(true , reflection->GetBool (message, F("default_bool" ))); 2731 EXPECT_EQ("hello", reflection->GetString(message, F("default_string" ))); 2732 EXPECT_EQ("world", reflection->GetString(message, F("default_bytes" ))); 2733 2734 EXPECT_EQ("hello", reflection->GetStringReference(message, F("default_string"), &scratch)); 2735 EXPECT_EQ("world", reflection->GetStringReference(message, F("default_bytes" ), &scratch)); 2736 2737 EXPECT_EQ( nested_bar_, reflection->GetEnum(message, F("default_nested_enum" ))); 2738 EXPECT_EQ(foreign_bar_, reflection->GetEnum(message, F("default_foreign_enum"))); 2739 EXPECT_EQ( import_bar_, reflection->GetEnum(message, F("default_import_enum" ))); 2740 2741 EXPECT_EQ("abc", reflection->GetString(message, F("default_string_piece"))); 2742 EXPECT_EQ("abc", reflection->GetStringReference(message, F("default_string_piece"), &scratch)); 2743 2744 EXPECT_EQ("123", reflection->GetString(message, F("default_cord"))); 2745 EXPECT_EQ("123", reflection->GetStringReference(message, F("default_cord"), &scratch)); 2746 } 2747 2748 void TestUtil::ReflectionTester::ExpectPackedClearViaReflection( 2749 const Message& message) { 2750 const Reflection* reflection = message.GetReflection(); 2751 2752 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int32" ))); 2753 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_int64" ))); 2754 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint32" ))); 2755 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_uint64" ))); 2756 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint32" ))); 2757 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sint64" ))); 2758 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed32" ))); 2759 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_fixed64" ))); 2760 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed32"))); 2761 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_sfixed64"))); 2762 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_float" ))); 2763 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_double" ))); 2764 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_bool" ))); 2765 EXPECT_EQ(0, reflection->FieldSize(message, F("packed_enum" ))); 2766 } 2767 2768 // ------------------------------------------------------------------- 2769 2770 void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection( 2771 Message* message) { 2772 const Reflection* reflection = message->GetReflection(); 2773 Message* sub_message; 2774 2775 reflection->SetRepeatedInt32 (message, F("repeated_int32" ), 1, 501); 2776 reflection->SetRepeatedInt64 (message, F("repeated_int64" ), 1, 502); 2777 reflection->SetRepeatedUInt32(message, F("repeated_uint32" ), 1, 503); 2778 reflection->SetRepeatedUInt64(message, F("repeated_uint64" ), 1, 504); 2779 reflection->SetRepeatedInt32 (message, F("repeated_sint32" ), 1, 505); 2780 reflection->SetRepeatedInt64 (message, F("repeated_sint64" ), 1, 506); 2781 reflection->SetRepeatedUInt32(message, F("repeated_fixed32" ), 1, 507); 2782 reflection->SetRepeatedUInt64(message, F("repeated_fixed64" ), 1, 508); 2783 reflection->SetRepeatedInt32 (message, F("repeated_sfixed32"), 1, 509); 2784 reflection->SetRepeatedInt64 (message, F("repeated_sfixed64"), 1, 510); 2785 reflection->SetRepeatedFloat (message, F("repeated_float" ), 1, 511); 2786 reflection->SetRepeatedDouble(message, F("repeated_double" ), 1, 512); 2787 reflection->SetRepeatedBool (message, F("repeated_bool" ), 1, true); 2788 reflection->SetRepeatedString(message, F("repeated_string" ), 1, "515"); 2789 reflection->SetRepeatedString(message, F("repeated_bytes" ), 1, "516"); 2790 2791 sub_message = reflection->MutableRepeatedMessage(message, F("repeatedgroup"), 1); 2792 sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 517); 2793 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_nested_message"), 1); 2794 sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 518); 2795 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_foreign_message"), 1); 2796 sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 519); 2797 sub_message = reflection->MutableRepeatedMessage(message, F("repeated_import_message"), 1); 2798 sub_message->GetReflection()->SetInt32(sub_message, import_d_, 520); 2799 2800 reflection->SetRepeatedEnum(message, F("repeated_nested_enum" ), 1, nested_foo_); 2801 reflection->SetRepeatedEnum(message, F("repeated_foreign_enum"), 1, foreign_foo_); 2802 reflection->SetRepeatedEnum(message, F("repeated_import_enum" ), 1, import_foo_); 2803 2804 reflection->SetRepeatedString(message, F("repeated_string_piece"), 1, "524"); 2805 reflection->SetRepeatedString(message, F("repeated_cord"), 1, "525"); 2806 } 2807 2808 void TestUtil::ReflectionTester::ModifyPackedFieldsViaReflection( 2809 Message* message) { 2810 const Reflection* reflection = message->GetReflection(); 2811 reflection->SetRepeatedInt32 (message, F("packed_int32" ), 1, 801); 2812 reflection->SetRepeatedInt64 (message, F("packed_int64" ), 1, 802); 2813 reflection->SetRepeatedUInt32(message, F("packed_uint32" ), 1, 803); 2814 reflection->SetRepeatedUInt64(message, F("packed_uint64" ), 1, 804); 2815 reflection->SetRepeatedInt32 (message, F("packed_sint32" ), 1, 805); 2816 reflection->SetRepeatedInt64 (message, F("packed_sint64" ), 1, 806); 2817 reflection->SetRepeatedUInt32(message, F("packed_fixed32" ), 1, 807); 2818 reflection->SetRepeatedUInt64(message, F("packed_fixed64" ), 1, 808); 2819 reflection->SetRepeatedInt32 (message, F("packed_sfixed32"), 1, 809); 2820 reflection->SetRepeatedInt64 (message, F("packed_sfixed64"), 1, 810); 2821 reflection->SetRepeatedFloat (message, F("packed_float" ), 1, 811); 2822 reflection->SetRepeatedDouble(message, F("packed_double" ), 1, 812); 2823 reflection->SetRepeatedBool (message, F("packed_bool" ), 1, true); 2824 reflection->SetRepeatedEnum (message, F("packed_enum" ), 1, foreign_foo_); 2825 } 2826 2827 void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection(Message* message) { 2828 const Reflection* reflection = message->GetReflection(); 2829 2830 vector<const FieldDescriptor*> output; 2831 reflection->ListFields(*message, &output); 2832 for (int i=0; i<output.size(); ++i) { 2833 const FieldDescriptor* field = output[i]; 2834 if (!field->is_repeated()) continue; 2835 2836 reflection->RemoveLast(message, field); 2837 } 2838 } 2839 2840 void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) { 2841 const Reflection* reflection = message->GetReflection(); 2842 2843 vector<const FieldDescriptor*> output; 2844 reflection->ListFields(*message, &output); 2845 for (int i=0; i<output.size(); ++i) { 2846 const FieldDescriptor* field = output[i]; 2847 if (!field->is_repeated()) continue; 2848 2849 reflection->SwapElements(message, field, 0, 1); 2850 } 2851 } 2852 2853 } // namespace protobuf 2854 } // namespace google 2855
