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