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#include <google/protobuf/test_util_lite.h> 36#include <google/protobuf/stubs/common.h> 37 38 39#define EXPECT_TRUE GOOGLE_CHECK 40#define ASSERT_TRUE GOOGLE_CHECK 41#define EXPECT_FALSE(COND) GOOGLE_CHECK(!(COND)) 42#define EXPECT_EQ GOOGLE_CHECK_EQ 43#define ASSERT_EQ GOOGLE_CHECK_EQ 44 45namespace google { 46namespace protobuf { 47 48void TestUtilLite::SetAllFields(unittest::TestAllTypesLite* message) { 49 message->set_optional_int32 (101); 50 message->set_optional_int64 (102); 51 message->set_optional_uint32 (103); 52 message->set_optional_uint64 (104); 53 message->set_optional_sint32 (105); 54 message->set_optional_sint64 (106); 55 message->set_optional_fixed32 (107); 56 message->set_optional_fixed64 (108); 57 message->set_optional_sfixed32(109); 58 message->set_optional_sfixed64(110); 59 message->set_optional_float (111); 60 message->set_optional_double (112); 61 message->set_optional_bool (true); 62 message->set_optional_string ("115"); 63 message->set_optional_bytes ("116"); 64 65 message->mutable_optionalgroup ()->set_a(117); 66 message->mutable_optional_nested_message ()->set_bb(118); 67 message->mutable_optional_foreign_message ()->set_c(119); 68 message->mutable_optional_import_message ()->set_d(120); 69 message->mutable_optional_public_import_message()->set_e(126); 70 message->mutable_optional_lazy_message ()->set_bb(127); 71 72 message->set_optional_nested_enum (unittest::TestAllTypesLite::BAZ ); 73 message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ ); 74 message->set_optional_import_enum (unittest_import::IMPORT_LITE_BAZ); 75 76 77 // ----------------------------------------------------------------- 78 79 message->add_repeated_int32 (201); 80 message->add_repeated_int64 (202); 81 message->add_repeated_uint32 (203); 82 message->add_repeated_uint64 (204); 83 message->add_repeated_sint32 (205); 84 message->add_repeated_sint64 (206); 85 message->add_repeated_fixed32 (207); 86 message->add_repeated_fixed64 (208); 87 message->add_repeated_sfixed32(209); 88 message->add_repeated_sfixed64(210); 89 message->add_repeated_float (211); 90 message->add_repeated_double (212); 91 message->add_repeated_bool (true); 92 message->add_repeated_string ("215"); 93 message->add_repeated_bytes ("216"); 94 95 message->add_repeatedgroup ()->set_a(217); 96 message->add_repeated_nested_message ()->set_bb(218); 97 message->add_repeated_foreign_message()->set_c(219); 98 message->add_repeated_import_message ()->set_d(220); 99 message->add_repeated_lazy_message ()->set_bb(227); 100 101 message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAR ); 102 message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR ); 103 message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAR); 104 105 106 // Add a second one of each field. 107 message->add_repeated_int32 (301); 108 message->add_repeated_int64 (302); 109 message->add_repeated_uint32 (303); 110 message->add_repeated_uint64 (304); 111 message->add_repeated_sint32 (305); 112 message->add_repeated_sint64 (306); 113 message->add_repeated_fixed32 (307); 114 message->add_repeated_fixed64 (308); 115 message->add_repeated_sfixed32(309); 116 message->add_repeated_sfixed64(310); 117 message->add_repeated_float (311); 118 message->add_repeated_double (312); 119 message->add_repeated_bool (false); 120 message->add_repeated_string ("315"); 121 message->add_repeated_bytes ("316"); 122 123 message->add_repeatedgroup ()->set_a(317); 124 message->add_repeated_nested_message ()->set_bb(318); 125 message->add_repeated_foreign_message()->set_c(319); 126 message->add_repeated_import_message ()->set_d(320); 127 message->add_repeated_lazy_message ()->set_bb(327); 128 129 message->add_repeated_nested_enum (unittest::TestAllTypesLite::BAZ ); 130 message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ ); 131 message->add_repeated_import_enum (unittest_import::IMPORT_LITE_BAZ); 132 133 134 // ----------------------------------------------------------------- 135 136 message->set_default_int32 (401); 137 message->set_default_int64 (402); 138 message->set_default_uint32 (403); 139 message->set_default_uint64 (404); 140 message->set_default_sint32 (405); 141 message->set_default_sint64 (406); 142 message->set_default_fixed32 (407); 143 message->set_default_fixed64 (408); 144 message->set_default_sfixed32(409); 145 message->set_default_sfixed64(410); 146 message->set_default_float (411); 147 message->set_default_double (412); 148 message->set_default_bool (false); 149 message->set_default_string ("415"); 150 message->set_default_bytes ("416"); 151 152 message->set_default_nested_enum (unittest::TestAllTypesLite::FOO ); 153 message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO ); 154 message->set_default_import_enum (unittest_import::IMPORT_LITE_FOO); 155 156} 157 158// ------------------------------------------------------------------- 159 160void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) { 161 message->set_repeated_int32 (1, 501); 162 message->set_repeated_int64 (1, 502); 163 message->set_repeated_uint32 (1, 503); 164 message->set_repeated_uint64 (1, 504); 165 message->set_repeated_sint32 (1, 505); 166 message->set_repeated_sint64 (1, 506); 167 message->set_repeated_fixed32 (1, 507); 168 message->set_repeated_fixed64 (1, 508); 169 message->set_repeated_sfixed32(1, 509); 170 message->set_repeated_sfixed64(1, 510); 171 message->set_repeated_float (1, 511); 172 message->set_repeated_double (1, 512); 173 message->set_repeated_bool (1, true); 174 message->set_repeated_string (1, "515"); 175 message->set_repeated_bytes (1, "516"); 176 177 message->mutable_repeatedgroup (1)->set_a(517); 178 message->mutable_repeated_nested_message (1)->set_bb(518); 179 message->mutable_repeated_foreign_message(1)->set_c(519); 180 message->mutable_repeated_import_message (1)->set_d(520); 181 message->mutable_repeated_lazy_message (1)->set_bb(527); 182 183 message->set_repeated_nested_enum (1, unittest::TestAllTypesLite::FOO ); 184 message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO ); 185 message->set_repeated_import_enum (1, unittest_import::IMPORT_LITE_FOO); 186 187} 188 189// ------------------------------------------------------------------- 190 191void TestUtilLite::ExpectAllFieldsSet( 192 const unittest::TestAllTypesLite& message) { 193 EXPECT_TRUE(message.has_optional_int32 ()); 194 EXPECT_TRUE(message.has_optional_int64 ()); 195 EXPECT_TRUE(message.has_optional_uint32 ()); 196 EXPECT_TRUE(message.has_optional_uint64 ()); 197 EXPECT_TRUE(message.has_optional_sint32 ()); 198 EXPECT_TRUE(message.has_optional_sint64 ()); 199 EXPECT_TRUE(message.has_optional_fixed32 ()); 200 EXPECT_TRUE(message.has_optional_fixed64 ()); 201 EXPECT_TRUE(message.has_optional_sfixed32()); 202 EXPECT_TRUE(message.has_optional_sfixed64()); 203 EXPECT_TRUE(message.has_optional_float ()); 204 EXPECT_TRUE(message.has_optional_double ()); 205 EXPECT_TRUE(message.has_optional_bool ()); 206 EXPECT_TRUE(message.has_optional_string ()); 207 EXPECT_TRUE(message.has_optional_bytes ()); 208 209 EXPECT_TRUE(message.has_optionalgroup ()); 210 EXPECT_TRUE(message.has_optional_nested_message ()); 211 EXPECT_TRUE(message.has_optional_foreign_message ()); 212 EXPECT_TRUE(message.has_optional_import_message ()); 213 EXPECT_TRUE(message.has_optional_public_import_message()); 214 EXPECT_TRUE(message.has_optional_lazy_message ()); 215 216 EXPECT_TRUE(message.optionalgroup ().has_a()); 217 EXPECT_TRUE(message.optional_nested_message ().has_bb()); 218 EXPECT_TRUE(message.optional_foreign_message ().has_c()); 219 EXPECT_TRUE(message.optional_import_message ().has_d()); 220 EXPECT_TRUE(message.optional_public_import_message().has_e()); 221 EXPECT_TRUE(message.optional_lazy_message ().has_bb()); 222 223 EXPECT_TRUE(message.has_optional_nested_enum ()); 224 EXPECT_TRUE(message.has_optional_foreign_enum()); 225 EXPECT_TRUE(message.has_optional_import_enum ()); 226 227 228 EXPECT_EQ(101 , message.optional_int32 ()); 229 EXPECT_EQ(102 , message.optional_int64 ()); 230 EXPECT_EQ(103 , message.optional_uint32 ()); 231 EXPECT_EQ(104 , message.optional_uint64 ()); 232 EXPECT_EQ(105 , message.optional_sint32 ()); 233 EXPECT_EQ(106 , message.optional_sint64 ()); 234 EXPECT_EQ(107 , message.optional_fixed32 ()); 235 EXPECT_EQ(108 , message.optional_fixed64 ()); 236 EXPECT_EQ(109 , message.optional_sfixed32()); 237 EXPECT_EQ(110 , message.optional_sfixed64()); 238 EXPECT_EQ(111 , message.optional_float ()); 239 EXPECT_EQ(112 , message.optional_double ()); 240 EXPECT_EQ(true , message.optional_bool ()); 241 EXPECT_EQ("115", message.optional_string ()); 242 EXPECT_EQ("116", message.optional_bytes ()); 243 244 EXPECT_EQ(117, message.optionalgroup ().a()); 245 EXPECT_EQ(118, message.optional_nested_message ().bb()); 246 EXPECT_EQ(119, message.optional_foreign_message ().c()); 247 EXPECT_EQ(120, message.optional_import_message ().d()); 248 EXPECT_EQ(126, message.optional_public_import_message().e()); 249 EXPECT_EQ(127, message.optional_lazy_message ().bb()); 250 251 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.optional_nested_enum ()); 252 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.optional_foreign_enum()); 253 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum ()); 254 255 256 // ----------------------------------------------------------------- 257 258 ASSERT_EQ(2, message.repeated_int32_size ()); 259 ASSERT_EQ(2, message.repeated_int64_size ()); 260 ASSERT_EQ(2, message.repeated_uint32_size ()); 261 ASSERT_EQ(2, message.repeated_uint64_size ()); 262 ASSERT_EQ(2, message.repeated_sint32_size ()); 263 ASSERT_EQ(2, message.repeated_sint64_size ()); 264 ASSERT_EQ(2, message.repeated_fixed32_size ()); 265 ASSERT_EQ(2, message.repeated_fixed64_size ()); 266 ASSERT_EQ(2, message.repeated_sfixed32_size()); 267 ASSERT_EQ(2, message.repeated_sfixed64_size()); 268 ASSERT_EQ(2, message.repeated_float_size ()); 269 ASSERT_EQ(2, message.repeated_double_size ()); 270 ASSERT_EQ(2, message.repeated_bool_size ()); 271 ASSERT_EQ(2, message.repeated_string_size ()); 272 ASSERT_EQ(2, message.repeated_bytes_size ()); 273 274 ASSERT_EQ(2, message.repeatedgroup_size ()); 275 ASSERT_EQ(2, message.repeated_nested_message_size ()); 276 ASSERT_EQ(2, message.repeated_foreign_message_size()); 277 ASSERT_EQ(2, message.repeated_import_message_size ()); 278 ASSERT_EQ(2, message.repeated_lazy_message_size ()); 279 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 280 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 281 ASSERT_EQ(2, message.repeated_import_enum_size ()); 282 283 284 EXPECT_EQ(201 , message.repeated_int32 (0)); 285 EXPECT_EQ(202 , message.repeated_int64 (0)); 286 EXPECT_EQ(203 , message.repeated_uint32 (0)); 287 EXPECT_EQ(204 , message.repeated_uint64 (0)); 288 EXPECT_EQ(205 , message.repeated_sint32 (0)); 289 EXPECT_EQ(206 , message.repeated_sint64 (0)); 290 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 291 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 292 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 293 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 294 EXPECT_EQ(211 , message.repeated_float (0)); 295 EXPECT_EQ(212 , message.repeated_double (0)); 296 EXPECT_EQ(true , message.repeated_bool (0)); 297 EXPECT_EQ("215", message.repeated_string (0)); 298 EXPECT_EQ("216", message.repeated_bytes (0)); 299 300 EXPECT_EQ(217, message.repeatedgroup (0).a()); 301 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 302 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 303 EXPECT_EQ(220, message.repeated_import_message (0).d()); 304 EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); 305 306 307 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0)); 308 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0)); 309 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0)); 310 311 EXPECT_EQ(301 , message.repeated_int32 (1)); 312 EXPECT_EQ(302 , message.repeated_int64 (1)); 313 EXPECT_EQ(303 , message.repeated_uint32 (1)); 314 EXPECT_EQ(304 , message.repeated_uint64 (1)); 315 EXPECT_EQ(305 , message.repeated_sint32 (1)); 316 EXPECT_EQ(306 , message.repeated_sint64 (1)); 317 EXPECT_EQ(307 , message.repeated_fixed32 (1)); 318 EXPECT_EQ(308 , message.repeated_fixed64 (1)); 319 EXPECT_EQ(309 , message.repeated_sfixed32(1)); 320 EXPECT_EQ(310 , message.repeated_sfixed64(1)); 321 EXPECT_EQ(311 , message.repeated_float (1)); 322 EXPECT_EQ(312 , message.repeated_double (1)); 323 EXPECT_EQ(false, message.repeated_bool (1)); 324 EXPECT_EQ("315", message.repeated_string (1)); 325 EXPECT_EQ("316", message.repeated_bytes (1)); 326 327 EXPECT_EQ(317, message.repeatedgroup (1).a()); 328 EXPECT_EQ(318, message.repeated_nested_message (1).bb()); 329 EXPECT_EQ(319, message.repeated_foreign_message(1).c()); 330 EXPECT_EQ(320, message.repeated_import_message (1).d()); 331 EXPECT_EQ(327, message.repeated_lazy_message (1).bb()); 332 333 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.repeated_nested_enum (1)); 334 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.repeated_foreign_enum(1)); 335 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum (1)); 336 337 338 // ----------------------------------------------------------------- 339 340 EXPECT_TRUE(message.has_default_int32 ()); 341 EXPECT_TRUE(message.has_default_int64 ()); 342 EXPECT_TRUE(message.has_default_uint32 ()); 343 EXPECT_TRUE(message.has_default_uint64 ()); 344 EXPECT_TRUE(message.has_default_sint32 ()); 345 EXPECT_TRUE(message.has_default_sint64 ()); 346 EXPECT_TRUE(message.has_default_fixed32 ()); 347 EXPECT_TRUE(message.has_default_fixed64 ()); 348 EXPECT_TRUE(message.has_default_sfixed32()); 349 EXPECT_TRUE(message.has_default_sfixed64()); 350 EXPECT_TRUE(message.has_default_float ()); 351 EXPECT_TRUE(message.has_default_double ()); 352 EXPECT_TRUE(message.has_default_bool ()); 353 EXPECT_TRUE(message.has_default_string ()); 354 EXPECT_TRUE(message.has_default_bytes ()); 355 356 EXPECT_TRUE(message.has_default_nested_enum ()); 357 EXPECT_TRUE(message.has_default_foreign_enum()); 358 EXPECT_TRUE(message.has_default_import_enum ()); 359 360 361 EXPECT_EQ(401 , message.default_int32 ()); 362 EXPECT_EQ(402 , message.default_int64 ()); 363 EXPECT_EQ(403 , message.default_uint32 ()); 364 EXPECT_EQ(404 , message.default_uint64 ()); 365 EXPECT_EQ(405 , message.default_sint32 ()); 366 EXPECT_EQ(406 , message.default_sint64 ()); 367 EXPECT_EQ(407 , message.default_fixed32 ()); 368 EXPECT_EQ(408 , message.default_fixed64 ()); 369 EXPECT_EQ(409 , message.default_sfixed32()); 370 EXPECT_EQ(410 , message.default_sfixed64()); 371 EXPECT_EQ(411 , message.default_float ()); 372 EXPECT_EQ(412 , message.default_double ()); 373 EXPECT_EQ(false, message.default_bool ()); 374 EXPECT_EQ("415", message.default_string ()); 375 EXPECT_EQ("416", message.default_bytes ()); 376 377 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.default_nested_enum ()); 378 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.default_foreign_enum()); 379 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum ()); 380 381} 382 383// ------------------------------------------------------------------- 384 385void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) { 386 // has_blah() should initially be false for all optional fields. 387 EXPECT_FALSE(message.has_optional_int32 ()); 388 EXPECT_FALSE(message.has_optional_int64 ()); 389 EXPECT_FALSE(message.has_optional_uint32 ()); 390 EXPECT_FALSE(message.has_optional_uint64 ()); 391 EXPECT_FALSE(message.has_optional_sint32 ()); 392 EXPECT_FALSE(message.has_optional_sint64 ()); 393 EXPECT_FALSE(message.has_optional_fixed32 ()); 394 EXPECT_FALSE(message.has_optional_fixed64 ()); 395 EXPECT_FALSE(message.has_optional_sfixed32()); 396 EXPECT_FALSE(message.has_optional_sfixed64()); 397 EXPECT_FALSE(message.has_optional_float ()); 398 EXPECT_FALSE(message.has_optional_double ()); 399 EXPECT_FALSE(message.has_optional_bool ()); 400 EXPECT_FALSE(message.has_optional_string ()); 401 EXPECT_FALSE(message.has_optional_bytes ()); 402 403 EXPECT_FALSE(message.has_optionalgroup ()); 404 EXPECT_FALSE(message.has_optional_nested_message ()); 405 EXPECT_FALSE(message.has_optional_foreign_message ()); 406 EXPECT_FALSE(message.has_optional_import_message ()); 407 EXPECT_FALSE(message.has_optional_public_import_message()); 408 EXPECT_FALSE(message.has_optional_lazy_message ()); 409 410 EXPECT_FALSE(message.has_optional_nested_enum ()); 411 EXPECT_FALSE(message.has_optional_foreign_enum()); 412 EXPECT_FALSE(message.has_optional_import_enum ()); 413 414 415 // Optional fields without defaults are set to zero or something like it. 416 EXPECT_EQ(0 , message.optional_int32 ()); 417 EXPECT_EQ(0 , message.optional_int64 ()); 418 EXPECT_EQ(0 , message.optional_uint32 ()); 419 EXPECT_EQ(0 , message.optional_uint64 ()); 420 EXPECT_EQ(0 , message.optional_sint32 ()); 421 EXPECT_EQ(0 , message.optional_sint64 ()); 422 EXPECT_EQ(0 , message.optional_fixed32 ()); 423 EXPECT_EQ(0 , message.optional_fixed64 ()); 424 EXPECT_EQ(0 , message.optional_sfixed32()); 425 EXPECT_EQ(0 , message.optional_sfixed64()); 426 EXPECT_EQ(0 , message.optional_float ()); 427 EXPECT_EQ(0 , message.optional_double ()); 428 EXPECT_EQ(false, message.optional_bool ()); 429 EXPECT_EQ("" , message.optional_string ()); 430 EXPECT_EQ("" , message.optional_bytes ()); 431 432 // Embedded messages should also be clear. 433 EXPECT_FALSE(message.optionalgroup ().has_a()); 434 EXPECT_FALSE(message.optional_nested_message ().has_bb()); 435 EXPECT_FALSE(message.optional_foreign_message ().has_c()); 436 EXPECT_FALSE(message.optional_import_message ().has_d()); 437 EXPECT_FALSE(message.optional_public_import_message().has_e()); 438 EXPECT_FALSE(message.optional_lazy_message ().has_bb()); 439 440 EXPECT_EQ(0, message.optionalgroup ().a()); 441 EXPECT_EQ(0, message.optional_nested_message ().bb()); 442 EXPECT_EQ(0, message.optional_foreign_message().c()); 443 EXPECT_EQ(0, message.optional_import_message ().d()); 444 445 // Enums without defaults are set to the first value in the enum. 446 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.optional_nested_enum ()); 447 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.optional_foreign_enum()); 448 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum ()); 449 450 451 // Repeated fields are empty. 452 EXPECT_EQ(0, message.repeated_int32_size ()); 453 EXPECT_EQ(0, message.repeated_int64_size ()); 454 EXPECT_EQ(0, message.repeated_uint32_size ()); 455 EXPECT_EQ(0, message.repeated_uint64_size ()); 456 EXPECT_EQ(0, message.repeated_sint32_size ()); 457 EXPECT_EQ(0, message.repeated_sint64_size ()); 458 EXPECT_EQ(0, message.repeated_fixed32_size ()); 459 EXPECT_EQ(0, message.repeated_fixed64_size ()); 460 EXPECT_EQ(0, message.repeated_sfixed32_size()); 461 EXPECT_EQ(0, message.repeated_sfixed64_size()); 462 EXPECT_EQ(0, message.repeated_float_size ()); 463 EXPECT_EQ(0, message.repeated_double_size ()); 464 EXPECT_EQ(0, message.repeated_bool_size ()); 465 EXPECT_EQ(0, message.repeated_string_size ()); 466 EXPECT_EQ(0, message.repeated_bytes_size ()); 467 468 EXPECT_EQ(0, message.repeatedgroup_size ()); 469 EXPECT_EQ(0, message.repeated_nested_message_size ()); 470 EXPECT_EQ(0, message.repeated_foreign_message_size()); 471 EXPECT_EQ(0, message.repeated_import_message_size ()); 472 EXPECT_EQ(0, message.repeated_lazy_message_size ()); 473 EXPECT_EQ(0, message.repeated_nested_enum_size ()); 474 EXPECT_EQ(0, message.repeated_foreign_enum_size ()); 475 EXPECT_EQ(0, message.repeated_import_enum_size ()); 476 477 478 // has_blah() should also be false for all default fields. 479 EXPECT_FALSE(message.has_default_int32 ()); 480 EXPECT_FALSE(message.has_default_int64 ()); 481 EXPECT_FALSE(message.has_default_uint32 ()); 482 EXPECT_FALSE(message.has_default_uint64 ()); 483 EXPECT_FALSE(message.has_default_sint32 ()); 484 EXPECT_FALSE(message.has_default_sint64 ()); 485 EXPECT_FALSE(message.has_default_fixed32 ()); 486 EXPECT_FALSE(message.has_default_fixed64 ()); 487 EXPECT_FALSE(message.has_default_sfixed32()); 488 EXPECT_FALSE(message.has_default_sfixed64()); 489 EXPECT_FALSE(message.has_default_float ()); 490 EXPECT_FALSE(message.has_default_double ()); 491 EXPECT_FALSE(message.has_default_bool ()); 492 EXPECT_FALSE(message.has_default_string ()); 493 EXPECT_FALSE(message.has_default_bytes ()); 494 495 EXPECT_FALSE(message.has_default_nested_enum ()); 496 EXPECT_FALSE(message.has_default_foreign_enum()); 497 EXPECT_FALSE(message.has_default_import_enum ()); 498 499 500 // Fields with defaults have their default values (duh). 501 EXPECT_EQ( 41 , message.default_int32 ()); 502 EXPECT_EQ( 42 , message.default_int64 ()); 503 EXPECT_EQ( 43 , message.default_uint32 ()); 504 EXPECT_EQ( 44 , message.default_uint64 ()); 505 EXPECT_EQ(-45 , message.default_sint32 ()); 506 EXPECT_EQ( 46 , message.default_sint64 ()); 507 EXPECT_EQ( 47 , message.default_fixed32 ()); 508 EXPECT_EQ( 48 , message.default_fixed64 ()); 509 EXPECT_EQ( 49 , message.default_sfixed32()); 510 EXPECT_EQ(-50 , message.default_sfixed64()); 511 EXPECT_EQ( 51.5 , message.default_float ()); 512 EXPECT_EQ( 52e3 , message.default_double ()); 513 EXPECT_EQ(true , message.default_bool ()); 514 EXPECT_EQ("hello", message.default_string ()); 515 EXPECT_EQ("world", message.default_bytes ()); 516 517 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.default_nested_enum ()); 518 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.default_foreign_enum()); 519 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum ()); 520 521} 522 523// ------------------------------------------------------------------- 524 525void TestUtilLite::ExpectRepeatedFieldsModified( 526 const unittest::TestAllTypesLite& message) { 527 // ModifyRepeatedFields only sets the second repeated element of each 528 // field. In addition to verifying this, we also verify that the first 529 // element and size were *not* modified. 530 ASSERT_EQ(2, message.repeated_int32_size ()); 531 ASSERT_EQ(2, message.repeated_int64_size ()); 532 ASSERT_EQ(2, message.repeated_uint32_size ()); 533 ASSERT_EQ(2, message.repeated_uint64_size ()); 534 ASSERT_EQ(2, message.repeated_sint32_size ()); 535 ASSERT_EQ(2, message.repeated_sint64_size ()); 536 ASSERT_EQ(2, message.repeated_fixed32_size ()); 537 ASSERT_EQ(2, message.repeated_fixed64_size ()); 538 ASSERT_EQ(2, message.repeated_sfixed32_size()); 539 ASSERT_EQ(2, message.repeated_sfixed64_size()); 540 ASSERT_EQ(2, message.repeated_float_size ()); 541 ASSERT_EQ(2, message.repeated_double_size ()); 542 ASSERT_EQ(2, message.repeated_bool_size ()); 543 ASSERT_EQ(2, message.repeated_string_size ()); 544 ASSERT_EQ(2, message.repeated_bytes_size ()); 545 546 ASSERT_EQ(2, message.repeatedgroup_size ()); 547 ASSERT_EQ(2, message.repeated_nested_message_size ()); 548 ASSERT_EQ(2, message.repeated_foreign_message_size()); 549 ASSERT_EQ(2, message.repeated_import_message_size ()); 550 ASSERT_EQ(2, message.repeated_lazy_message_size ()); 551 ASSERT_EQ(2, message.repeated_nested_enum_size ()); 552 ASSERT_EQ(2, message.repeated_foreign_enum_size ()); 553 ASSERT_EQ(2, message.repeated_import_enum_size ()); 554 555 556 EXPECT_EQ(201 , message.repeated_int32 (0)); 557 EXPECT_EQ(202 , message.repeated_int64 (0)); 558 EXPECT_EQ(203 , message.repeated_uint32 (0)); 559 EXPECT_EQ(204 , message.repeated_uint64 (0)); 560 EXPECT_EQ(205 , message.repeated_sint32 (0)); 561 EXPECT_EQ(206 , message.repeated_sint64 (0)); 562 EXPECT_EQ(207 , message.repeated_fixed32 (0)); 563 EXPECT_EQ(208 , message.repeated_fixed64 (0)); 564 EXPECT_EQ(209 , message.repeated_sfixed32(0)); 565 EXPECT_EQ(210 , message.repeated_sfixed64(0)); 566 EXPECT_EQ(211 , message.repeated_float (0)); 567 EXPECT_EQ(212 , message.repeated_double (0)); 568 EXPECT_EQ(true , message.repeated_bool (0)); 569 EXPECT_EQ("215", message.repeated_string (0)); 570 EXPECT_EQ("216", message.repeated_bytes (0)); 571 572 EXPECT_EQ(217, message.repeatedgroup (0).a()); 573 EXPECT_EQ(218, message.repeated_nested_message (0).bb()); 574 EXPECT_EQ(219, message.repeated_foreign_message(0).c()); 575 EXPECT_EQ(220, message.repeated_import_message (0).d()); 576 EXPECT_EQ(227, message.repeated_lazy_message (0).bb()); 577 578 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.repeated_nested_enum (0)); 579 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.repeated_foreign_enum(0)); 580 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum (0)); 581 582 583 // Actually verify the second (modified) elements now. 584 EXPECT_EQ(501 , message.repeated_int32 (1)); 585 EXPECT_EQ(502 , message.repeated_int64 (1)); 586 EXPECT_EQ(503 , message.repeated_uint32 (1)); 587 EXPECT_EQ(504 , message.repeated_uint64 (1)); 588 EXPECT_EQ(505 , message.repeated_sint32 (1)); 589 EXPECT_EQ(506 , message.repeated_sint64 (1)); 590 EXPECT_EQ(507 , message.repeated_fixed32 (1)); 591 EXPECT_EQ(508 , message.repeated_fixed64 (1)); 592 EXPECT_EQ(509 , message.repeated_sfixed32(1)); 593 EXPECT_EQ(510 , message.repeated_sfixed64(1)); 594 EXPECT_EQ(511 , message.repeated_float (1)); 595 EXPECT_EQ(512 , message.repeated_double (1)); 596 EXPECT_EQ(true , message.repeated_bool (1)); 597 EXPECT_EQ("515", message.repeated_string (1)); 598 EXPECT_EQ("516", message.repeated_bytes (1)); 599 600 EXPECT_EQ(517, message.repeatedgroup (1).a()); 601 EXPECT_EQ(518, message.repeated_nested_message (1).bb()); 602 EXPECT_EQ(519, message.repeated_foreign_message(1).c()); 603 EXPECT_EQ(520, message.repeated_import_message (1).d()); 604 EXPECT_EQ(527, message.repeated_lazy_message (1).bb()); 605 606 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.repeated_nested_enum (1)); 607 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.repeated_foreign_enum(1)); 608 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum (1)); 609 610} 611 612// ------------------------------------------------------------------- 613 614void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) { 615 message->add_packed_int32 (601); 616 message->add_packed_int64 (602); 617 message->add_packed_uint32 (603); 618 message->add_packed_uint64 (604); 619 message->add_packed_sint32 (605); 620 message->add_packed_sint64 (606); 621 message->add_packed_fixed32 (607); 622 message->add_packed_fixed64 (608); 623 message->add_packed_sfixed32(609); 624 message->add_packed_sfixed64(610); 625 message->add_packed_float (611); 626 message->add_packed_double (612); 627 message->add_packed_bool (true); 628 message->add_packed_enum (unittest::FOREIGN_LITE_BAR); 629 // add a second one of each field 630 message->add_packed_int32 (701); 631 message->add_packed_int64 (702); 632 message->add_packed_uint32 (703); 633 message->add_packed_uint64 (704); 634 message->add_packed_sint32 (705); 635 message->add_packed_sint64 (706); 636 message->add_packed_fixed32 (707); 637 message->add_packed_fixed64 (708); 638 message->add_packed_sfixed32(709); 639 message->add_packed_sfixed64(710); 640 message->add_packed_float (711); 641 message->add_packed_double (712); 642 message->add_packed_bool (false); 643 message->add_packed_enum (unittest::FOREIGN_LITE_BAZ); 644} 645 646// ------------------------------------------------------------------- 647 648void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) { 649 message->set_packed_int32 (1, 801); 650 message->set_packed_int64 (1, 802); 651 message->set_packed_uint32 (1, 803); 652 message->set_packed_uint64 (1, 804); 653 message->set_packed_sint32 (1, 805); 654 message->set_packed_sint64 (1, 806); 655 message->set_packed_fixed32 (1, 807); 656 message->set_packed_fixed64 (1, 808); 657 message->set_packed_sfixed32(1, 809); 658 message->set_packed_sfixed64(1, 810); 659 message->set_packed_float (1, 811); 660 message->set_packed_double (1, 812); 661 message->set_packed_bool (1, true); 662 message->set_packed_enum (1, unittest::FOREIGN_LITE_FOO); 663} 664 665// ------------------------------------------------------------------- 666 667void TestUtilLite::ExpectPackedFieldsSet( 668 const unittest::TestPackedTypesLite& message) { 669 ASSERT_EQ(2, message.packed_int32_size ()); 670 ASSERT_EQ(2, message.packed_int64_size ()); 671 ASSERT_EQ(2, message.packed_uint32_size ()); 672 ASSERT_EQ(2, message.packed_uint64_size ()); 673 ASSERT_EQ(2, message.packed_sint32_size ()); 674 ASSERT_EQ(2, message.packed_sint64_size ()); 675 ASSERT_EQ(2, message.packed_fixed32_size ()); 676 ASSERT_EQ(2, message.packed_fixed64_size ()); 677 ASSERT_EQ(2, message.packed_sfixed32_size()); 678 ASSERT_EQ(2, message.packed_sfixed64_size()); 679 ASSERT_EQ(2, message.packed_float_size ()); 680 ASSERT_EQ(2, message.packed_double_size ()); 681 ASSERT_EQ(2, message.packed_bool_size ()); 682 ASSERT_EQ(2, message.packed_enum_size ()); 683 684 EXPECT_EQ(601 , message.packed_int32 (0)); 685 EXPECT_EQ(602 , message.packed_int64 (0)); 686 EXPECT_EQ(603 , message.packed_uint32 (0)); 687 EXPECT_EQ(604 , message.packed_uint64 (0)); 688 EXPECT_EQ(605 , message.packed_sint32 (0)); 689 EXPECT_EQ(606 , message.packed_sint64 (0)); 690 EXPECT_EQ(607 , message.packed_fixed32 (0)); 691 EXPECT_EQ(608 , message.packed_fixed64 (0)); 692 EXPECT_EQ(609 , message.packed_sfixed32(0)); 693 EXPECT_EQ(610 , message.packed_sfixed64(0)); 694 EXPECT_EQ(611 , message.packed_float (0)); 695 EXPECT_EQ(612 , message.packed_double (0)); 696 EXPECT_EQ(true , message.packed_bool (0)); 697 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0)); 698 699 EXPECT_EQ(701 , message.packed_int32 (1)); 700 EXPECT_EQ(702 , message.packed_int64 (1)); 701 EXPECT_EQ(703 , message.packed_uint32 (1)); 702 EXPECT_EQ(704 , message.packed_uint64 (1)); 703 EXPECT_EQ(705 , message.packed_sint32 (1)); 704 EXPECT_EQ(706 , message.packed_sint64 (1)); 705 EXPECT_EQ(707 , message.packed_fixed32 (1)); 706 EXPECT_EQ(708 , message.packed_fixed64 (1)); 707 EXPECT_EQ(709 , message.packed_sfixed32(1)); 708 EXPECT_EQ(710 , message.packed_sfixed64(1)); 709 EXPECT_EQ(711 , message.packed_float (1)); 710 EXPECT_EQ(712 , message.packed_double (1)); 711 EXPECT_EQ(false, message.packed_bool (1)); 712 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1)); 713} 714 715// ------------------------------------------------------------------- 716 717void TestUtilLite::ExpectPackedClear( 718 const unittest::TestPackedTypesLite& message) { 719 // Packed repeated fields are empty. 720 EXPECT_EQ(0, message.packed_int32_size ()); 721 EXPECT_EQ(0, message.packed_int64_size ()); 722 EXPECT_EQ(0, message.packed_uint32_size ()); 723 EXPECT_EQ(0, message.packed_uint64_size ()); 724 EXPECT_EQ(0, message.packed_sint32_size ()); 725 EXPECT_EQ(0, message.packed_sint64_size ()); 726 EXPECT_EQ(0, message.packed_fixed32_size ()); 727 EXPECT_EQ(0, message.packed_fixed64_size ()); 728 EXPECT_EQ(0, message.packed_sfixed32_size()); 729 EXPECT_EQ(0, message.packed_sfixed64_size()); 730 EXPECT_EQ(0, message.packed_float_size ()); 731 EXPECT_EQ(0, message.packed_double_size ()); 732 EXPECT_EQ(0, message.packed_bool_size ()); 733 EXPECT_EQ(0, message.packed_enum_size ()); 734} 735 736// ------------------------------------------------------------------- 737 738void TestUtilLite::ExpectPackedFieldsModified( 739 const unittest::TestPackedTypesLite& message) { 740 // Do the same for packed repeated fields. 741 ASSERT_EQ(2, message.packed_int32_size ()); 742 ASSERT_EQ(2, message.packed_int64_size ()); 743 ASSERT_EQ(2, message.packed_uint32_size ()); 744 ASSERT_EQ(2, message.packed_uint64_size ()); 745 ASSERT_EQ(2, message.packed_sint32_size ()); 746 ASSERT_EQ(2, message.packed_sint64_size ()); 747 ASSERT_EQ(2, message.packed_fixed32_size ()); 748 ASSERT_EQ(2, message.packed_fixed64_size ()); 749 ASSERT_EQ(2, message.packed_sfixed32_size()); 750 ASSERT_EQ(2, message.packed_sfixed64_size()); 751 ASSERT_EQ(2, message.packed_float_size ()); 752 ASSERT_EQ(2, message.packed_double_size ()); 753 ASSERT_EQ(2, message.packed_bool_size ()); 754 ASSERT_EQ(2, message.packed_enum_size ()); 755 756 EXPECT_EQ(601 , message.packed_int32 (0)); 757 EXPECT_EQ(602 , message.packed_int64 (0)); 758 EXPECT_EQ(603 , message.packed_uint32 (0)); 759 EXPECT_EQ(604 , message.packed_uint64 (0)); 760 EXPECT_EQ(605 , message.packed_sint32 (0)); 761 EXPECT_EQ(606 , message.packed_sint64 (0)); 762 EXPECT_EQ(607 , message.packed_fixed32 (0)); 763 EXPECT_EQ(608 , message.packed_fixed64 (0)); 764 EXPECT_EQ(609 , message.packed_sfixed32(0)); 765 EXPECT_EQ(610 , message.packed_sfixed64(0)); 766 EXPECT_EQ(611 , message.packed_float (0)); 767 EXPECT_EQ(612 , message.packed_double (0)); 768 EXPECT_EQ(true , message.packed_bool (0)); 769 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0)); 770 // Actually verify the second (modified) elements now. 771 EXPECT_EQ(801 , message.packed_int32 (1)); 772 EXPECT_EQ(802 , message.packed_int64 (1)); 773 EXPECT_EQ(803 , message.packed_uint32 (1)); 774 EXPECT_EQ(804 , message.packed_uint64 (1)); 775 EXPECT_EQ(805 , message.packed_sint32 (1)); 776 EXPECT_EQ(806 , message.packed_sint64 (1)); 777 EXPECT_EQ(807 , message.packed_fixed32 (1)); 778 EXPECT_EQ(808 , message.packed_fixed64 (1)); 779 EXPECT_EQ(809 , message.packed_sfixed32(1)); 780 EXPECT_EQ(810 , message.packed_sfixed64(1)); 781 EXPECT_EQ(811 , message.packed_float (1)); 782 EXPECT_EQ(812 , message.packed_double (1)); 783 EXPECT_EQ(true , message.packed_bool (1)); 784 EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1)); 785} 786 787// =================================================================== 788// Extensions 789// 790// All this code is exactly equivalent to the above code except that it's 791// manipulating extension fields instead of normal ones. 792// 793// I gave up on the 80-char limit here. Sorry. 794 795void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) { 796 message->SetExtension(unittest::optional_int32_extension_lite , 101); 797 message->SetExtension(unittest::optional_int64_extension_lite , 102); 798 message->SetExtension(unittest::optional_uint32_extension_lite , 103); 799 message->SetExtension(unittest::optional_uint64_extension_lite , 104); 800 message->SetExtension(unittest::optional_sint32_extension_lite , 105); 801 message->SetExtension(unittest::optional_sint64_extension_lite , 106); 802 message->SetExtension(unittest::optional_fixed32_extension_lite , 107); 803 message->SetExtension(unittest::optional_fixed64_extension_lite , 108); 804 message->SetExtension(unittest::optional_sfixed32_extension_lite, 109); 805 message->SetExtension(unittest::optional_sfixed64_extension_lite, 110); 806 message->SetExtension(unittest::optional_float_extension_lite , 111); 807 message->SetExtension(unittest::optional_double_extension_lite , 112); 808 message->SetExtension(unittest::optional_bool_extension_lite , true); 809 message->SetExtension(unittest::optional_string_extension_lite , "115"); 810 message->SetExtension(unittest::optional_bytes_extension_lite , "116"); 811 812 message->MutableExtension(unittest::optionalgroup_extension_lite )->set_a(117); 813 message->MutableExtension(unittest::optional_nested_message_extension_lite )->set_bb(118); 814 message->MutableExtension(unittest::optional_foreign_message_extension_lite )->set_c(119); 815 message->MutableExtension(unittest::optional_import_message_extension_lite )->set_d(120); 816 message->MutableExtension(unittest::optional_public_import_message_extension_lite)->set_e(126); 817 message->MutableExtension(unittest::optional_lazy_message_extension_lite )->set_bb(127); 818 819 message->SetExtension(unittest::optional_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ ); 820 message->SetExtension(unittest::optional_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ ); 821 message->SetExtension(unittest::optional_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ); 822 823 824 // ----------------------------------------------------------------- 825 826 message->AddExtension(unittest::repeated_int32_extension_lite , 201); 827 message->AddExtension(unittest::repeated_int64_extension_lite , 202); 828 message->AddExtension(unittest::repeated_uint32_extension_lite , 203); 829 message->AddExtension(unittest::repeated_uint64_extension_lite , 204); 830 message->AddExtension(unittest::repeated_sint32_extension_lite , 205); 831 message->AddExtension(unittest::repeated_sint64_extension_lite , 206); 832 message->AddExtension(unittest::repeated_fixed32_extension_lite , 207); 833 message->AddExtension(unittest::repeated_fixed64_extension_lite , 208); 834 message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209); 835 message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210); 836 message->AddExtension(unittest::repeated_float_extension_lite , 211); 837 message->AddExtension(unittest::repeated_double_extension_lite , 212); 838 message->AddExtension(unittest::repeated_bool_extension_lite , true); 839 message->AddExtension(unittest::repeated_string_extension_lite , "215"); 840 message->AddExtension(unittest::repeated_bytes_extension_lite , "216"); 841 842 message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(217); 843 message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(218); 844 message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(219); 845 message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(220); 846 message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(227); 847 848 message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAR ); 849 message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAR ); 850 message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAR); 851 852 853 // Add a second one of each field. 854 message->AddExtension(unittest::repeated_int32_extension_lite , 301); 855 message->AddExtension(unittest::repeated_int64_extension_lite , 302); 856 message->AddExtension(unittest::repeated_uint32_extension_lite , 303); 857 message->AddExtension(unittest::repeated_uint64_extension_lite , 304); 858 message->AddExtension(unittest::repeated_sint32_extension_lite , 305); 859 message->AddExtension(unittest::repeated_sint64_extension_lite , 306); 860 message->AddExtension(unittest::repeated_fixed32_extension_lite , 307); 861 message->AddExtension(unittest::repeated_fixed64_extension_lite , 308); 862 message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309); 863 message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310); 864 message->AddExtension(unittest::repeated_float_extension_lite , 311); 865 message->AddExtension(unittest::repeated_double_extension_lite , 312); 866 message->AddExtension(unittest::repeated_bool_extension_lite , false); 867 message->AddExtension(unittest::repeated_string_extension_lite , "315"); 868 message->AddExtension(unittest::repeated_bytes_extension_lite , "316"); 869 870 message->AddExtension(unittest::repeatedgroup_extension_lite )->set_a(317); 871 message->AddExtension(unittest::repeated_nested_message_extension_lite )->set_bb(318); 872 message->AddExtension(unittest::repeated_foreign_message_extension_lite)->set_c(319); 873 message->AddExtension(unittest::repeated_import_message_extension_lite )->set_d(320); 874 message->AddExtension(unittest::repeated_lazy_message_extension_lite )->set_bb(327); 875 876 message->AddExtension(unittest::repeated_nested_enum_extension_lite , unittest::TestAllTypesLite::BAZ ); 877 message->AddExtension(unittest::repeated_foreign_enum_extension_lite, unittest::FOREIGN_LITE_BAZ ); 878 message->AddExtension(unittest::repeated_import_enum_extension_lite , unittest_import::IMPORT_LITE_BAZ); 879 880 881 // ----------------------------------------------------------------- 882 883 message->SetExtension(unittest::default_int32_extension_lite , 401); 884 message->SetExtension(unittest::default_int64_extension_lite , 402); 885 message->SetExtension(unittest::default_uint32_extension_lite , 403); 886 message->SetExtension(unittest::default_uint64_extension_lite , 404); 887 message->SetExtension(unittest::default_sint32_extension_lite , 405); 888 message->SetExtension(unittest::default_sint64_extension_lite , 406); 889 message->SetExtension(unittest::default_fixed32_extension_lite , 407); 890 message->SetExtension(unittest::default_fixed64_extension_lite , 408); 891 message->SetExtension(unittest::default_sfixed32_extension_lite, 409); 892 message->SetExtension(unittest::default_sfixed64_extension_lite, 410); 893 message->SetExtension(unittest::default_float_extension_lite , 411); 894 message->SetExtension(unittest::default_double_extension_lite , 412); 895 message->SetExtension(unittest::default_bool_extension_lite , false); 896 message->SetExtension(unittest::default_string_extension_lite , "415"); 897 message->SetExtension(unittest::default_bytes_extension_lite , "416"); 898 899 message->SetExtension(unittest::default_nested_enum_extension_lite , unittest::TestAllTypesLite::FOO ); 900 message->SetExtension(unittest::default_foreign_enum_extension_lite, unittest::FOREIGN_LITE_FOO ); 901 message->SetExtension(unittest::default_import_enum_extension_lite , unittest_import::IMPORT_LITE_FOO); 902 903} 904 905// ------------------------------------------------------------------- 906 907void TestUtilLite::ModifyRepeatedExtensions( 908 unittest::TestAllExtensionsLite* message) { 909 message->SetExtension(unittest::repeated_int32_extension_lite , 1, 501); 910 message->SetExtension(unittest::repeated_int64_extension_lite , 1, 502); 911 message->SetExtension(unittest::repeated_uint32_extension_lite , 1, 503); 912 message->SetExtension(unittest::repeated_uint64_extension_lite , 1, 504); 913 message->SetExtension(unittest::repeated_sint32_extension_lite , 1, 505); 914 message->SetExtension(unittest::repeated_sint64_extension_lite , 1, 506); 915 message->SetExtension(unittest::repeated_fixed32_extension_lite , 1, 507); 916 message->SetExtension(unittest::repeated_fixed64_extension_lite , 1, 508); 917 message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509); 918 message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510); 919 message->SetExtension(unittest::repeated_float_extension_lite , 1, 511); 920 message->SetExtension(unittest::repeated_double_extension_lite , 1, 512); 921 message->SetExtension(unittest::repeated_bool_extension_lite , 1, true); 922 message->SetExtension(unittest::repeated_string_extension_lite , 1, "515"); 923 message->SetExtension(unittest::repeated_bytes_extension_lite , 1, "516"); 924 925 message->MutableExtension(unittest::repeatedgroup_extension_lite , 1)->set_a(517); 926 message->MutableExtension(unittest::repeated_nested_message_extension_lite , 1)->set_bb(518); 927 message->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)->set_c(519); 928 message->MutableExtension(unittest::repeated_import_message_extension_lite , 1)->set_d(520); 929 message->MutableExtension(unittest::repeated_lazy_message_extension_lite , 1)->set_bb(527); 930 931 message->SetExtension(unittest::repeated_nested_enum_extension_lite , 1, unittest::TestAllTypesLite::FOO ); 932 message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1, unittest::FOREIGN_LITE_FOO ); 933 message->SetExtension(unittest::repeated_import_enum_extension_lite , 1, unittest_import::IMPORT_LITE_FOO); 934 935} 936 937// ------------------------------------------------------------------- 938 939void TestUtilLite::ExpectAllExtensionsSet( 940 const unittest::TestAllExtensionsLite& message) { 941 EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite )); 942 EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite )); 943 EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite )); 944 EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite )); 945 EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite )); 946 EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite )); 947 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite )); 948 EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite )); 949 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite)); 950 EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite)); 951 EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite )); 952 EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite )); 953 EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite )); 954 EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite )); 955 EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite )); 956 957 EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite )); 958 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_message_extension_lite )); 959 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_message_extension_lite )); 960 EXPECT_TRUE(message.HasExtension(unittest::optional_import_message_extension_lite )); 961 EXPECT_TRUE(message.HasExtension(unittest::optional_public_import_message_extension_lite)); 962 EXPECT_TRUE(message.HasExtension(unittest::optional_lazy_message_extension_lite )); 963 964 EXPECT_TRUE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a()); 965 EXPECT_TRUE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb()); 966 EXPECT_TRUE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c()); 967 EXPECT_TRUE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d()); 968 EXPECT_TRUE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e()); 969 EXPECT_TRUE(message.GetExtension(unittest::optional_lazy_message_extension_lite ).has_bb()); 970 971 EXPECT_TRUE(message.HasExtension(unittest::optional_nested_enum_extension_lite )); 972 EXPECT_TRUE(message.HasExtension(unittest::optional_foreign_enum_extension_lite)); 973 EXPECT_TRUE(message.HasExtension(unittest::optional_import_enum_extension_lite )); 974 975 976 EXPECT_EQ(101 , message.GetExtension(unittest::optional_int32_extension_lite )); 977 EXPECT_EQ(102 , message.GetExtension(unittest::optional_int64_extension_lite )); 978 EXPECT_EQ(103 , message.GetExtension(unittest::optional_uint32_extension_lite )); 979 EXPECT_EQ(104 , message.GetExtension(unittest::optional_uint64_extension_lite )); 980 EXPECT_EQ(105 , message.GetExtension(unittest::optional_sint32_extension_lite )); 981 EXPECT_EQ(106 , message.GetExtension(unittest::optional_sint64_extension_lite )); 982 EXPECT_EQ(107 , message.GetExtension(unittest::optional_fixed32_extension_lite )); 983 EXPECT_EQ(108 , message.GetExtension(unittest::optional_fixed64_extension_lite )); 984 EXPECT_EQ(109 , message.GetExtension(unittest::optional_sfixed32_extension_lite)); 985 EXPECT_EQ(110 , message.GetExtension(unittest::optional_sfixed64_extension_lite)); 986 EXPECT_EQ(111 , message.GetExtension(unittest::optional_float_extension_lite )); 987 EXPECT_EQ(112 , message.GetExtension(unittest::optional_double_extension_lite )); 988 EXPECT_EQ(true , message.GetExtension(unittest::optional_bool_extension_lite )); 989 EXPECT_EQ("115", message.GetExtension(unittest::optional_string_extension_lite )); 990 EXPECT_EQ("116", message.GetExtension(unittest::optional_bytes_extension_lite )); 991 992 EXPECT_EQ(117, message.GetExtension(unittest::optionalgroup_extension_lite ).a()); 993 EXPECT_EQ(118, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb()); 994 EXPECT_EQ(119, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c()); 995 EXPECT_EQ(120, message.GetExtension(unittest::optional_import_message_extension_lite ).d()); 996 EXPECT_EQ(126, message.GetExtension(unittest::optional_public_import_message_extension_lite).e()); 997 EXPECT_EQ(127, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb()); 998 999 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::optional_nested_enum_extension_lite )); 1000 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::optional_foreign_enum_extension_lite)); 1001 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::optional_import_enum_extension_lite )); 1002 1003 1004 // ----------------------------------------------------------------- 1005 1006 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite )); 1007 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite )); 1008 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite )); 1009 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite )); 1010 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite )); 1011 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite )); 1012 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite )); 1013 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite )); 1014 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite)); 1015 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite)); 1016 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite )); 1017 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite )); 1018 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite )); 1019 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite )); 1020 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite )); 1021 1022 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite )); 1023 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite )); 1024 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite)); 1025 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite )); 1026 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite )); 1027 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite )); 1028 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite )); 1029 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite )); 1030 1031 1032 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0)); 1033 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0)); 1034 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0)); 1035 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0)); 1036 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0)); 1037 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0)); 1038 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0)); 1039 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0)); 1040 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0)); 1041 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0)); 1042 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0)); 1043 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0)); 1044 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0)); 1045 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0)); 1046 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0)); 1047 1048 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a()); 1049 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb()); 1050 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c()); 1051 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d()); 1052 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb()); 1053 1054 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0)); 1055 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0)); 1056 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0)); 1057 1058 1059 EXPECT_EQ(301 , message.GetExtension(unittest::repeated_int32_extension_lite , 1)); 1060 EXPECT_EQ(302 , message.GetExtension(unittest::repeated_int64_extension_lite , 1)); 1061 EXPECT_EQ(303 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1)); 1062 EXPECT_EQ(304 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1)); 1063 EXPECT_EQ(305 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1)); 1064 EXPECT_EQ(306 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1)); 1065 EXPECT_EQ(307 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1)); 1066 EXPECT_EQ(308 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1)); 1067 EXPECT_EQ(309 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1)); 1068 EXPECT_EQ(310 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1)); 1069 EXPECT_EQ(311 , message.GetExtension(unittest::repeated_float_extension_lite , 1)); 1070 EXPECT_EQ(312 , message.GetExtension(unittest::repeated_double_extension_lite , 1)); 1071 EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension_lite , 1)); 1072 EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension_lite , 1)); 1073 EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension_lite , 1)); 1074 1075 EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a()); 1076 EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb()); 1077 EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c()); 1078 EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d()); 1079 EXPECT_EQ(327, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb()); 1080 1081 EXPECT_EQ(unittest::TestAllTypesLite::BAZ , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1)); 1082 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1)); 1083 EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1)); 1084 1085 1086 // ----------------------------------------------------------------- 1087 1088 EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite )); 1089 EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite )); 1090 EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite )); 1091 EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite )); 1092 EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite )); 1093 EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite )); 1094 EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite )); 1095 EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite )); 1096 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite)); 1097 EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite)); 1098 EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite )); 1099 EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite )); 1100 EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite )); 1101 EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite )); 1102 EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite )); 1103 1104 EXPECT_TRUE(message.HasExtension(unittest::default_nested_enum_extension_lite )); 1105 EXPECT_TRUE(message.HasExtension(unittest::default_foreign_enum_extension_lite)); 1106 EXPECT_TRUE(message.HasExtension(unittest::default_import_enum_extension_lite )); 1107 1108 1109 EXPECT_EQ(401 , message.GetExtension(unittest::default_int32_extension_lite )); 1110 EXPECT_EQ(402 , message.GetExtension(unittest::default_int64_extension_lite )); 1111 EXPECT_EQ(403 , message.GetExtension(unittest::default_uint32_extension_lite )); 1112 EXPECT_EQ(404 , message.GetExtension(unittest::default_uint64_extension_lite )); 1113 EXPECT_EQ(405 , message.GetExtension(unittest::default_sint32_extension_lite )); 1114 EXPECT_EQ(406 , message.GetExtension(unittest::default_sint64_extension_lite )); 1115 EXPECT_EQ(407 , message.GetExtension(unittest::default_fixed32_extension_lite )); 1116 EXPECT_EQ(408 , message.GetExtension(unittest::default_fixed64_extension_lite )); 1117 EXPECT_EQ(409 , message.GetExtension(unittest::default_sfixed32_extension_lite)); 1118 EXPECT_EQ(410 , message.GetExtension(unittest::default_sfixed64_extension_lite)); 1119 EXPECT_EQ(411 , message.GetExtension(unittest::default_float_extension_lite )); 1120 EXPECT_EQ(412 , message.GetExtension(unittest::default_double_extension_lite )); 1121 EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite )); 1122 EXPECT_EQ("415", message.GetExtension(unittest::default_string_extension_lite )); 1123 EXPECT_EQ("416", message.GetExtension(unittest::default_bytes_extension_lite )); 1124 1125 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::default_nested_enum_extension_lite )); 1126 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::default_foreign_enum_extension_lite)); 1127 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::default_import_enum_extension_lite )); 1128 1129} 1130 1131// ------------------------------------------------------------------- 1132 1133void TestUtilLite::ExpectExtensionsClear( 1134 const unittest::TestAllExtensionsLite& message) { 1135 string serialized; 1136 ASSERT_TRUE(message.SerializeToString(&serialized)); 1137 EXPECT_EQ("", serialized); 1138 EXPECT_EQ(0, message.ByteSize()); 1139 1140 // has_blah() should initially be false for all optional fields. 1141 EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite )); 1142 EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite )); 1143 EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite )); 1144 EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite )); 1145 EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite )); 1146 EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite )); 1147 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite )); 1148 EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite )); 1149 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed32_extension_lite)); 1150 EXPECT_FALSE(message.HasExtension(unittest::optional_sfixed64_extension_lite)); 1151 EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite )); 1152 EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite )); 1153 EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite )); 1154 EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite )); 1155 EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite )); 1156 1157 EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite )); 1158 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_message_extension_lite )); 1159 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_message_extension_lite )); 1160 EXPECT_FALSE(message.HasExtension(unittest::optional_import_message_extension_lite )); 1161 EXPECT_FALSE(message.HasExtension(unittest::optional_public_import_message_extension_lite)); 1162 EXPECT_FALSE(message.HasExtension(unittest::optional_lazy_message_extension_lite )); 1163 1164 EXPECT_FALSE(message.HasExtension(unittest::optional_nested_enum_extension_lite )); 1165 EXPECT_FALSE(message.HasExtension(unittest::optional_foreign_enum_extension_lite)); 1166 EXPECT_FALSE(message.HasExtension(unittest::optional_import_enum_extension_lite )); 1167 1168 1169 // Optional fields without defaults are set to zero or something like it. 1170 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int32_extension_lite )); 1171 EXPECT_EQ(0 , message.GetExtension(unittest::optional_int64_extension_lite )); 1172 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint32_extension_lite )); 1173 EXPECT_EQ(0 , message.GetExtension(unittest::optional_uint64_extension_lite )); 1174 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint32_extension_lite )); 1175 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sint64_extension_lite )); 1176 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed32_extension_lite )); 1177 EXPECT_EQ(0 , message.GetExtension(unittest::optional_fixed64_extension_lite )); 1178 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed32_extension_lite)); 1179 EXPECT_EQ(0 , message.GetExtension(unittest::optional_sfixed64_extension_lite)); 1180 EXPECT_EQ(0 , message.GetExtension(unittest::optional_float_extension_lite )); 1181 EXPECT_EQ(0 , message.GetExtension(unittest::optional_double_extension_lite )); 1182 EXPECT_EQ(false, message.GetExtension(unittest::optional_bool_extension_lite )); 1183 EXPECT_EQ("" , message.GetExtension(unittest::optional_string_extension_lite )); 1184 EXPECT_EQ("" , message.GetExtension(unittest::optional_bytes_extension_lite )); 1185 1186 // Embedded messages should also be clear. 1187 EXPECT_FALSE(message.GetExtension(unittest::optionalgroup_extension_lite ).has_a()); 1188 EXPECT_FALSE(message.GetExtension(unittest::optional_nested_message_extension_lite ).has_bb()); 1189 EXPECT_FALSE(message.GetExtension(unittest::optional_foreign_message_extension_lite ).has_c()); 1190 EXPECT_FALSE(message.GetExtension(unittest::optional_import_message_extension_lite ).has_d()); 1191 EXPECT_FALSE(message.GetExtension(unittest::optional_public_import_message_extension_lite).has_e()); 1192 EXPECT_FALSE(message.GetExtension(unittest::optional_lazy_message_extension_lite ).has_bb()); 1193 1194 EXPECT_EQ(0, message.GetExtension(unittest::optionalgroup_extension_lite ).a()); 1195 EXPECT_EQ(0, message.GetExtension(unittest::optional_nested_message_extension_lite ).bb()); 1196 EXPECT_EQ(0, message.GetExtension(unittest::optional_foreign_message_extension_lite ).c()); 1197 EXPECT_EQ(0, message.GetExtension(unittest::optional_import_message_extension_lite ).d()); 1198 EXPECT_EQ(0, message.GetExtension(unittest::optional_public_import_message_extension_lite).e()); 1199 EXPECT_EQ(0, message.GetExtension(unittest::optional_lazy_message_extension_lite ).bb()); 1200 1201 // Enums without defaults are set to the first value in the enum. 1202 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::optional_nested_enum_extension_lite )); 1203 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::optional_foreign_enum_extension_lite)); 1204 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::optional_import_enum_extension_lite )); 1205 1206 1207 // Repeated fields are empty. 1208 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite )); 1209 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite )); 1210 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite )); 1211 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite )); 1212 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite )); 1213 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite )); 1214 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed32_extension_lite )); 1215 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_fixed64_extension_lite )); 1216 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite)); 1217 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite)); 1218 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite )); 1219 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite )); 1220 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite )); 1221 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite )); 1222 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite )); 1223 1224 EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite )); 1225 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_message_extension_lite )); 1226 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite)); 1227 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_message_extension_lite )); 1228 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite )); 1229 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite )); 1230 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite )); 1231 EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite )); 1232 1233 1234 // has_blah() should also be false for all default fields. 1235 EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite )); 1236 EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite )); 1237 EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite )); 1238 EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite )); 1239 EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite )); 1240 EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite )); 1241 EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite )); 1242 EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite )); 1243 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite)); 1244 EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite)); 1245 EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite )); 1246 EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite )); 1247 EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite )); 1248 EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite )); 1249 EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite )); 1250 1251 EXPECT_FALSE(message.HasExtension(unittest::default_nested_enum_extension_lite )); 1252 EXPECT_FALSE(message.HasExtension(unittest::default_foreign_enum_extension_lite)); 1253 EXPECT_FALSE(message.HasExtension(unittest::default_import_enum_extension_lite )); 1254 1255 1256 // Fields with defaults have their default values (duh). 1257 EXPECT_EQ( 41 , message.GetExtension(unittest::default_int32_extension_lite )); 1258 EXPECT_EQ( 42 , message.GetExtension(unittest::default_int64_extension_lite )); 1259 EXPECT_EQ( 43 , message.GetExtension(unittest::default_uint32_extension_lite )); 1260 EXPECT_EQ( 44 , message.GetExtension(unittest::default_uint64_extension_lite )); 1261 EXPECT_EQ(-45 , message.GetExtension(unittest::default_sint32_extension_lite )); 1262 EXPECT_EQ( 46 , message.GetExtension(unittest::default_sint64_extension_lite )); 1263 EXPECT_EQ( 47 , message.GetExtension(unittest::default_fixed32_extension_lite )); 1264 EXPECT_EQ( 48 , message.GetExtension(unittest::default_fixed64_extension_lite )); 1265 EXPECT_EQ( 49 , message.GetExtension(unittest::default_sfixed32_extension_lite)); 1266 EXPECT_EQ(-50 , message.GetExtension(unittest::default_sfixed64_extension_lite)); 1267 EXPECT_EQ( 51.5 , message.GetExtension(unittest::default_float_extension_lite )); 1268 EXPECT_EQ( 52e3 , message.GetExtension(unittest::default_double_extension_lite )); 1269 EXPECT_EQ(true , message.GetExtension(unittest::default_bool_extension_lite )); 1270 EXPECT_EQ("hello", message.GetExtension(unittest::default_string_extension_lite )); 1271 EXPECT_EQ("world", message.GetExtension(unittest::default_bytes_extension_lite )); 1272 1273 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::default_nested_enum_extension_lite )); 1274 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::default_foreign_enum_extension_lite)); 1275 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::default_import_enum_extension_lite )); 1276 1277} 1278 1279// ------------------------------------------------------------------- 1280 1281void TestUtilLite::ExpectRepeatedExtensionsModified( 1282 const unittest::TestAllExtensionsLite& message) { 1283 // ModifyRepeatedFields only sets the second repeated element of each 1284 // field. In addition to verifying this, we also verify that the first 1285 // element and size were *not* modified. 1286 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite )); 1287 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite )); 1288 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite )); 1289 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite )); 1290 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite )); 1291 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite )); 1292 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension_lite )); 1293 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension_lite )); 1294 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension_lite)); 1295 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension_lite)); 1296 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite )); 1297 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite )); 1298 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite )); 1299 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite )); 1300 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite )); 1301 1302 ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite )); 1303 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension_lite )); 1304 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension_lite)); 1305 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension_lite )); 1306 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite )); 1307 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite )); 1308 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite )); 1309 ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite )); 1310 1311 1312 EXPECT_EQ(201 , message.GetExtension(unittest::repeated_int32_extension_lite , 0)); 1313 EXPECT_EQ(202 , message.GetExtension(unittest::repeated_int64_extension_lite , 0)); 1314 EXPECT_EQ(203 , message.GetExtension(unittest::repeated_uint32_extension_lite , 0)); 1315 EXPECT_EQ(204 , message.GetExtension(unittest::repeated_uint64_extension_lite , 0)); 1316 EXPECT_EQ(205 , message.GetExtension(unittest::repeated_sint32_extension_lite , 0)); 1317 EXPECT_EQ(206 , message.GetExtension(unittest::repeated_sint64_extension_lite , 0)); 1318 EXPECT_EQ(207 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 0)); 1319 EXPECT_EQ(208 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 0)); 1320 EXPECT_EQ(209 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0)); 1321 EXPECT_EQ(210 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0)); 1322 EXPECT_EQ(211 , message.GetExtension(unittest::repeated_float_extension_lite , 0)); 1323 EXPECT_EQ(212 , message.GetExtension(unittest::repeated_double_extension_lite , 0)); 1324 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 0)); 1325 EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension_lite , 0)); 1326 EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension_lite , 0)); 1327 1328 EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension_lite , 0).a()); 1329 EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension_lite , 0).bb()); 1330 EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0).c()); 1331 EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension_lite , 0).d()); 1332 EXPECT_EQ(227, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 0).bb()); 1333 1334 EXPECT_EQ(unittest::TestAllTypesLite::BAR , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 0)); 1335 EXPECT_EQ(unittest::FOREIGN_LITE_BAR , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0)); 1336 EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.GetExtension(unittest::repeated_import_enum_extension_lite , 0)); 1337 1338 1339 // Actually verify the second (modified) elements now. 1340 EXPECT_EQ(501 , message.GetExtension(unittest::repeated_int32_extension_lite , 1)); 1341 EXPECT_EQ(502 , message.GetExtension(unittest::repeated_int64_extension_lite , 1)); 1342 EXPECT_EQ(503 , message.GetExtension(unittest::repeated_uint32_extension_lite , 1)); 1343 EXPECT_EQ(504 , message.GetExtension(unittest::repeated_uint64_extension_lite , 1)); 1344 EXPECT_EQ(505 , message.GetExtension(unittest::repeated_sint32_extension_lite , 1)); 1345 EXPECT_EQ(506 , message.GetExtension(unittest::repeated_sint64_extension_lite , 1)); 1346 EXPECT_EQ(507 , message.GetExtension(unittest::repeated_fixed32_extension_lite , 1)); 1347 EXPECT_EQ(508 , message.GetExtension(unittest::repeated_fixed64_extension_lite , 1)); 1348 EXPECT_EQ(509 , message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1)); 1349 EXPECT_EQ(510 , message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1)); 1350 EXPECT_EQ(511 , message.GetExtension(unittest::repeated_float_extension_lite , 1)); 1351 EXPECT_EQ(512 , message.GetExtension(unittest::repeated_double_extension_lite , 1)); 1352 EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension_lite , 1)); 1353 EXPECT_EQ("515", message.GetExtension(unittest::repeated_string_extension_lite , 1)); 1354 EXPECT_EQ("516", message.GetExtension(unittest::repeated_bytes_extension_lite , 1)); 1355 1356 EXPECT_EQ(517, message.GetExtension(unittest::repeatedgroup_extension_lite , 1).a()); 1357 EXPECT_EQ(518, message.GetExtension(unittest::repeated_nested_message_extension_lite , 1).bb()); 1358 EXPECT_EQ(519, message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1).c()); 1359 EXPECT_EQ(520, message.GetExtension(unittest::repeated_import_message_extension_lite , 1).d()); 1360 EXPECT_EQ(527, message.GetExtension(unittest::repeated_lazy_message_extension_lite , 1).bb()); 1361 1362 EXPECT_EQ(unittest::TestAllTypesLite::FOO , message.GetExtension(unittest::repeated_nested_enum_extension_lite , 1)); 1363 EXPECT_EQ(unittest::FOREIGN_LITE_FOO , message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1)); 1364 EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.GetExtension(unittest::repeated_import_enum_extension_lite , 1)); 1365 1366} 1367 1368// ------------------------------------------------------------------- 1369 1370void TestUtilLite::SetPackedExtensions( 1371 unittest::TestPackedExtensionsLite* message) { 1372 message->AddExtension(unittest::packed_int32_extension_lite , 601); 1373 message->AddExtension(unittest::packed_int64_extension_lite , 602); 1374 message->AddExtension(unittest::packed_uint32_extension_lite , 603); 1375 message->AddExtension(unittest::packed_uint64_extension_lite , 604); 1376 message->AddExtension(unittest::packed_sint32_extension_lite , 605); 1377 message->AddExtension(unittest::packed_sint64_extension_lite , 606); 1378 message->AddExtension(unittest::packed_fixed32_extension_lite , 607); 1379 message->AddExtension(unittest::packed_fixed64_extension_lite , 608); 1380 message->AddExtension(unittest::packed_sfixed32_extension_lite, 609); 1381 message->AddExtension(unittest::packed_sfixed64_extension_lite, 610); 1382 message->AddExtension(unittest::packed_float_extension_lite , 611); 1383 message->AddExtension(unittest::packed_double_extension_lite , 612); 1384 message->AddExtension(unittest::packed_bool_extension_lite , true); 1385 message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAR); 1386 // add a second one of each field 1387 message->AddExtension(unittest::packed_int32_extension_lite , 701); 1388 message->AddExtension(unittest::packed_int64_extension_lite , 702); 1389 message->AddExtension(unittest::packed_uint32_extension_lite , 703); 1390 message->AddExtension(unittest::packed_uint64_extension_lite , 704); 1391 message->AddExtension(unittest::packed_sint32_extension_lite , 705); 1392 message->AddExtension(unittest::packed_sint64_extension_lite , 706); 1393 message->AddExtension(unittest::packed_fixed32_extension_lite , 707); 1394 message->AddExtension(unittest::packed_fixed64_extension_lite , 708); 1395 message->AddExtension(unittest::packed_sfixed32_extension_lite, 709); 1396 message->AddExtension(unittest::packed_sfixed64_extension_lite, 710); 1397 message->AddExtension(unittest::packed_float_extension_lite , 711); 1398 message->AddExtension(unittest::packed_double_extension_lite , 712); 1399 message->AddExtension(unittest::packed_bool_extension_lite , false); 1400 message->AddExtension(unittest::packed_enum_extension_lite, unittest::FOREIGN_LITE_BAZ); 1401} 1402 1403// ------------------------------------------------------------------- 1404 1405void TestUtilLite::ModifyPackedExtensions( 1406 unittest::TestPackedExtensionsLite* message) { 1407 message->SetExtension(unittest::packed_int32_extension_lite , 1, 801); 1408 message->SetExtension(unittest::packed_int64_extension_lite , 1, 802); 1409 message->SetExtension(unittest::packed_uint32_extension_lite , 1, 803); 1410 message->SetExtension(unittest::packed_uint64_extension_lite , 1, 804); 1411 message->SetExtension(unittest::packed_sint32_extension_lite , 1, 805); 1412 message->SetExtension(unittest::packed_sint64_extension_lite , 1, 806); 1413 message->SetExtension(unittest::packed_fixed32_extension_lite , 1, 807); 1414 message->SetExtension(unittest::packed_fixed64_extension_lite , 1, 808); 1415 message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809); 1416 message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810); 1417 message->SetExtension(unittest::packed_float_extension_lite , 1, 811); 1418 message->SetExtension(unittest::packed_double_extension_lite , 1, 812); 1419 message->SetExtension(unittest::packed_bool_extension_lite , 1, true); 1420 message->SetExtension(unittest::packed_enum_extension_lite , 1, 1421 unittest::FOREIGN_LITE_FOO); 1422} 1423 1424// ------------------------------------------------------------------- 1425 1426void TestUtilLite::ExpectPackedExtensionsSet( 1427 const unittest::TestPackedExtensionsLite& message) { 1428 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite )); 1429 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite )); 1430 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite )); 1431 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite )); 1432 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite )); 1433 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite )); 1434 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite )); 1435 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite )); 1436 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite)); 1437 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite)); 1438 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite )); 1439 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite )); 1440 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite )); 1441 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite )); 1442 1443 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0)); 1444 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0)); 1445 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0)); 1446 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0)); 1447 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0)); 1448 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0)); 1449 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0)); 1450 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0)); 1451 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0)); 1452 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0)); 1453 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0)); 1454 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0)); 1455 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0)); 1456 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, 1457 message.GetExtension(unittest::packed_enum_extension_lite, 0)); 1458 EXPECT_EQ(701 , message.GetExtension(unittest::packed_int32_extension_lite , 1)); 1459 EXPECT_EQ(702 , message.GetExtension(unittest::packed_int64_extension_lite , 1)); 1460 EXPECT_EQ(703 , message.GetExtension(unittest::packed_uint32_extension_lite , 1)); 1461 EXPECT_EQ(704 , message.GetExtension(unittest::packed_uint64_extension_lite , 1)); 1462 EXPECT_EQ(705 , message.GetExtension(unittest::packed_sint32_extension_lite , 1)); 1463 EXPECT_EQ(706 , message.GetExtension(unittest::packed_sint64_extension_lite , 1)); 1464 EXPECT_EQ(707 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1)); 1465 EXPECT_EQ(708 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1)); 1466 EXPECT_EQ(709 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1)); 1467 EXPECT_EQ(710 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1)); 1468 EXPECT_EQ(711 , message.GetExtension(unittest::packed_float_extension_lite , 1)); 1469 EXPECT_EQ(712 , message.GetExtension(unittest::packed_double_extension_lite , 1)); 1470 EXPECT_EQ(false, message.GetExtension(unittest::packed_bool_extension_lite , 1)); 1471 EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, 1472 message.GetExtension(unittest::packed_enum_extension_lite, 1)); 1473} 1474 1475// ------------------------------------------------------------------- 1476 1477void TestUtilLite::ExpectPackedExtensionsClear( 1478 const unittest::TestPackedExtensionsLite& message) { 1479 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite )); 1480 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite )); 1481 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite )); 1482 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite )); 1483 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite )); 1484 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite )); 1485 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite )); 1486 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite )); 1487 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite)); 1488 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite)); 1489 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite )); 1490 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite )); 1491 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite )); 1492 EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite )); 1493} 1494 1495// ------------------------------------------------------------------- 1496 1497void TestUtilLite::ExpectPackedExtensionsModified( 1498 const unittest::TestPackedExtensionsLite& message) { 1499 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite )); 1500 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite )); 1501 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite )); 1502 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite )); 1503 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite )); 1504 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite )); 1505 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite )); 1506 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite )); 1507 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite)); 1508 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite)); 1509 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite )); 1510 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite )); 1511 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite )); 1512 ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite )); 1513 EXPECT_EQ(601 , message.GetExtension(unittest::packed_int32_extension_lite , 0)); 1514 EXPECT_EQ(602 , message.GetExtension(unittest::packed_int64_extension_lite , 0)); 1515 EXPECT_EQ(603 , message.GetExtension(unittest::packed_uint32_extension_lite , 0)); 1516 EXPECT_EQ(604 , message.GetExtension(unittest::packed_uint64_extension_lite , 0)); 1517 EXPECT_EQ(605 , message.GetExtension(unittest::packed_sint32_extension_lite , 0)); 1518 EXPECT_EQ(606 , message.GetExtension(unittest::packed_sint64_extension_lite , 0)); 1519 EXPECT_EQ(607 , message.GetExtension(unittest::packed_fixed32_extension_lite , 0)); 1520 EXPECT_EQ(608 , message.GetExtension(unittest::packed_fixed64_extension_lite , 0)); 1521 EXPECT_EQ(609 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 0)); 1522 EXPECT_EQ(610 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 0)); 1523 EXPECT_EQ(611 , message.GetExtension(unittest::packed_float_extension_lite , 0)); 1524 EXPECT_EQ(612 , message.GetExtension(unittest::packed_double_extension_lite , 0)); 1525 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 0)); 1526 EXPECT_EQ(unittest::FOREIGN_LITE_BAR, 1527 message.GetExtension(unittest::packed_enum_extension_lite, 0)); 1528 1529 // Actually verify the second (modified) elements now. 1530 EXPECT_EQ(801 , message.GetExtension(unittest::packed_int32_extension_lite , 1)); 1531 EXPECT_EQ(802 , message.GetExtension(unittest::packed_int64_extension_lite , 1)); 1532 EXPECT_EQ(803 , message.GetExtension(unittest::packed_uint32_extension_lite , 1)); 1533 EXPECT_EQ(804 , message.GetExtension(unittest::packed_uint64_extension_lite , 1)); 1534 EXPECT_EQ(805 , message.GetExtension(unittest::packed_sint32_extension_lite , 1)); 1535 EXPECT_EQ(806 , message.GetExtension(unittest::packed_sint64_extension_lite , 1)); 1536 EXPECT_EQ(807 , message.GetExtension(unittest::packed_fixed32_extension_lite , 1)); 1537 EXPECT_EQ(808 , message.GetExtension(unittest::packed_fixed64_extension_lite , 1)); 1538 EXPECT_EQ(809 , message.GetExtension(unittest::packed_sfixed32_extension_lite, 1)); 1539 EXPECT_EQ(810 , message.GetExtension(unittest::packed_sfixed64_extension_lite, 1)); 1540 EXPECT_EQ(811 , message.GetExtension(unittest::packed_float_extension_lite , 1)); 1541 EXPECT_EQ(812 , message.GetExtension(unittest::packed_double_extension_lite , 1)); 1542 EXPECT_EQ(true , message.GetExtension(unittest::packed_bool_extension_lite , 1)); 1543 EXPECT_EQ(unittest::FOREIGN_LITE_FOO, 1544 message.GetExtension(unittest::packed_enum_extension_lite, 1)); 1545} 1546 1547} // namespace protobuf 1548} // namespace google 1549