1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// https://developers.google.com/protocol-buffers/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// Author: kenton@google.com (Kenton Varda) 32 33#include <string> 34#include <iostream> 35 36#include <google/protobuf/stubs/logging.h> 37#include <google/protobuf/stubs/common.h> 38#include <google/protobuf/arena_test_util.h> 39#include <google/protobuf/map_lite_unittest.pb.h> 40#include <google/protobuf/map_lite_test_util.h> 41#include <google/protobuf/test_util_lite.h> 42#include <google/protobuf/unittest_lite.pb.h> 43#include <google/protobuf/io/coded_stream.h> 44#include <google/protobuf/io/zero_copy_stream_impl_lite.h> 45#include <google/protobuf/wire_format_lite.h> 46#include <google/protobuf/wire_format_lite_inl.h> 47#include <google/protobuf/stubs/strutil.h> 48 49using namespace std; 50 51namespace { 52// Helper methods to test parsing merge behavior. 53void ExpectMessageMerged(const google::protobuf::unittest::TestAllTypesLite& message) { 54 GOOGLE_CHECK(message.optional_int32() == 3); 55 GOOGLE_CHECK(message.optional_int64() == 2); 56 GOOGLE_CHECK(message.optional_string() == "hello"); 57} 58 59void AssignParsingMergeMessages( 60 google::protobuf::unittest::TestAllTypesLite* msg1, 61 google::protobuf::unittest::TestAllTypesLite* msg2, 62 google::protobuf::unittest::TestAllTypesLite* msg3) { 63 msg1->set_optional_int32(1); 64 msg2->set_optional_int64(2); 65 msg3->set_optional_int32(3); 66 msg3->set_optional_string("hello"); 67} 68 69void SetAllTypesInEmptyMessageUnknownFields( 70 google::protobuf::unittest::TestEmptyMessageLite* empty_message) { 71 protobuf_unittest::TestAllTypesLite message; 72 google::protobuf::TestUtilLite::ExpectClear(message); 73 google::protobuf::TestUtilLite::SetAllFields(&message); 74 string data = message.SerializeAsString(); 75 empty_message->ParseFromString(data); 76} 77 78void SetSomeTypesInEmptyMessageUnknownFields( 79 google::protobuf::unittest::TestEmptyMessageLite* empty_message) { 80 protobuf_unittest::TestAllTypesLite message; 81 google::protobuf::TestUtilLite::ExpectClear(message); 82 message.set_optional_int32(101); 83 message.set_optional_int64(102); 84 message.set_optional_uint32(103); 85 message.set_optional_uint64(104); 86 string data = message.SerializeAsString(); 87 empty_message->ParseFromString(data); 88} 89 90} // namespace 91 92#define EXPECT_TRUE GOOGLE_CHECK 93#define ASSERT_TRUE GOOGLE_CHECK 94#define EXPECT_FALSE(COND) GOOGLE_CHECK(!(COND)) 95#define EXPECT_EQ GOOGLE_CHECK_EQ 96#define ASSERT_EQ GOOGLE_CHECK_EQ 97 98int main(int argc, char* argv[]) { 99 string data, data2, packed_data; 100 101 { 102 protobuf_unittest::TestAllTypesLite message, message2, message3; 103 google::protobuf::TestUtilLite::ExpectClear(message); 104 google::protobuf::TestUtilLite::SetAllFields(&message); 105 message2.CopyFrom(message); 106 data = message.SerializeAsString(); 107 message3.ParseFromString(data); 108 google::protobuf::TestUtilLite::ExpectAllFieldsSet(message); 109 google::protobuf::TestUtilLite::ExpectAllFieldsSet(message2); 110 google::protobuf::TestUtilLite::ExpectAllFieldsSet(message3); 111 google::protobuf::TestUtilLite::ModifyRepeatedFields(&message); 112 google::protobuf::TestUtilLite::ExpectRepeatedFieldsModified(message); 113 message.Clear(); 114 google::protobuf::TestUtilLite::ExpectClear(message); 115 } 116 117 { 118 protobuf_unittest::TestAllExtensionsLite message, message2, message3; 119 google::protobuf::TestUtilLite::ExpectExtensionsClear(message); 120 google::protobuf::TestUtilLite::SetAllExtensions(&message); 121 message2.CopyFrom(message); 122 string extensions_data = message.SerializeAsString(); 123 message3.ParseFromString(extensions_data); 124 google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message); 125 google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message2); 126 google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message3); 127 google::protobuf::TestUtilLite::ModifyRepeatedExtensions(&message); 128 google::protobuf::TestUtilLite::ExpectRepeatedExtensionsModified(message); 129 message.Clear(); 130 google::protobuf::TestUtilLite::ExpectExtensionsClear(message); 131 } 132 133 { 134 protobuf_unittest::TestPackedTypesLite message, message2, message3; 135 google::protobuf::TestUtilLite::ExpectPackedClear(message); 136 google::protobuf::TestUtilLite::SetPackedFields(&message); 137 message2.CopyFrom(message); 138 packed_data = message.SerializeAsString(); 139 message3.ParseFromString(packed_data); 140 google::protobuf::TestUtilLite::ExpectPackedFieldsSet(message); 141 google::protobuf::TestUtilLite::ExpectPackedFieldsSet(message2); 142 google::protobuf::TestUtilLite::ExpectPackedFieldsSet(message3); 143 google::protobuf::TestUtilLite::ModifyPackedFields(&message); 144 google::protobuf::TestUtilLite::ExpectPackedFieldsModified(message); 145 message.Clear(); 146 google::protobuf::TestUtilLite::ExpectPackedClear(message); 147 } 148 149 { 150 protobuf_unittest::TestPackedExtensionsLite message, message2, message3; 151 google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); 152 google::protobuf::TestUtilLite::SetPackedExtensions(&message); 153 message2.CopyFrom(message); 154 string packed_extensions_data = message.SerializeAsString(); 155 GOOGLE_CHECK(packed_extensions_data == packed_data); 156 message3.ParseFromString(packed_extensions_data); 157 google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message); 158 google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message2); 159 google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message3); 160 google::protobuf::TestUtilLite::ModifyPackedExtensions(&message); 161 google::protobuf::TestUtilLite::ExpectPackedExtensionsModified(message); 162 message.Clear(); 163 google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); 164 } 165 166 { 167 // Test that if an optional or required message/group field appears multiple 168 // times in the input, they need to be merged. 169 google::protobuf::unittest::TestParsingMergeLite::RepeatedFieldsGenerator generator; 170 google::protobuf::unittest::TestAllTypesLite* msg1; 171 google::protobuf::unittest::TestAllTypesLite* msg2; 172 google::protobuf::unittest::TestAllTypesLite* msg3; 173 174#define ASSIGN_REPEATED_FIELD(FIELD) \ 175 msg1 = generator.add_##FIELD(); \ 176 msg2 = generator.add_##FIELD(); \ 177 msg3 = generator.add_##FIELD(); \ 178 AssignParsingMergeMessages(msg1, msg2, msg3) 179 180 ASSIGN_REPEATED_FIELD(field1); 181 ASSIGN_REPEATED_FIELD(field2); 182 ASSIGN_REPEATED_FIELD(field3); 183 ASSIGN_REPEATED_FIELD(ext1); 184 ASSIGN_REPEATED_FIELD(ext2); 185 186#undef ASSIGN_REPEATED_FIELD 187#define ASSIGN_REPEATED_GROUP(FIELD) \ 188 msg1 = generator.add_##FIELD()->mutable_field1(); \ 189 msg2 = generator.add_##FIELD()->mutable_field1(); \ 190 msg3 = generator.add_##FIELD()->mutable_field1(); \ 191 AssignParsingMergeMessages(msg1, msg2, msg3) 192 193 ASSIGN_REPEATED_GROUP(group1); 194 ASSIGN_REPEATED_GROUP(group2); 195 196#undef ASSIGN_REPEATED_GROUP 197 198 string buffer; 199 generator.SerializeToString(&buffer); 200 google::protobuf::unittest::TestParsingMergeLite parsing_merge; 201 parsing_merge.ParseFromString(buffer); 202 203 // Required and optional fields should be merged. 204 ExpectMessageMerged(parsing_merge.required_all_types()); 205 ExpectMessageMerged(parsing_merge.optional_all_types()); 206 ExpectMessageMerged( 207 parsing_merge.optionalgroup().optional_group_all_types()); 208 ExpectMessageMerged(parsing_merge.GetExtension( 209 google::protobuf::unittest::TestParsingMergeLite::optional_ext)); 210 211 // Repeated fields should not be merged. 212 GOOGLE_CHECK(parsing_merge.repeated_all_types_size() == 3); 213 GOOGLE_CHECK(parsing_merge.repeatedgroup_size() == 3); 214 GOOGLE_CHECK(parsing_merge.ExtensionSize( 215 google::protobuf::unittest::TestParsingMergeLite::repeated_ext) == 3); 216 } 217 218 // Test unknown fields support for lite messages. 219 { 220 protobuf_unittest::TestAllTypesLite message, message2; 221 protobuf_unittest::TestEmptyMessageLite empty_message; 222 google::protobuf::TestUtilLite::ExpectClear(message); 223 google::protobuf::TestUtilLite::SetAllFields(&message); 224 data = message.SerializeAsString(); 225 empty_message.ParseFromString(data); 226 data.clear(); 227 data = empty_message.SerializeAsString(); 228 message2.ParseFromString(data); 229 data = message2.SerializeAsString(); 230 google::protobuf::TestUtilLite::ExpectAllFieldsSet(message2); 231 message.Clear(); 232 google::protobuf::TestUtilLite::ExpectClear(message); 233 } 234 235 { 236 protobuf_unittest::TestAllExtensionsLite message, message2; 237 protobuf_unittest::TestEmptyMessageLite empty_message; 238 google::protobuf::TestUtilLite::ExpectExtensionsClear(message); 239 google::protobuf::TestUtilLite::SetAllExtensions(&message); 240 data = message.SerializeAsString(); 241 empty_message.ParseFromString(data); 242 data.clear(); 243 data = empty_message.SerializeAsString(); 244 message2.ParseFromString(data); 245 data = message2.SerializeAsString(); 246 google::protobuf::TestUtilLite::ExpectAllExtensionsSet(message2); 247 message.Clear(); 248 google::protobuf::TestUtilLite::ExpectExtensionsClear(message); 249 } 250 251 { 252 protobuf_unittest::TestPackedTypesLite message, message2; 253 protobuf_unittest::TestEmptyMessageLite empty_message; 254 google::protobuf::TestUtilLite::ExpectPackedClear(message); 255 google::protobuf::TestUtilLite::SetPackedFields(&message); 256 data = message.SerializeAsString(); 257 empty_message.ParseFromString(data); 258 data.clear(); 259 data = empty_message.SerializeAsString(); 260 message2.ParseFromString(data); 261 data = message2.SerializeAsString(); 262 google::protobuf::TestUtilLite::ExpectPackedFieldsSet(message2); 263 message.Clear(); 264 google::protobuf::TestUtilLite::ExpectPackedClear(message); 265 } 266 267 { 268 protobuf_unittest::TestPackedExtensionsLite message, message2; 269 protobuf_unittest::TestEmptyMessageLite empty_message; 270 google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); 271 google::protobuf::TestUtilLite::SetPackedExtensions(&message); 272 data = message.SerializeAsString(); 273 empty_message.ParseFromString(data); 274 data.clear(); 275 data = empty_message.SerializeAsString(); 276 message2.ParseFromString(data); 277 data = message2.SerializeAsString(); 278 google::protobuf::TestUtilLite::ExpectPackedExtensionsSet(message2); 279 message.Clear(); 280 google::protobuf::TestUtilLite::ExpectPackedExtensionsClear(message); 281 } 282 283 { 284 // Test Unknown fields swap 285 protobuf_unittest::TestEmptyMessageLite empty_message, empty_message2; 286 SetAllTypesInEmptyMessageUnknownFields(&empty_message); 287 SetSomeTypesInEmptyMessageUnknownFields(&empty_message2); 288 data = empty_message.SerializeAsString(); 289 data2 = empty_message2.SerializeAsString(); 290 empty_message.Swap(&empty_message2); 291 GOOGLE_CHECK_EQ(data, empty_message2.SerializeAsString()); 292 GOOGLE_CHECK_EQ(data2, empty_message.SerializeAsString()); 293 } 294 295 { 296 // Test unknown fields swap with self 297 protobuf_unittest::TestEmptyMessageLite empty_message; 298 SetAllTypesInEmptyMessageUnknownFields(&empty_message); 299 data = empty_message.SerializeAsString(); 300 empty_message.Swap(&empty_message); 301 GOOGLE_CHECK_EQ(data, empty_message.SerializeAsString()); 302 } 303 304 { 305 // Test MergeFrom with unknown fields 306 protobuf_unittest::TestAllTypesLite message, message2; 307 protobuf_unittest::TestEmptyMessageLite empty_message, empty_message2; 308 message.set_optional_int32(101); 309 message.add_repeated_int32(201); 310 message.set_optional_nested_enum(google::protobuf::unittest::TestAllTypesLite::BAZ); 311 message2.set_optional_int64(102); 312 message2.add_repeated_int64(202); 313 message2.set_optional_foreign_enum(google::protobuf::unittest::FOREIGN_LITE_BAZ); 314 315 data = message.SerializeAsString(); 316 empty_message.ParseFromString(data); 317 data = message2.SerializeAsString(); 318 empty_message2.ParseFromString(data); 319 message.MergeFrom(message2); 320 empty_message.MergeFrom(empty_message2); 321 322 data = empty_message.SerializeAsString(); 323 message2.ParseFromString(data); 324 // We do not compare the serialized output of a normal message and a lite 325 // message because the order of fields do not match. We convert lite message 326 // back into normal message, then compare. 327 GOOGLE_CHECK_EQ(message.SerializeAsString(), message2.SerializeAsString()); 328 } 329 330 { 331 // Test unknown enum value 332 protobuf_unittest::TestAllTypesLite message; 333 string buffer; 334 { 335 google::protobuf::io::StringOutputStream output_stream(&buffer); 336 google::protobuf::io::CodedOutputStream coded_output(&output_stream); 337 google::protobuf::internal::WireFormatLite::WriteTag( 338 protobuf_unittest::TestAllTypesLite::kOptionalNestedEnumFieldNumber, 339 google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT, &coded_output); 340 coded_output.WriteVarint32(10); 341 google::protobuf::internal::WireFormatLite::WriteTag( 342 protobuf_unittest::TestAllTypesLite::kRepeatedNestedEnumFieldNumber, 343 google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT, &coded_output); 344 coded_output.WriteVarint32(20); 345 } 346 message.ParseFromString(buffer); 347 data = message.SerializeAsString(); 348 GOOGLE_CHECK_EQ(data, buffer); 349 } 350 351 { 352 // Test Clear with unknown fields 353 protobuf_unittest::TestEmptyMessageLite empty_message; 354 SetAllTypesInEmptyMessageUnknownFields(&empty_message); 355 empty_message.Clear(); 356 GOOGLE_CHECK_EQ(0, empty_message.unknown_fields().size()); 357 } 358 359 // Tests for map lite ============================================= 360 361 { 362 // Accessors 363 protobuf_unittest::TestMapLite message; 364 365 google::protobuf::MapLiteTestUtil::SetMapFields(&message); 366 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message); 367 368 google::protobuf::MapLiteTestUtil::ModifyMapFields(&message); 369 google::protobuf::MapLiteTestUtil::ExpectMapFieldsModified(message); 370 } 371 372 { 373 // SetMapFieldsInitialized 374 protobuf_unittest::TestMapLite message; 375 376 google::protobuf::MapLiteTestUtil::SetMapFieldsInitialized(&message); 377 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSetInitialized(message); 378 } 379 380 { 381 // Clear 382 protobuf_unittest::TestMapLite message; 383 384 google::protobuf::MapLiteTestUtil::SetMapFields(&message); 385 message.Clear(); 386 google::protobuf::MapLiteTestUtil::ExpectClear(message); 387 } 388 389 { 390 // ClearMessageMap 391 protobuf_unittest::TestMessageMapLite message; 392 393 // Creates a TestAllTypes with default value 394 google::protobuf::TestUtilLite::ExpectClear( 395 (*message.mutable_map_int32_message())[0]); 396 } 397 398 { 399 // CopyFrom 400 protobuf_unittest::TestMapLite message1, message2; 401 402 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 403 message2.CopyFrom(message1); 404 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 405 406 // Copying from self should be a no-op. 407 message2.CopyFrom(message2); 408 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 409 } 410 411 { 412 // CopyFromMessageMap 413 protobuf_unittest::TestMessageMapLite message1, message2; 414 415 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100); 416 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101); 417 418 message1.CopyFrom(message2); 419 420 // Checks repeated field is overwritten. 421 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); 422 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); 423 } 424 425 { 426 // SwapWithEmpty 427 protobuf_unittest::TestMapLite message1, message2; 428 429 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 430 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message1); 431 google::protobuf::MapLiteTestUtil::ExpectClear(message2); 432 433 message1.Swap(&message2); 434 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 435 google::protobuf::MapLiteTestUtil::ExpectClear(message1); 436 } 437 438 { 439 // SwapWithSelf 440 protobuf_unittest::TestMapLite message; 441 442 google::protobuf::MapLiteTestUtil::SetMapFields(&message); 443 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message); 444 445 message.Swap(&message); 446 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message); 447 } 448 449 { 450 // SwapWithOther 451 protobuf_unittest::TestMapLite message1, message2; 452 453 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 454 google::protobuf::MapLiteTestUtil::SetMapFields(&message2); 455 google::protobuf::MapLiteTestUtil::ModifyMapFields(&message2); 456 457 message1.Swap(&message2); 458 google::protobuf::MapLiteTestUtil::ExpectMapFieldsModified(message1); 459 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 460 } 461 462 { 463 // CopyConstructor 464 protobuf_unittest::TestMapLite message1; 465 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 466 467 protobuf_unittest::TestMapLite message2(message1); 468 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 469 } 470 471 { 472 // CopyAssignmentOperator 473 protobuf_unittest::TestMapLite message1; 474 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 475 476 protobuf_unittest::TestMapLite message2; 477 message2 = message1; 478 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 479 480 // Make sure that self-assignment does something sane. 481 message2.operator=(message2); 482 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 483 } 484 485 { 486 // NonEmptyMergeFrom 487 protobuf_unittest::TestMapLite message1, message2; 488 489 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 490 491 // This field will test merging into an empty spot. 492 (*message2.mutable_map_int32_int32())[1] = 1; 493 message1.mutable_map_int32_int32()->erase(1); 494 495 // This tests overwriting. 496 (*message2.mutable_map_int32_double())[1] = 1; 497 (*message1.mutable_map_int32_double())[1] = 2; 498 499 message1.MergeFrom(message2); 500 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message1); 501 } 502 503 { 504 // MergeFromMessageMap 505 protobuf_unittest::TestMessageMapLite message1, message2; 506 507 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100); 508 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101); 509 510 message1.MergeFrom(message2); 511 512 // Checks repeated field is overwritten. 513 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size()); 514 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0)); 515 } 516 517 { 518 // Test the generated SerializeWithCachedSizesToArray() 519 protobuf_unittest::TestMapLite message1, message2; 520 string data; 521 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 522 int size = message1.ByteSize(); 523 data.resize(size); 524 ::google::protobuf::uint8* start = reinterpret_cast< ::google::protobuf::uint8*>(::google::protobuf::string_as_array(&data)); 525 ::google::protobuf::uint8* end = message1.SerializeWithCachedSizesToArray(start); 526 EXPECT_EQ(size, end - start); 527 EXPECT_TRUE(message2.ParseFromString(data)); 528 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 529 } 530 531 { 532 // Test the generated SerializeWithCachedSizes() 533 protobuf_unittest::TestMapLite message1, message2; 534 google::protobuf::MapLiteTestUtil::SetMapFields(&message1); 535 int size = message1.ByteSize(); 536 string data; 537 data.resize(size); 538 { 539 // Allow the output stream to buffer only one byte at a time. 540 google::protobuf::io::ArrayOutputStream array_stream( 541 ::google::protobuf::string_as_array(&data), size, 1); 542 google::protobuf::io::CodedOutputStream output_stream(&array_stream); 543 message1.SerializeWithCachedSizes(&output_stream); 544 EXPECT_FALSE(output_stream.HadError()); 545 EXPECT_EQ(size, output_stream.ByteCount()); 546 } 547 EXPECT_TRUE(message2.ParseFromString(data)); 548 google::protobuf::MapLiteTestUtil::ExpectMapFieldsSet(message2); 549 } 550 551 552 { 553 // Proto2UnknownEnum 554 protobuf_unittest::TestEnumMapPlusExtraLite from; 555 (*from.mutable_known_map_field())[0] = 556 protobuf_unittest::E_PROTO2_MAP_ENUM_FOO_LITE; 557 (*from.mutable_unknown_map_field())[0] = 558 protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE; 559 string data; 560 from.SerializeToString(&data); 561 562 protobuf_unittest::TestEnumMapLite to; 563 EXPECT_TRUE(to.ParseFromString(data)); 564 EXPECT_EQ(0, to.unknown_map_field().size()); 565 EXPECT_FALSE(to.mutable_unknown_fields()->empty()); 566 EXPECT_EQ(1, to.known_map_field().size()); 567 EXPECT_EQ(protobuf_unittest::PROTO2_MAP_ENUM_FOO_LITE, 568 to.known_map_field().at(0)); 569 570 data.clear(); 571 from.Clear(); 572 to.SerializeToString(&data); 573 EXPECT_TRUE(from.ParseFromString(data)); 574 EXPECT_EQ(1, from.known_map_field().size()); 575 EXPECT_EQ(protobuf_unittest::E_PROTO2_MAP_ENUM_FOO_LITE, 576 from.known_map_field().at(0)); 577 EXPECT_EQ(1, from.unknown_map_field().size()); 578 EXPECT_EQ(protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE, 579 from.unknown_map_field().at(0)); 580 } 581 582 { 583 // StandardWireFormat 584 protobuf_unittest::TestMapLite message; 585 string data = "\x0A\x04\x08\x01\x10\x01"; 586 587 EXPECT_TRUE(message.ParseFromString(data)); 588 EXPECT_EQ(1, message.map_int32_int32().size()); 589 EXPECT_EQ(1, message.map_int32_int32().at(1)); 590 } 591 592 { 593 // UnorderedWireFormat 594 protobuf_unittest::TestMapLite message; 595 596 // put value before key in wire format 597 string data = "\x0A\x04\x10\x01\x08\x02"; 598 599 EXPECT_TRUE(message.ParseFromString(data)); 600 EXPECT_EQ(1, message.map_int32_int32().size()); 601 EXPECT_EQ(1, message.map_int32_int32().at(2)); 602 } 603 604 { 605 // DuplicatedKeyWireFormat 606 protobuf_unittest::TestMapLite message; 607 608 // Two key fields in wire format 609 string data = "\x0A\x06\x08\x01\x08\x02\x10\x01"; 610 611 EXPECT_TRUE(message.ParseFromString(data)); 612 EXPECT_EQ(1, message.map_int32_int32().size()); 613 EXPECT_EQ(1, message.map_int32_int32().at(2)); 614 } 615 616 { 617 // DuplicatedValueWireFormat 618 protobuf_unittest::TestMapLite message; 619 620 // Two value fields in wire format 621 string data = "\x0A\x06\x08\x01\x10\x01\x10\x02"; 622 623 EXPECT_TRUE(message.ParseFromString(data)); 624 EXPECT_EQ(1, message.map_int32_int32().size()); 625 EXPECT_EQ(2, message.map_int32_int32().at(1)); 626 } 627 628 { 629 // MissedKeyWireFormat 630 protobuf_unittest::TestMapLite message; 631 632 // No key field in wire format 633 string data = "\x0A\x02\x10\x01"; 634 635 EXPECT_TRUE(message.ParseFromString(data)); 636 EXPECT_EQ(1, message.map_int32_int32().size()); 637 EXPECT_EQ(1, message.map_int32_int32().at(0)); 638 } 639 640 { 641 // MissedValueWireFormat 642 protobuf_unittest::TestMapLite message; 643 644 // No value field in wire format 645 string data = "\x0A\x02\x08\x01"; 646 647 EXPECT_TRUE(message.ParseFromString(data)); 648 EXPECT_EQ(1, message.map_int32_int32().size()); 649 EXPECT_EQ(0, message.map_int32_int32().at(1)); 650 } 651 652 { 653 // UnknownFieldWireFormat 654 protobuf_unittest::TestMapLite message; 655 656 // Unknown field in wire format 657 string data = "\x0A\x06\x08\x02\x10\x03\x18\x01"; 658 659 EXPECT_TRUE(message.ParseFromString(data)); 660 EXPECT_EQ(1, message.map_int32_int32().size()); 661 EXPECT_EQ(3, message.map_int32_int32().at(2)); 662 } 663 664 { 665 // CorruptedWireFormat 666 protobuf_unittest::TestMapLite message; 667 668 // corrupted data in wire format 669 string data = "\x0A\x06\x08\x02\x11\x03"; 670 671 EXPECT_FALSE(message.ParseFromString(data)); 672 } 673 674 { 675 // IsInitialized 676 protobuf_unittest::TestRequiredMessageMapLite map_message; 677 678 // Add an uninitialized message. 679 (*map_message.mutable_map_field())[0]; 680 EXPECT_FALSE(map_message.IsInitialized()); 681 682 // Initialize uninitialized message 683 (*map_message.mutable_map_field())[0].set_a(0); 684 (*map_message.mutable_map_field())[0].set_b(0); 685 (*map_message.mutable_map_field())[0].set_c(0); 686 EXPECT_TRUE(map_message.IsInitialized()); 687 } 688 689 { 690 // Check that adding more values to enum does not corrupt message 691 // when passed through an old client. 692 protobuf_unittest::V2MessageLite v2_message; 693 v2_message.set_int_field(800); 694 // Set enum field to the value not understood by the old client. 695 v2_message.set_enum_field(protobuf_unittest::V2_SECOND); 696 string v2_bytes = v2_message.SerializeAsString(); 697 698 protobuf_unittest::V1MessageLite v1_message; 699 v1_message.ParseFromString(v2_bytes); 700 EXPECT_TRUE(v1_message.IsInitialized()); 701 EXPECT_EQ(v1_message.int_field(), v2_message.int_field()); 702 // V1 client does not understand V2_SECOND value, so it discards it and 703 // uses default value instead. 704 EXPECT_EQ(v1_message.enum_field(), protobuf_unittest::V1_FIRST); 705 706 // However, when re-serialized, it should preserve enum value. 707 string v1_bytes = v1_message.SerializeAsString(); 708 709 protobuf_unittest::V2MessageLite same_v2_message; 710 same_v2_message.ParseFromString(v1_bytes); 711 712 EXPECT_EQ(v2_message.int_field(), same_v2_message.int_field()); 713 EXPECT_EQ(v2_message.enum_field(), same_v2_message.enum_field()); 714 } 715 716 std::cout << "PASS" << std::endl; 717 return 0; 718} 719