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 (at) google.com (Kenton Varda) 32 // Based on original Protocol Buffers design by 33 // Sanjay Ghemawat, Jeff Dean, and others. 34 35 #include <google/protobuf/wire_format.h> 36 #include <google/protobuf/wire_format_lite_inl.h> 37 #include <google/protobuf/descriptor.h> 38 #include <google/protobuf/io/zero_copy_stream_impl.h> 39 #include <google/protobuf/io/coded_stream.h> 40 #include <google/protobuf/unittest.pb.h> 41 #include <google/protobuf/unittest_proto3_arena.pb.h> 42 #include <google/protobuf/unittest_mset.pb.h> 43 #include <google/protobuf/unittest_mset_wire_format.pb.h> 44 #include <google/protobuf/test_util.h> 45 46 #include <google/protobuf/stubs/logging.h> 47 #include <google/protobuf/stubs/common.h> 48 #include <google/protobuf/stubs/logging.h> 49 #include <google/protobuf/testing/googletest.h> 50 #include <gtest/gtest.h> 51 #include <google/protobuf/stubs/stl_util.h> 52 53 namespace google { 54 namespace protobuf { 55 namespace internal { 56 namespace { 57 58 TEST(WireFormatTest, EnumsInSync) { 59 // Verify that WireFormatLite::FieldType and WireFormatLite::CppType match 60 // FieldDescriptor::Type and FieldDescriptor::CppType. 61 62 EXPECT_EQ(implicit_cast<int>(FieldDescriptor::MAX_TYPE), 63 implicit_cast<int>(WireFormatLite::MAX_FIELD_TYPE)); 64 EXPECT_EQ(implicit_cast<int>(FieldDescriptor::MAX_CPPTYPE), 65 implicit_cast<int>(WireFormatLite::MAX_CPPTYPE)); 66 67 for (int i = 1; i <= WireFormatLite::MAX_FIELD_TYPE; i++) { 68 EXPECT_EQ( 69 implicit_cast<int>(FieldDescriptor::TypeToCppType( 70 static_cast<FieldDescriptor::Type>(i))), 71 implicit_cast<int>(WireFormatLite::FieldTypeToCppType( 72 static_cast<WireFormatLite::FieldType>(i)))); 73 } 74 } 75 76 TEST(WireFormatTest, MaxFieldNumber) { 77 // Make sure the max field number constant is accurate. 78 EXPECT_EQ((1 << (32 - WireFormatLite::kTagTypeBits)) - 1, 79 FieldDescriptor::kMaxNumber); 80 } 81 82 TEST(WireFormatTest, Parse) { 83 unittest::TestAllTypes source, dest; 84 string data; 85 86 // Serialize using the generated code. 87 TestUtil::SetAllFields(&source); 88 source.SerializeToString(&data); 89 90 // Parse using WireFormat. 91 io::ArrayInputStream raw_input(data.data(), data.size()); 92 io::CodedInputStream input(&raw_input); 93 WireFormat::ParseAndMergePartial(&input, &dest); 94 95 // Check. 96 TestUtil::ExpectAllFieldsSet(dest); 97 } 98 99 TEST(WireFormatTest, ParseExtensions) { 100 unittest::TestAllExtensions source, dest; 101 string data; 102 103 // Serialize using the generated code. 104 TestUtil::SetAllExtensions(&source); 105 source.SerializeToString(&data); 106 107 // Parse using WireFormat. 108 io::ArrayInputStream raw_input(data.data(), data.size()); 109 io::CodedInputStream input(&raw_input); 110 WireFormat::ParseAndMergePartial(&input, &dest); 111 112 // Check. 113 TestUtil::ExpectAllExtensionsSet(dest); 114 } 115 116 TEST(WireFormatTest, ParsePacked) { 117 unittest::TestPackedTypes source, dest; 118 string data; 119 120 // Serialize using the generated code. 121 TestUtil::SetPackedFields(&source); 122 source.SerializeToString(&data); 123 124 // Parse using WireFormat. 125 io::ArrayInputStream raw_input(data.data(), data.size()); 126 io::CodedInputStream input(&raw_input); 127 WireFormat::ParseAndMergePartial(&input, &dest); 128 129 // Check. 130 TestUtil::ExpectPackedFieldsSet(dest); 131 } 132 133 TEST(WireFormatTest, ParsePackedFromUnpacked) { 134 // Serialize using the generated code. 135 unittest::TestUnpackedTypes source; 136 TestUtil::SetUnpackedFields(&source); 137 string data = source.SerializeAsString(); 138 139 // Parse using WireFormat. 140 unittest::TestPackedTypes dest; 141 io::ArrayInputStream raw_input(data.data(), data.size()); 142 io::CodedInputStream input(&raw_input); 143 WireFormat::ParseAndMergePartial(&input, &dest); 144 145 // Check. 146 TestUtil::ExpectPackedFieldsSet(dest); 147 } 148 149 TEST(WireFormatTest, ParseUnpackedFromPacked) { 150 // Serialize using the generated code. 151 unittest::TestPackedTypes source; 152 TestUtil::SetPackedFields(&source); 153 string data = source.SerializeAsString(); 154 155 // Parse using WireFormat. 156 unittest::TestUnpackedTypes dest; 157 io::ArrayInputStream raw_input(data.data(), data.size()); 158 io::CodedInputStream input(&raw_input); 159 WireFormat::ParseAndMergePartial(&input, &dest); 160 161 // Check. 162 TestUtil::ExpectUnpackedFieldsSet(dest); 163 } 164 165 TEST(WireFormatTest, ParsePackedExtensions) { 166 unittest::TestPackedExtensions source, dest; 167 string data; 168 169 // Serialize using the generated code. 170 TestUtil::SetPackedExtensions(&source); 171 source.SerializeToString(&data); 172 173 // Parse using WireFormat. 174 io::ArrayInputStream raw_input(data.data(), data.size()); 175 io::CodedInputStream input(&raw_input); 176 WireFormat::ParseAndMergePartial(&input, &dest); 177 178 // Check. 179 TestUtil::ExpectPackedExtensionsSet(dest); 180 } 181 182 TEST(WireFormatTest, ParseOneof) { 183 unittest::TestOneof2 source, dest; 184 string data; 185 186 // Serialize using the generated code. 187 TestUtil::SetOneof1(&source); 188 source.SerializeToString(&data); 189 190 // Parse using WireFormat. 191 io::ArrayInputStream raw_input(data.data(), data.size()); 192 io::CodedInputStream input(&raw_input); 193 WireFormat::ParseAndMergePartial(&input, &dest); 194 195 // Check. 196 TestUtil::ExpectOneofSet1(dest); 197 } 198 199 TEST(WireFormatTest, OneofOnlySetLast) { 200 unittest::TestOneofBackwardsCompatible source; 201 unittest::TestOneof oneof_dest; 202 string data; 203 204 // Set two fields 205 source.set_foo_int(100); 206 source.set_foo_string("101"); 207 208 // Serialize and parse to oneof message. 209 source.SerializeToString(&data); 210 io::ArrayInputStream raw_input(data.data(), data.size()); 211 io::CodedInputStream input(&raw_input); 212 WireFormat::ParseAndMergePartial(&input, &oneof_dest); 213 214 // Only the last field is set. 215 EXPECT_FALSE(oneof_dest.has_foo_int()); 216 EXPECT_TRUE(oneof_dest.has_foo_string()); 217 } 218 219 TEST(WireFormatTest, ByteSize) { 220 unittest::TestAllTypes message; 221 TestUtil::SetAllFields(&message); 222 223 EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message)); 224 message.Clear(); 225 EXPECT_EQ(0, message.ByteSize()); 226 EXPECT_EQ(0, WireFormat::ByteSize(message)); 227 } 228 229 TEST(WireFormatTest, ByteSizeExtensions) { 230 unittest::TestAllExtensions message; 231 TestUtil::SetAllExtensions(&message); 232 233 EXPECT_EQ(message.ByteSize(), 234 WireFormat::ByteSize(message)); 235 message.Clear(); 236 EXPECT_EQ(0, message.ByteSize()); 237 EXPECT_EQ(0, WireFormat::ByteSize(message)); 238 } 239 240 TEST(WireFormatTest, ByteSizePacked) { 241 unittest::TestPackedTypes message; 242 TestUtil::SetPackedFields(&message); 243 244 EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message)); 245 message.Clear(); 246 EXPECT_EQ(0, message.ByteSize()); 247 EXPECT_EQ(0, WireFormat::ByteSize(message)); 248 } 249 250 TEST(WireFormatTest, ByteSizePackedExtensions) { 251 unittest::TestPackedExtensions message; 252 TestUtil::SetPackedExtensions(&message); 253 254 EXPECT_EQ(message.ByteSize(), 255 WireFormat::ByteSize(message)); 256 message.Clear(); 257 EXPECT_EQ(0, message.ByteSize()); 258 EXPECT_EQ(0, WireFormat::ByteSize(message)); 259 } 260 261 TEST(WireFormatTest, ByteSizeOneof) { 262 unittest::TestOneof2 message; 263 TestUtil::SetOneof1(&message); 264 265 EXPECT_EQ(message.ByteSize(), 266 WireFormat::ByteSize(message)); 267 message.Clear(); 268 269 EXPECT_EQ(0, message.ByteSize()); 270 EXPECT_EQ(0, WireFormat::ByteSize(message)); 271 } 272 273 TEST(WireFormatTest, Serialize) { 274 unittest::TestAllTypes message; 275 string generated_data; 276 string dynamic_data; 277 278 TestUtil::SetAllFields(&message); 279 int size = message.ByteSize(); 280 281 // Serialize using the generated code. 282 { 283 io::StringOutputStream raw_output(&generated_data); 284 io::CodedOutputStream output(&raw_output); 285 message.SerializeWithCachedSizes(&output); 286 ASSERT_FALSE(output.HadError()); 287 } 288 289 // Serialize using WireFormat. 290 { 291 io::StringOutputStream raw_output(&dynamic_data); 292 io::CodedOutputStream output(&raw_output); 293 WireFormat::SerializeWithCachedSizes(message, size, &output); 294 ASSERT_FALSE(output.HadError()); 295 } 296 297 // Should be the same. 298 // Don't use EXPECT_EQ here because we're comparing raw binary data and 299 // we really don't want it dumped to stdout on failure. 300 EXPECT_TRUE(dynamic_data == generated_data); 301 } 302 303 TEST(WireFormatTest, SerializeExtensions) { 304 unittest::TestAllExtensions message; 305 string generated_data; 306 string dynamic_data; 307 308 TestUtil::SetAllExtensions(&message); 309 int size = message.ByteSize(); 310 311 // Serialize using the generated code. 312 { 313 io::StringOutputStream raw_output(&generated_data); 314 io::CodedOutputStream output(&raw_output); 315 message.SerializeWithCachedSizes(&output); 316 ASSERT_FALSE(output.HadError()); 317 } 318 319 // Serialize using WireFormat. 320 { 321 io::StringOutputStream raw_output(&dynamic_data); 322 io::CodedOutputStream output(&raw_output); 323 WireFormat::SerializeWithCachedSizes(message, size, &output); 324 ASSERT_FALSE(output.HadError()); 325 } 326 327 // Should be the same. 328 // Don't use EXPECT_EQ here because we're comparing raw binary data and 329 // we really don't want it dumped to stdout on failure. 330 EXPECT_TRUE(dynamic_data == generated_data); 331 } 332 333 TEST(WireFormatTest, SerializeFieldsAndExtensions) { 334 unittest::TestFieldOrderings message; 335 string generated_data; 336 string dynamic_data; 337 338 TestUtil::SetAllFieldsAndExtensions(&message); 339 int size = message.ByteSize(); 340 341 // Serialize using the generated code. 342 { 343 io::StringOutputStream raw_output(&generated_data); 344 io::CodedOutputStream output(&raw_output); 345 message.SerializeWithCachedSizes(&output); 346 ASSERT_FALSE(output.HadError()); 347 } 348 349 // Serialize using WireFormat. 350 { 351 io::StringOutputStream raw_output(&dynamic_data); 352 io::CodedOutputStream output(&raw_output); 353 WireFormat::SerializeWithCachedSizes(message, size, &output); 354 ASSERT_FALSE(output.HadError()); 355 } 356 357 // Should be the same. 358 // Don't use EXPECT_EQ here because we're comparing raw binary data and 359 // we really don't want it dumped to stdout on failure. 360 EXPECT_TRUE(dynamic_data == generated_data); 361 362 // Should output in canonical order. 363 TestUtil::ExpectAllFieldsAndExtensionsInOrder(dynamic_data); 364 TestUtil::ExpectAllFieldsAndExtensionsInOrder(generated_data); 365 } 366 367 TEST(WireFormatTest, SerializeOneof) { 368 unittest::TestOneof2 message; 369 string generated_data; 370 string dynamic_data; 371 372 TestUtil::SetOneof1(&message); 373 int size = message.ByteSize(); 374 375 // Serialize using the generated code. 376 { 377 io::StringOutputStream raw_output(&generated_data); 378 io::CodedOutputStream output(&raw_output); 379 message.SerializeWithCachedSizes(&output); 380 ASSERT_FALSE(output.HadError()); 381 } 382 383 // Serialize using WireFormat. 384 { 385 io::StringOutputStream raw_output(&dynamic_data); 386 io::CodedOutputStream output(&raw_output); 387 WireFormat::SerializeWithCachedSizes(message, size, &output); 388 ASSERT_FALSE(output.HadError()); 389 } 390 391 // Should be the same. 392 // Don't use EXPECT_EQ here because we're comparing raw binary data and 393 // we really don't want it dumped to stdout on failure. 394 EXPECT_TRUE(dynamic_data == generated_data); 395 } 396 397 TEST(WireFormatTest, ParseMultipleExtensionRanges) { 398 // Make sure we can parse a message that contains multiple extensions ranges. 399 unittest::TestFieldOrderings source; 400 string data; 401 402 TestUtil::SetAllFieldsAndExtensions(&source); 403 source.SerializeToString(&data); 404 405 { 406 unittest::TestFieldOrderings dest; 407 EXPECT_TRUE(dest.ParseFromString(data)); 408 EXPECT_EQ(source.DebugString(), dest.DebugString()); 409 } 410 411 // Also test using reflection-based parsing. 412 { 413 unittest::TestFieldOrderings dest; 414 io::ArrayInputStream raw_input(data.data(), data.size()); 415 io::CodedInputStream coded_input(&raw_input); 416 EXPECT_TRUE(WireFormat::ParseAndMergePartial(&coded_input, &dest)); 417 EXPECT_EQ(source.DebugString(), dest.DebugString()); 418 } 419 } 420 421 const int kUnknownTypeId = 1550055; 422 423 TEST(WireFormatTest, SerializeMessageSet) { 424 // Set up a TestMessageSet with two known messages and an unknown one. 425 proto2_wireformat_unittest::TestMessageSet message_set; 426 message_set.MutableExtension( 427 unittest::TestMessageSetExtension1::message_set_extension)->set_i(123); 428 message_set.MutableExtension( 429 unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo"); 430 message_set.mutable_unknown_fields()->AddLengthDelimited( 431 kUnknownTypeId, "bar"); 432 433 string data; 434 ASSERT_TRUE(message_set.SerializeToString(&data)); 435 436 // Parse back using RawMessageSet and check the contents. 437 unittest::RawMessageSet raw; 438 ASSERT_TRUE(raw.ParseFromString(data)); 439 440 EXPECT_EQ(0, raw.unknown_fields().field_count()); 441 442 ASSERT_EQ(3, raw.item_size()); 443 EXPECT_EQ( 444 unittest::TestMessageSetExtension1::descriptor()->extension(0)->number(), 445 raw.item(0).type_id()); 446 EXPECT_EQ( 447 unittest::TestMessageSetExtension2::descriptor()->extension(0)->number(), 448 raw.item(1).type_id()); 449 EXPECT_EQ(kUnknownTypeId, raw.item(2).type_id()); 450 451 unittest::TestMessageSetExtension1 message1; 452 EXPECT_TRUE(message1.ParseFromString(raw.item(0).message())); 453 EXPECT_EQ(123, message1.i()); 454 455 unittest::TestMessageSetExtension2 message2; 456 EXPECT_TRUE(message2.ParseFromString(raw.item(1).message())); 457 EXPECT_EQ("foo", message2.str()); 458 459 EXPECT_EQ("bar", raw.item(2).message()); 460 } 461 462 TEST(WireFormatTest, SerializeMessageSetVariousWaysAreEqual) { 463 // Serialize a MessageSet to a stream and to a flat array using generated 464 // code, and also using WireFormat, and check that the results are equal. 465 // Set up a TestMessageSet with two known messages and an unknown one, as 466 // above. 467 468 proto2_wireformat_unittest::TestMessageSet message_set; 469 message_set.MutableExtension( 470 unittest::TestMessageSetExtension1::message_set_extension)->set_i(123); 471 message_set.MutableExtension( 472 unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo"); 473 message_set.mutable_unknown_fields()->AddLengthDelimited( 474 kUnknownTypeId, "bar"); 475 476 int size = message_set.ByteSize(); 477 EXPECT_EQ(size, message_set.GetCachedSize()); 478 ASSERT_EQ(size, WireFormat::ByteSize(message_set)); 479 480 string flat_data; 481 string stream_data; 482 string dynamic_data; 483 flat_data.resize(size); 484 stream_data.resize(size); 485 486 // Serialize to flat array 487 { 488 uint8* target = reinterpret_cast<uint8*>(string_as_array(&flat_data)); 489 uint8* end = message_set.SerializeWithCachedSizesToArray(target); 490 EXPECT_EQ(size, end - target); 491 } 492 493 // Serialize to buffer 494 { 495 io::ArrayOutputStream array_stream(string_as_array(&stream_data), size, 1); 496 io::CodedOutputStream output_stream(&array_stream); 497 message_set.SerializeWithCachedSizes(&output_stream); 498 ASSERT_FALSE(output_stream.HadError()); 499 } 500 501 // Serialize to buffer with WireFormat. 502 { 503 io::StringOutputStream string_stream(&dynamic_data); 504 io::CodedOutputStream output_stream(&string_stream); 505 WireFormat::SerializeWithCachedSizes(message_set, size, &output_stream); 506 ASSERT_FALSE(output_stream.HadError()); 507 } 508 509 EXPECT_TRUE(flat_data == stream_data); 510 EXPECT_TRUE(flat_data == dynamic_data); 511 } 512 513 TEST(WireFormatTest, ParseMessageSet) { 514 // Set up a RawMessageSet with two known messages and an unknown one. 515 unittest::RawMessageSet raw; 516 517 { 518 unittest::RawMessageSet::Item* item = raw.add_item(); 519 item->set_type_id( 520 unittest::TestMessageSetExtension1::descriptor()->extension(0)->number()); 521 unittest::TestMessageSetExtension1 message; 522 message.set_i(123); 523 message.SerializeToString(item->mutable_message()); 524 } 525 526 { 527 unittest::RawMessageSet::Item* item = raw.add_item(); 528 item->set_type_id( 529 unittest::TestMessageSetExtension2::descriptor()->extension(0)->number()); 530 unittest::TestMessageSetExtension2 message; 531 message.set_str("foo"); 532 message.SerializeToString(item->mutable_message()); 533 } 534 535 { 536 unittest::RawMessageSet::Item* item = raw.add_item(); 537 item->set_type_id(kUnknownTypeId); 538 item->set_message("bar"); 539 } 540 541 string data; 542 ASSERT_TRUE(raw.SerializeToString(&data)); 543 544 // Parse as a TestMessageSet and check the contents. 545 proto2_wireformat_unittest::TestMessageSet message_set; 546 ASSERT_TRUE(message_set.ParseFromString(data)); 547 548 EXPECT_EQ(123, message_set.GetExtension( 549 unittest::TestMessageSetExtension1::message_set_extension).i()); 550 EXPECT_EQ("foo", message_set.GetExtension( 551 unittest::TestMessageSetExtension2::message_set_extension).str()); 552 553 ASSERT_EQ(1, message_set.unknown_fields().field_count()); 554 ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED, 555 message_set.unknown_fields().field(0).type()); 556 EXPECT_EQ("bar", message_set.unknown_fields().field(0).length_delimited()); 557 558 // Also parse using WireFormat. 559 proto2_wireformat_unittest::TestMessageSet dynamic_message_set; 560 io::CodedInputStream input(reinterpret_cast<const uint8*>(data.data()), 561 data.size()); 562 ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &dynamic_message_set)); 563 EXPECT_EQ(message_set.DebugString(), dynamic_message_set.DebugString()); 564 } 565 566 TEST(WireFormatTest, ParseMessageSetWithReverseTagOrder) { 567 string data; 568 { 569 unittest::TestMessageSetExtension1 message; 570 message.set_i(123); 571 // Build a MessageSet manually with its message content put before its 572 // type_id. 573 io::StringOutputStream output_stream(&data); 574 io::CodedOutputStream coded_output(&output_stream); 575 coded_output.WriteTag(WireFormatLite::kMessageSetItemStartTag); 576 // Write the message content first. 577 WireFormatLite::WriteTag(WireFormatLite::kMessageSetMessageNumber, 578 WireFormatLite::WIRETYPE_LENGTH_DELIMITED, 579 &coded_output); 580 coded_output.WriteVarint32(message.ByteSize()); 581 message.SerializeWithCachedSizes(&coded_output); 582 // Write the type id. 583 uint32 type_id = message.GetDescriptor()->extension(0)->number(); 584 WireFormatLite::WriteUInt32(WireFormatLite::kMessageSetTypeIdNumber, 585 type_id, &coded_output); 586 coded_output.WriteTag(WireFormatLite::kMessageSetItemEndTag); 587 } 588 { 589 proto2_wireformat_unittest::TestMessageSet message_set; 590 ASSERT_TRUE(message_set.ParseFromString(data)); 591 592 EXPECT_EQ(123, message_set.GetExtension( 593 unittest::TestMessageSetExtension1::message_set_extension).i()); 594 } 595 { 596 // Test parse the message via Reflection. 597 proto2_wireformat_unittest::TestMessageSet message_set; 598 io::CodedInputStream input( 599 reinterpret_cast<const uint8*>(data.data()), data.size()); 600 EXPECT_TRUE(WireFormat::ParseAndMergePartial(&input, &message_set)); 601 EXPECT_TRUE(input.ConsumedEntireMessage()); 602 603 EXPECT_EQ(123, message_set.GetExtension( 604 unittest::TestMessageSetExtension1::message_set_extension).i()); 605 } 606 } 607 608 TEST(WireFormatTest, ParseBrokenMessageSet) { 609 proto2_wireformat_unittest::TestMessageSet message_set; 610 string input("goodbye"); // Invalid wire format data. 611 EXPECT_FALSE(message_set.ParseFromString(input)); 612 } 613 614 TEST(WireFormatTest, RecursionLimit) { 615 unittest::TestRecursiveMessage message; 616 message.mutable_a()->mutable_a()->mutable_a()->mutable_a()->set_i(1); 617 string data; 618 message.SerializeToString(&data); 619 620 { 621 io::ArrayInputStream raw_input(data.data(), data.size()); 622 io::CodedInputStream input(&raw_input); 623 input.SetRecursionLimit(4); 624 unittest::TestRecursiveMessage message2; 625 EXPECT_TRUE(message2.ParseFromCodedStream(&input)); 626 } 627 628 { 629 io::ArrayInputStream raw_input(data.data(), data.size()); 630 io::CodedInputStream input(&raw_input); 631 input.SetRecursionLimit(3); 632 unittest::TestRecursiveMessage message2; 633 EXPECT_FALSE(message2.ParseFromCodedStream(&input)); 634 } 635 } 636 637 TEST(WireFormatTest, UnknownFieldRecursionLimit) { 638 unittest::TestEmptyMessage message; 639 message.mutable_unknown_fields() 640 ->AddGroup(1234) 641 ->AddGroup(1234) 642 ->AddGroup(1234) 643 ->AddGroup(1234) 644 ->AddVarint(1234, 123); 645 string data; 646 message.SerializeToString(&data); 647 648 { 649 io::ArrayInputStream raw_input(data.data(), data.size()); 650 io::CodedInputStream input(&raw_input); 651 input.SetRecursionLimit(4); 652 unittest::TestEmptyMessage message2; 653 EXPECT_TRUE(message2.ParseFromCodedStream(&input)); 654 } 655 656 { 657 io::ArrayInputStream raw_input(data.data(), data.size()); 658 io::CodedInputStream input(&raw_input); 659 input.SetRecursionLimit(3); 660 unittest::TestEmptyMessage message2; 661 EXPECT_FALSE(message2.ParseFromCodedStream(&input)); 662 } 663 } 664 665 TEST(WireFormatTest, ZigZag) { 666 // avoid line-wrapping 667 #define LL(x) GOOGLE_LONGLONG(x) 668 #define ULL(x) GOOGLE_ULONGLONG(x) 669 #define ZigZagEncode32(x) WireFormatLite::ZigZagEncode32(x) 670 #define ZigZagDecode32(x) WireFormatLite::ZigZagDecode32(x) 671 #define ZigZagEncode64(x) WireFormatLite::ZigZagEncode64(x) 672 #define ZigZagDecode64(x) WireFormatLite::ZigZagDecode64(x) 673 674 EXPECT_EQ(0u, ZigZagEncode32( 0)); 675 EXPECT_EQ(1u, ZigZagEncode32(-1)); 676 EXPECT_EQ(2u, ZigZagEncode32( 1)); 677 EXPECT_EQ(3u, ZigZagEncode32(-2)); 678 EXPECT_EQ(0x7FFFFFFEu, ZigZagEncode32(0x3FFFFFFF)); 679 EXPECT_EQ(0x7FFFFFFFu, ZigZagEncode32(0xC0000000)); 680 EXPECT_EQ(0xFFFFFFFEu, ZigZagEncode32(0x7FFFFFFF)); 681 EXPECT_EQ(0xFFFFFFFFu, ZigZagEncode32(0x80000000)); 682 683 EXPECT_EQ( 0, ZigZagDecode32(0u)); 684 EXPECT_EQ(-1, ZigZagDecode32(1u)); 685 EXPECT_EQ( 1, ZigZagDecode32(2u)); 686 EXPECT_EQ(-2, ZigZagDecode32(3u)); 687 EXPECT_EQ(0x3FFFFFFF, ZigZagDecode32(0x7FFFFFFEu)); 688 EXPECT_EQ(0xC0000000, ZigZagDecode32(0x7FFFFFFFu)); 689 EXPECT_EQ(0x7FFFFFFF, ZigZagDecode32(0xFFFFFFFEu)); 690 EXPECT_EQ(0x80000000, ZigZagDecode32(0xFFFFFFFFu)); 691 692 EXPECT_EQ(0u, ZigZagEncode64( 0)); 693 EXPECT_EQ(1u, ZigZagEncode64(-1)); 694 EXPECT_EQ(2u, ZigZagEncode64( 1)); 695 EXPECT_EQ(3u, ZigZagEncode64(-2)); 696 EXPECT_EQ(ULL(0x000000007FFFFFFE), ZigZagEncode64(LL(0x000000003FFFFFFF))); 697 EXPECT_EQ(ULL(0x000000007FFFFFFF), ZigZagEncode64(LL(0xFFFFFFFFC0000000))); 698 EXPECT_EQ(ULL(0x00000000FFFFFFFE), ZigZagEncode64(LL(0x000000007FFFFFFF))); 699 EXPECT_EQ(ULL(0x00000000FFFFFFFF), ZigZagEncode64(LL(0xFFFFFFFF80000000))); 700 EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFE), ZigZagEncode64(LL(0x7FFFFFFFFFFFFFFF))); 701 EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFF), ZigZagEncode64(LL(0x8000000000000000))); 702 703 EXPECT_EQ( 0, ZigZagDecode64(0u)); 704 EXPECT_EQ(-1, ZigZagDecode64(1u)); 705 EXPECT_EQ( 1, ZigZagDecode64(2u)); 706 EXPECT_EQ(-2, ZigZagDecode64(3u)); 707 EXPECT_EQ(LL(0x000000003FFFFFFF), ZigZagDecode64(ULL(0x000000007FFFFFFE))); 708 EXPECT_EQ(LL(0xFFFFFFFFC0000000), ZigZagDecode64(ULL(0x000000007FFFFFFF))); 709 EXPECT_EQ(LL(0x000000007FFFFFFF), ZigZagDecode64(ULL(0x00000000FFFFFFFE))); 710 EXPECT_EQ(LL(0xFFFFFFFF80000000), ZigZagDecode64(ULL(0x00000000FFFFFFFF))); 711 EXPECT_EQ(LL(0x7FFFFFFFFFFFFFFF), ZigZagDecode64(ULL(0xFFFFFFFFFFFFFFFE))); 712 EXPECT_EQ(LL(0x8000000000000000), ZigZagDecode64(ULL(0xFFFFFFFFFFFFFFFF))); 713 714 // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) 715 // were chosen semi-randomly via keyboard bashing. 716 EXPECT_EQ( 0, ZigZagDecode32(ZigZagEncode32( 0))); 717 EXPECT_EQ( 1, ZigZagDecode32(ZigZagEncode32( 1))); 718 EXPECT_EQ( -1, ZigZagDecode32(ZigZagEncode32( -1))); 719 EXPECT_EQ(14927, ZigZagDecode32(ZigZagEncode32(14927))); 720 EXPECT_EQ(-3612, ZigZagDecode32(ZigZagEncode32(-3612))); 721 722 EXPECT_EQ( 0, ZigZagDecode64(ZigZagEncode64( 0))); 723 EXPECT_EQ( 1, ZigZagDecode64(ZigZagEncode64( 1))); 724 EXPECT_EQ( -1, ZigZagDecode64(ZigZagEncode64( -1))); 725 EXPECT_EQ(14927, ZigZagDecode64(ZigZagEncode64(14927))); 726 EXPECT_EQ(-3612, ZigZagDecode64(ZigZagEncode64(-3612))); 727 728 EXPECT_EQ(LL(856912304801416), ZigZagDecode64(ZigZagEncode64( 729 LL(856912304801416)))); 730 EXPECT_EQ(LL(-75123905439571256), ZigZagDecode64(ZigZagEncode64( 731 LL(-75123905439571256)))); 732 } 733 734 TEST(WireFormatTest, RepeatedScalarsDifferentTagSizes) { 735 // At one point checks would trigger when parsing repeated fixed scalar 736 // fields. 737 protobuf_unittest::TestRepeatedScalarDifferentTagSizes msg1, msg2; 738 for (int i = 0; i < 100; ++i) { 739 msg1.add_repeated_fixed32(i); 740 msg1.add_repeated_int32(i); 741 msg1.add_repeated_fixed64(i); 742 msg1.add_repeated_int64(i); 743 msg1.add_repeated_float(i); 744 msg1.add_repeated_uint64(i); 745 } 746 747 // Make sure that we have a variety of tag sizes. 748 const google::protobuf::Descriptor* desc = msg1.GetDescriptor(); 749 const google::protobuf::FieldDescriptor* field; 750 field = desc->FindFieldByName("repeated_fixed32"); 751 ASSERT_TRUE(field != NULL); 752 ASSERT_EQ(1, WireFormat::TagSize(field->number(), field->type())); 753 field = desc->FindFieldByName("repeated_int32"); 754 ASSERT_TRUE(field != NULL); 755 ASSERT_EQ(1, WireFormat::TagSize(field->number(), field->type())); 756 field = desc->FindFieldByName("repeated_fixed64"); 757 ASSERT_TRUE(field != NULL); 758 ASSERT_EQ(2, WireFormat::TagSize(field->number(), field->type())); 759 field = desc->FindFieldByName("repeated_int64"); 760 ASSERT_TRUE(field != NULL); 761 ASSERT_EQ(2, WireFormat::TagSize(field->number(), field->type())); 762 field = desc->FindFieldByName("repeated_float"); 763 ASSERT_TRUE(field != NULL); 764 ASSERT_EQ(3, WireFormat::TagSize(field->number(), field->type())); 765 field = desc->FindFieldByName("repeated_uint64"); 766 ASSERT_TRUE(field != NULL); 767 ASSERT_EQ(3, WireFormat::TagSize(field->number(), field->type())); 768 769 EXPECT_TRUE(msg2.ParseFromString(msg1.SerializeAsString())); 770 EXPECT_EQ(msg1.DebugString(), msg2.DebugString()); 771 } 772 773 TEST(WireFormatTest, CompatibleTypes) { 774 const int64 data = 0x100000000LL; 775 unittest::Int64Message msg1; 776 msg1.set_data(data); 777 string serialized; 778 msg1.SerializeToString(&serialized); 779 780 // Test int64 is compatible with bool 781 unittest::BoolMessage msg2; 782 ASSERT_TRUE(msg2.ParseFromString(serialized)); 783 ASSERT_EQ(static_cast<bool>(data), msg2.data()); 784 785 // Test int64 is compatible with uint64 786 unittest::Uint64Message msg3; 787 ASSERT_TRUE(msg3.ParseFromString(serialized)); 788 ASSERT_EQ(static_cast<uint64>(data), msg3.data()); 789 790 // Test int64 is compatible with int32 791 unittest::Int32Message msg4; 792 ASSERT_TRUE(msg4.ParseFromString(serialized)); 793 ASSERT_EQ(static_cast<int32>(data), msg4.data()); 794 795 // Test int64 is compatible with uint32 796 unittest::Uint32Message msg5; 797 ASSERT_TRUE(msg5.ParseFromString(serialized)); 798 ASSERT_EQ(static_cast<uint32>(data), msg5.data()); 799 } 800 801 class Proto3PrimitiveRepeatedWireFormatTest : public ::testing::Test { 802 protected: 803 Proto3PrimitiveRepeatedWireFormatTest() 804 : packedTestAllTypes_( 805 "\xFA\x01\x01\x01" 806 "\x82\x02\x01\x01" 807 "\x8A\x02\x01\x01" 808 "\x92\x02\x01\x01" 809 "\x9A\x02\x01\x02" 810 "\xA2\x02\x01\x02" 811 "\xAA\x02\x04\x01\x00\x00\x00" 812 "\xB2\x02\x08\x01\x00\x00\x00\x00\x00\x00\x00" 813 "\xBA\x02\x04\x01\x00\x00\x00" 814 "\xC2\x02\x08\x01\x00\x00\x00\x00\x00\x00\x00" 815 "\xCA\x02\x04\x00\x00\x80\x3f" 816 "\xD2\x02\x08\x00\x00\x00\x00\x00\x00\xf0\x3f" 817 "\xDA\x02\x01\x01" 818 "\x9A\x03\x01\x01", 819 86), 820 packedTestUnpackedTypes_( 821 "\x0A\x01\x01" 822 "\x12\x01\x01" 823 "\x1A\x01\x01" 824 "\x22\x01\x01" 825 "\x2A\x01\x02" 826 "\x32\x01\x02" 827 "\x3A\x04\x01\x00\x00\x00" 828 "\x42\x08\x01\x00\x00\x00\x00\x00\x00\x00" 829 "\x4A\x04\x01\x00\x00\x00" 830 "\x52\x08\x01\x00\x00\x00\x00\x00\x00\x00" 831 "\x5A\x04\x00\x00\x80\x3f" 832 "\x62\x08\x00\x00\x00\x00\x00\x00\xf0\x3f" 833 "\x6A\x01\x01" 834 "\x72\x01\x01", 835 72), 836 unpackedTestAllTypes_( 837 "\xF8\x01\x01" 838 "\x80\x02\x01" 839 "\x88\x02\x01" 840 "\x90\x02\x01" 841 "\x98\x02\x02" 842 "\xA0\x02\x02" 843 "\xAD\x02\x01\x00\x00\x00" 844 "\xB1\x02\x01\x00\x00\x00\x00\x00\x00\x00" 845 "\xBD\x02\x01\x00\x00\x00" 846 "\xC1\x02\x01\x00\x00\x00\x00\x00\x00\x00" 847 "\xCD\x02\x00\x00\x80\x3f" 848 "\xD1\x02\x00\x00\x00\x00\x00\x00\xf0\x3f" 849 "\xD8\x02\x01" 850 "\x98\x03\x01", 851 72), 852 unpackedTestUnpackedTypes_( 853 "\x08\x01" 854 "\x10\x01" 855 "\x18\x01" 856 "\x20\x01" 857 "\x28\x02" 858 "\x30\x02" 859 "\x3D\x01\x00\x00\x00" 860 "\x41\x01\x00\x00\x00\x00\x00\x00\x00" 861 "\x4D\x01\x00\x00\x00" 862 "\x51\x01\x00\x00\x00\x00\x00\x00\x00" 863 "\x5D\x00\x00\x80\x3f" 864 "\x61\x00\x00\x00\x00\x00\x00\xf0\x3f" 865 "\x68\x01" 866 "\x70\x01", 867 58) {} 868 template <class Proto> 869 void SetProto3PrimitiveRepeatedFields(Proto* message) { 870 message->add_repeated_int32(1); 871 message->add_repeated_int64(1); 872 message->add_repeated_uint32(1); 873 message->add_repeated_uint64(1); 874 message->add_repeated_sint32(1); 875 message->add_repeated_sint64(1); 876 message->add_repeated_fixed32(1); 877 message->add_repeated_fixed64(1); 878 message->add_repeated_sfixed32(1); 879 message->add_repeated_sfixed64(1); 880 message->add_repeated_float(1.0); 881 message->add_repeated_double(1.0); 882 message->add_repeated_bool(true); 883 message->add_repeated_nested_enum( 884 proto3_arena_unittest::TestAllTypes_NestedEnum_FOO); 885 } 886 887 template <class Proto> 888 void ExpectProto3PrimitiveRepeatedFieldsSet(const Proto& message) { 889 EXPECT_EQ(1, message.repeated_int32(0)); 890 EXPECT_EQ(1, message.repeated_int64(0)); 891 EXPECT_EQ(1, message.repeated_uint32(0)); 892 EXPECT_EQ(1, message.repeated_uint64(0)); 893 EXPECT_EQ(1, message.repeated_sint32(0)); 894 EXPECT_EQ(1, message.repeated_sint64(0)); 895 EXPECT_EQ(1, message.repeated_fixed32(0)); 896 EXPECT_EQ(1, message.repeated_fixed64(0)); 897 EXPECT_EQ(1, message.repeated_sfixed32(0)); 898 EXPECT_EQ(1, message.repeated_sfixed64(0)); 899 EXPECT_EQ(1.0, message.repeated_float(0)); 900 EXPECT_EQ(1.0, message.repeated_double(0)); 901 EXPECT_EQ(true, message.repeated_bool(0)); 902 EXPECT_EQ(proto3_arena_unittest::TestAllTypes_NestedEnum_FOO, 903 message.repeated_nested_enum(0)); 904 } 905 906 template <class Proto> 907 void TestSerialization(Proto* message, const string& expected) { 908 SetProto3PrimitiveRepeatedFields(message); 909 910 int size = message->ByteSize(); 911 912 // Serialize using the generated code. 913 string generated_data; 914 { 915 io::StringOutputStream raw_output(&generated_data); 916 io::CodedOutputStream output(&raw_output); 917 message->SerializeWithCachedSizes(&output); 918 ASSERT_FALSE(output.HadError()); 919 } 920 EXPECT_TRUE(expected == generated_data); 921 922 // Serialize using the dynamic code. 923 string dynamic_data; 924 { 925 io::StringOutputStream raw_output(&dynamic_data); 926 io::CodedOutputStream output(&raw_output); 927 WireFormat::SerializeWithCachedSizes(*message, size, &output); 928 ASSERT_FALSE(output.HadError()); 929 } 930 EXPECT_TRUE(expected == dynamic_data); 931 } 932 933 template <class Proto> 934 void TestParsing(Proto* message, const string& compatible_data) { 935 message->Clear(); 936 message->ParseFromString(compatible_data); 937 ExpectProto3PrimitiveRepeatedFieldsSet(*message); 938 939 message->Clear(); 940 io::CodedInputStream input( 941 reinterpret_cast<const uint8*>(compatible_data.data()), 942 compatible_data.size()); 943 WireFormat::ParseAndMergePartial(&input, message); 944 ExpectProto3PrimitiveRepeatedFieldsSet(*message); 945 } 946 947 const string packedTestAllTypes_; 948 const string packedTestUnpackedTypes_; 949 const string unpackedTestAllTypes_; 950 const string unpackedTestUnpackedTypes_; 951 }; 952 953 TEST_F(Proto3PrimitiveRepeatedWireFormatTest, Proto3PrimitiveRepeated) { 954 proto3_arena_unittest::TestAllTypes packed_message; 955 proto3_arena_unittest::TestUnpackedTypes unpacked_message; 956 TestSerialization(&packed_message, packedTestAllTypes_); 957 TestParsing(&packed_message, packedTestAllTypes_); 958 TestParsing(&packed_message, unpackedTestAllTypes_); 959 TestSerialization(&unpacked_message, unpackedTestUnpackedTypes_); 960 TestParsing(&unpacked_message, packedTestUnpackedTypes_); 961 TestParsing(&unpacked_message, unpackedTestUnpackedTypes_); 962 } 963 964 class WireFormatInvalidInputTest : public testing::Test { 965 protected: 966 // Make a serialized TestAllTypes in which the field optional_nested_message 967 // contains exactly the given bytes, which may be invalid. 968 string MakeInvalidEmbeddedMessage(const char* bytes, int size) { 969 const FieldDescriptor* field = 970 unittest::TestAllTypes::descriptor()->FindFieldByName( 971 "optional_nested_message"); 972 GOOGLE_CHECK(field != NULL); 973 974 string result; 975 976 { 977 io::StringOutputStream raw_output(&result); 978 io::CodedOutputStream output(&raw_output); 979 980 WireFormatLite::WriteBytes(field->number(), string(bytes, size), &output); 981 } 982 983 return result; 984 } 985 986 // Make a serialized TestAllTypes in which the field optionalgroup 987 // contains exactly the given bytes -- which may be invalid -- and 988 // possibly no end tag. 989 string MakeInvalidGroup(const char* bytes, int size, bool include_end_tag) { 990 const FieldDescriptor* field = 991 unittest::TestAllTypes::descriptor()->FindFieldByName( 992 "optionalgroup"); 993 GOOGLE_CHECK(field != NULL); 994 995 string result; 996 997 { 998 io::StringOutputStream raw_output(&result); 999 io::CodedOutputStream output(&raw_output); 1000 1001 output.WriteVarint32(WireFormat::MakeTag(field)); 1002 output.WriteString(string(bytes, size)); 1003 if (include_end_tag) { 1004 output.WriteVarint32(WireFormatLite::MakeTag( 1005 field->number(), WireFormatLite::WIRETYPE_END_GROUP)); 1006 } 1007 } 1008 1009 return result; 1010 } 1011 }; 1012 1013 TEST_F(WireFormatInvalidInputTest, InvalidSubMessage) { 1014 unittest::TestAllTypes message; 1015 1016 // Control case. 1017 EXPECT_TRUE(message.ParseFromString(MakeInvalidEmbeddedMessage("", 0))); 1018 1019 // The byte is a valid varint, but not a valid tag (zero). 1020 EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\0", 1))); 1021 1022 // The byte is a malformed varint. 1023 EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\200", 1))); 1024 1025 // The byte is an endgroup tag, but we aren't parsing a group. 1026 EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\014", 1))); 1027 1028 // The byte is a valid varint but not a valid tag (bad wire type). 1029 EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\017", 1))); 1030 } 1031 1032 TEST_F(WireFormatInvalidInputTest, InvalidGroup) { 1033 unittest::TestAllTypes message; 1034 1035 // Control case. 1036 EXPECT_TRUE(message.ParseFromString(MakeInvalidGroup("", 0, true))); 1037 1038 // Missing end tag. Groups cannot end at EOF. 1039 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("", 0, false))); 1040 1041 // The byte is a valid varint, but not a valid tag (zero). 1042 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\0", 1, false))); 1043 1044 // The byte is a malformed varint. 1045 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\200", 1, false))); 1046 1047 // The byte is an endgroup tag, but not the right one for this group. 1048 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\014", 1, false))); 1049 1050 // The byte is a valid varint but not a valid tag (bad wire type). 1051 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\017", 1, true))); 1052 } 1053 1054 TEST_F(WireFormatInvalidInputTest, InvalidUnknownGroup) { 1055 // Use TestEmptyMessage so that the group made by MakeInvalidGroup will not 1056 // be a known tag number. 1057 unittest::TestEmptyMessage message; 1058 1059 // Control case. 1060 EXPECT_TRUE(message.ParseFromString(MakeInvalidGroup("", 0, true))); 1061 1062 // Missing end tag. Groups cannot end at EOF. 1063 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("", 0, false))); 1064 1065 // The byte is a valid varint, but not a valid tag (zero). 1066 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\0", 1, false))); 1067 1068 // The byte is a malformed varint. 1069 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\200", 1, false))); 1070 1071 // The byte is an endgroup tag, but not the right one for this group. 1072 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\014", 1, false))); 1073 1074 // The byte is a valid varint but not a valid tag (bad wire type). 1075 EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\017", 1, true))); 1076 } 1077 1078 TEST_F(WireFormatInvalidInputTest, InvalidStringInUnknownGroup) { 1079 // Test a bug fix: SkipMessage should fail if the message contains a string 1080 // whose length would extend beyond the message end. 1081 1082 unittest::TestAllTypes message; 1083 message.set_optional_string("foo foo foo foo"); 1084 string data; 1085 message.SerializeToString(&data); 1086 1087 // Chop some bytes off the end. 1088 data.resize(data.size() - 4); 1089 1090 // Try to skip it. Note that the bug was only present when parsing to an 1091 // UnknownFieldSet. 1092 io::ArrayInputStream raw_input(data.data(), data.size()); 1093 io::CodedInputStream coded_input(&raw_input); 1094 UnknownFieldSet unknown_fields; 1095 EXPECT_FALSE(WireFormat::SkipMessage(&coded_input, &unknown_fields)); 1096 } 1097 1098 // Test differences between string and bytes. 1099 // Value of a string type must be valid UTF-8 string. When UTF-8 1100 // validation is enabled (GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED): 1101 // WriteInvalidUTF8String: see error message. 1102 // ReadInvalidUTF8String: see error message. 1103 // WriteValidUTF8String: fine. 1104 // ReadValidUTF8String: fine. 1105 // WriteAnyBytes: fine. 1106 // ReadAnyBytes: fine. 1107 const char * kInvalidUTF8String = "Invalid UTF-8: \xA0\xB0\xC0\xD0"; 1108 // This used to be "Valid UTF-8: \x01\x02\u8C37\u6B4C", but MSVC seems to 1109 // interpret \u differently from GCC. 1110 const char * kValidUTF8String = "Valid UTF-8: \x01\x02\350\260\267\346\255\214"; 1111 1112 template<typename T> 1113 bool WriteMessage(const char *value, T *message, string *wire_buffer) { 1114 message->set_data(value); 1115 wire_buffer->clear(); 1116 message->AppendToString(wire_buffer); 1117 return (wire_buffer->size() > 0); 1118 } 1119 1120 template<typename T> 1121 bool ReadMessage(const string &wire_buffer, T *message) { 1122 return message->ParseFromArray(wire_buffer.data(), wire_buffer.size()); 1123 } 1124 1125 bool StartsWith(const string& s, const string& prefix) { 1126 return s.substr(0, prefix.length()) == prefix; 1127 } 1128 1129 class Utf8ValidationTest : public ::testing::Test { 1130 protected: 1131 Utf8ValidationTest() {} 1132 virtual ~Utf8ValidationTest() {} 1133 virtual void SetUp() { 1134 } 1135 1136 }; 1137 1138 TEST_F(Utf8ValidationTest, WriteInvalidUTF8String) { 1139 string wire_buffer; 1140 protobuf_unittest::OneString input; 1141 vector<string> errors; 1142 { 1143 ScopedMemoryLog log; 1144 WriteMessage(kInvalidUTF8String, &input, &wire_buffer); 1145 errors = log.GetMessages(ERROR); 1146 } 1147 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1148 ASSERT_EQ(1, errors.size()); 1149 EXPECT_TRUE(StartsWith(errors[0], 1150 "String field 'protobuf_unittest.OneString.data' " 1151 "contains invalid UTF-8 data when " 1152 "serializing a protocol buffer. Use the " 1153 "'bytes' type if you intend to send raw bytes.")); 1154 #else 1155 ASSERT_EQ(0, errors.size()); 1156 #endif // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1157 } 1158 1159 1160 TEST_F(Utf8ValidationTest, ReadInvalidUTF8String) { 1161 string wire_buffer; 1162 protobuf_unittest::OneString input; 1163 WriteMessage(kInvalidUTF8String, &input, &wire_buffer); 1164 protobuf_unittest::OneString output; 1165 vector<string> errors; 1166 { 1167 ScopedMemoryLog log; 1168 ReadMessage(wire_buffer, &output); 1169 errors = log.GetMessages(ERROR); 1170 } 1171 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1172 ASSERT_EQ(1, errors.size()); 1173 EXPECT_TRUE(StartsWith(errors[0], 1174 "String field 'protobuf_unittest.OneString.data' " 1175 "contains invalid UTF-8 data when " 1176 "parsing a protocol buffer. Use the " 1177 "'bytes' type if you intend to send raw bytes.")); 1178 1179 #else 1180 ASSERT_EQ(0, errors.size()); 1181 #endif // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1182 } 1183 1184 1185 TEST_F(Utf8ValidationTest, WriteValidUTF8String) { 1186 string wire_buffer; 1187 protobuf_unittest::OneString input; 1188 vector<string> errors; 1189 { 1190 ScopedMemoryLog log; 1191 WriteMessage(kValidUTF8String, &input, &wire_buffer); 1192 errors = log.GetMessages(ERROR); 1193 } 1194 ASSERT_EQ(0, errors.size()); 1195 } 1196 1197 TEST_F(Utf8ValidationTest, ReadValidUTF8String) { 1198 string wire_buffer; 1199 protobuf_unittest::OneString input; 1200 WriteMessage(kValidUTF8String, &input, &wire_buffer); 1201 protobuf_unittest::OneString output; 1202 vector<string> errors; 1203 { 1204 ScopedMemoryLog log; 1205 ReadMessage(wire_buffer, &output); 1206 errors = log.GetMessages(ERROR); 1207 } 1208 ASSERT_EQ(0, errors.size()); 1209 EXPECT_EQ(input.data(), output.data()); 1210 } 1211 1212 // Bytes: anything can pass as bytes, use invalid UTF-8 string to test 1213 TEST_F(Utf8ValidationTest, WriteArbitraryBytes) { 1214 string wire_buffer; 1215 protobuf_unittest::OneBytes input; 1216 vector<string> errors; 1217 { 1218 ScopedMemoryLog log; 1219 WriteMessage(kInvalidUTF8String, &input, &wire_buffer); 1220 errors = log.GetMessages(ERROR); 1221 } 1222 ASSERT_EQ(0, errors.size()); 1223 } 1224 1225 TEST_F(Utf8ValidationTest, ReadArbitraryBytes) { 1226 string wire_buffer; 1227 protobuf_unittest::OneBytes input; 1228 WriteMessage(kInvalidUTF8String, &input, &wire_buffer); 1229 protobuf_unittest::OneBytes output; 1230 vector<string> errors; 1231 { 1232 ScopedMemoryLog log; 1233 ReadMessage(wire_buffer, &output); 1234 errors = log.GetMessages(ERROR); 1235 } 1236 ASSERT_EQ(0, errors.size()); 1237 EXPECT_EQ(input.data(), output.data()); 1238 } 1239 1240 TEST_F(Utf8ValidationTest, ParseRepeatedString) { 1241 protobuf_unittest::MoreBytes input; 1242 input.add_data(kValidUTF8String); 1243 input.add_data(kInvalidUTF8String); 1244 input.add_data(kInvalidUTF8String); 1245 string wire_buffer = input.SerializeAsString(); 1246 1247 protobuf_unittest::MoreString output; 1248 vector<string> errors; 1249 { 1250 ScopedMemoryLog log; 1251 ReadMessage(wire_buffer, &output); 1252 errors = log.GetMessages(ERROR); 1253 } 1254 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1255 ASSERT_EQ(2, errors.size()); 1256 #else 1257 ASSERT_EQ(0, errors.size()); 1258 #endif // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1259 EXPECT_EQ(wire_buffer, output.SerializeAsString()); 1260 } 1261 1262 // Test the old VerifyUTF8String() function, which may still be called by old 1263 // generated code. 1264 TEST_F(Utf8ValidationTest, OldVerifyUTF8String) { 1265 string data(kInvalidUTF8String); 1266 1267 vector<string> errors; 1268 { 1269 ScopedMemoryLog log; 1270 WireFormat::VerifyUTF8String(data.data(), data.size(), 1271 WireFormat::SERIALIZE); 1272 errors = log.GetMessages(ERROR); 1273 } 1274 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED 1275 ASSERT_EQ(1, errors.size()); 1276 EXPECT_TRUE(StartsWith(errors[0], 1277 "String field contains invalid UTF-8 data when " 1278 "serializing a protocol buffer. Use the " 1279 "'bytes' type if you intend to send raw bytes.")); 1280 #else 1281 ASSERT_EQ(0, errors.size()); 1282 #endif 1283 } 1284 1285 1286 } // namespace 1287 } // namespace internal 1288 } // namespace protobuf 1289 } // namespace google 1290
