src/third_party/protobuf/src/google/protobuf/wire_format_unittest.cc

   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/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_mset.pb.h>
  42 #include <google/protobuf/test_util.h>
  43
  44 #include <google/protobuf/stubs/common.h>
  45 #include <google/protobuf/testing/googletest.h>
  46 #include <gtest/gtest.h>
  47 #include <google/protobuf/stubs/stl_util.h>
  48
  49 namespace google {
  50 namespace protobuf {
  51 namespace internal {
  52 namespace {
  53
  54 TEST(WireFormatTest, EnumsInSync) {
  55   // Verify that WireFormatLite::FieldType and WireFormatLite::CppType match
  56   // FieldDescriptor::Type and FieldDescriptor::CppType.
  57
  58   EXPECT_EQ(implicit_cast<int>(FieldDescriptor::MAX_TYPE),
  59             implicit_cast<int>(WireFormatLite::MAX_FIELD_TYPE));
  60   EXPECT_EQ(implicit_cast<int>(FieldDescriptor::MAX_CPPTYPE),
  61             implicit_cast<int>(WireFormatLite::MAX_CPPTYPE));
  62
  63   for (int i = 1; i <= WireFormatLite::MAX_FIELD_TYPE; i++) {
  64     EXPECT_EQ(
  65       implicit_cast<int>(FieldDescriptor::TypeToCppType(
  66         static_cast<FieldDescriptor::Type>(i))),
  67       implicit_cast<int>(WireFormatLite::FieldTypeToCppType(
  68         static_cast<WireFormatLite::FieldType>(i))));
  69   }
  70 }
  71
  72 TEST(WireFormatTest, MaxFieldNumber) {
  73   // Make sure the max field number constant is accurate.
  74   EXPECT_EQ((1 << (32 - WireFormatLite::kTagTypeBits)) - 1,
  75             FieldDescriptor::kMaxNumber);
  76 }
  77
  78 TEST(WireFormatTest, Parse) {
  79   unittest::TestAllTypes source, dest;
  80   string data;
  81
  82   // Serialize using the generated code.
  83   TestUtil::SetAllFields(&source);
  84   source.SerializeToString(&data);
  85
  86   // Parse using WireFormat.
  87   io::ArrayInputStream raw_input(data.data(), data.size());
  88   io::CodedInputStream input(&raw_input);
  89   WireFormat::ParseAndMergePartial(&input, &dest);
  90
  91   // Check.
  92   TestUtil::ExpectAllFieldsSet(dest);
  93 }
  94
  95 TEST(WireFormatTest, ParseExtensions) {
  96   unittest::TestAllExtensions source, dest;
  97   string data;
  98
  99   // Serialize using the generated code.
 100   TestUtil::SetAllExtensions(&source);
 101   source.SerializeToString(&data);
 102
 103   // Parse using WireFormat.
 104   io::ArrayInputStream raw_input(data.data(), data.size());
 105   io::CodedInputStream input(&raw_input);
 106   WireFormat::ParseAndMergePartial(&input, &dest);
 107
 108   // Check.
 109   TestUtil::ExpectAllExtensionsSet(dest);
 110 }
 111
 112 TEST(WireFormatTest, ParsePacked) {
 113   unittest::TestPackedTypes source, dest;
 114   string data;
 115
 116   // Serialize using the generated code.
 117   TestUtil::SetPackedFields(&source);
 118   source.SerializeToString(&data);
 119
 120   // Parse using WireFormat.
 121   io::ArrayInputStream raw_input(data.data(), data.size());
 122   io::CodedInputStream input(&raw_input);
 123   WireFormat::ParseAndMergePartial(&input, &dest);
 124
 125   // Check.
 126   TestUtil::ExpectPackedFieldsSet(dest);
 127 }
 128
 129 TEST(WireFormatTest, ParsePackedFromUnpacked) {
 130   // Serialize using the generated code.
 131   unittest::TestUnpackedTypes source;
 132   TestUtil::SetUnpackedFields(&source);
 133   string data = source.SerializeAsString();
 134
 135   // Parse using WireFormat.
 136   unittest::TestPackedTypes dest;
 137   io::ArrayInputStream raw_input(data.data(), data.size());
 138   io::CodedInputStream input(&raw_input);
 139   WireFormat::ParseAndMergePartial(&input, &dest);
 140
 141   // Check.
 142   TestUtil::ExpectPackedFieldsSet(dest);
 143 }
 144
 145 TEST(WireFormatTest, ParseUnpackedFromPacked) {
 146   // Serialize using the generated code.
 147   unittest::TestPackedTypes source;
 148   TestUtil::SetPackedFields(&source);
 149   string data = source.SerializeAsString();
 150
 151   // Parse using WireFormat.
 152   unittest::TestUnpackedTypes dest;
 153   io::ArrayInputStream raw_input(data.data(), data.size());
 154   io::CodedInputStream input(&raw_input);
 155   WireFormat::ParseAndMergePartial(&input, &dest);
 156
 157   // Check.
 158   TestUtil::ExpectUnpackedFieldsSet(dest);
 159 }
 160
 161 TEST(WireFormatTest, ParsePackedExtensions) {
 162   unittest::TestPackedExtensions source, dest;
 163   string data;
 164
 165   // Serialize using the generated code.
 166   TestUtil::SetPackedExtensions(&source);
 167   source.SerializeToString(&data);
 168
 169   // Parse using WireFormat.
 170   io::ArrayInputStream raw_input(data.data(), data.size());
 171   io::CodedInputStream input(&raw_input);
 172   WireFormat::ParseAndMergePartial(&input, &dest);
 173
 174   // Check.
 175   TestUtil::ExpectPackedExtensionsSet(dest);
 176 }
 177
 178 TEST(WireFormatTest, ByteSize) {
 179   unittest::TestAllTypes message;
 180   TestUtil::SetAllFields(&message);
 181
 182   EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message));
 183   message.Clear();
 184   EXPECT_EQ(0, message.ByteSize());
 185   EXPECT_EQ(0, WireFormat::ByteSize(message));
 186 }
 187
 188 TEST(WireFormatTest, ByteSizeExtensions) {
 189   unittest::TestAllExtensions message;
 190   TestUtil::SetAllExtensions(&message);
 191
 192   EXPECT_EQ(message.ByteSize(),
 193             WireFormat::ByteSize(message));
 194   message.Clear();
 195   EXPECT_EQ(0, message.ByteSize());
 196   EXPECT_EQ(0, WireFormat::ByteSize(message));
 197 }
 198
 199 TEST(WireFormatTest, ByteSizePacked) {
 200   unittest::TestPackedTypes message;
 201   TestUtil::SetPackedFields(&message);
 202
 203   EXPECT_EQ(message.ByteSize(), WireFormat::ByteSize(message));
 204   message.Clear();
 205   EXPECT_EQ(0, message.ByteSize());
 206   EXPECT_EQ(0, WireFormat::ByteSize(message));
 207 }
 208
 209 TEST(WireFormatTest, ByteSizePackedExtensions) {
 210   unittest::TestPackedExtensions message;
 211   TestUtil::SetPackedExtensions(&message);
 212
 213   EXPECT_EQ(message.ByteSize(),
 214             WireFormat::ByteSize(message));
 215   message.Clear();
 216   EXPECT_EQ(0, message.ByteSize());
 217   EXPECT_EQ(0, WireFormat::ByteSize(message));
 218 }
 219
 220 TEST(WireFormatTest, Serialize) {
 221   unittest::TestAllTypes message;
 222   string generated_data;
 223   string dynamic_data;
 224
 225   TestUtil::SetAllFields(&message);
 226   int size = message.ByteSize();
 227
 228   // Serialize using the generated code.
 229   {
 230     io::StringOutputStream raw_output(&generated_data);
 231     io::CodedOutputStream output(&raw_output);
 232     message.SerializeWithCachedSizes(&output);
 233     ASSERT_FALSE(output.HadError());
 234   }
 235
 236   // Serialize using WireFormat.
 237   {
 238     io::StringOutputStream raw_output(&dynamic_data);
 239     io::CodedOutputStream output(&raw_output);
 240     WireFormat::SerializeWithCachedSizes(message, size, &output);
 241     ASSERT_FALSE(output.HadError());
 242   }
 243
 244   // Should be the same.
 245   // Don't use EXPECT_EQ here because we're comparing raw binary data and
 246   // we really don't want it dumped to stdout on failure.
 247   EXPECT_TRUE(dynamic_data == generated_data);
 248 }
 249
 250 TEST(WireFormatTest, SerializeExtensions) {
 251   unittest::TestAllExtensions message;
 252   string generated_data;
 253   string dynamic_data;
 254
 255   TestUtil::SetAllExtensions(&message);
 256   int size = message.ByteSize();
 257
 258   // Serialize using the generated code.
 259   {
 260     io::StringOutputStream raw_output(&generated_data);
 261     io::CodedOutputStream output(&raw_output);
 262     message.SerializeWithCachedSizes(&output);
 263     ASSERT_FALSE(output.HadError());
 264   }
 265
 266   // Serialize using WireFormat.
 267   {
 268     io::StringOutputStream raw_output(&dynamic_data);
 269     io::CodedOutputStream output(&raw_output);
 270     WireFormat::SerializeWithCachedSizes(message, size, &output);
 271     ASSERT_FALSE(output.HadError());
 272   }
 273
 274   // Should be the same.
 275   // Don't use EXPECT_EQ here because we're comparing raw binary data and
 276   // we really don't want it dumped to stdout on failure.
 277   EXPECT_TRUE(dynamic_data == generated_data);
 278 }
 279
 280 TEST(WireFormatTest, SerializeFieldsAndExtensions) {
 281   unittest::TestFieldOrderings message;
 282   string generated_data;
 283   string dynamic_data;
 284
 285   TestUtil::SetAllFieldsAndExtensions(&message);
 286   int size = message.ByteSize();
 287
 288   // Serialize using the generated code.
 289   {
 290     io::StringOutputStream raw_output(&generated_data);
 291     io::CodedOutputStream output(&raw_output);
 292     message.SerializeWithCachedSizes(&output);
 293     ASSERT_FALSE(output.HadError());
 294   }
 295
 296   // Serialize using WireFormat.
 297   {
 298     io::StringOutputStream raw_output(&dynamic_data);
 299     io::CodedOutputStream output(&raw_output);
 300     WireFormat::SerializeWithCachedSizes(message, size, &output);
 301     ASSERT_FALSE(output.HadError());
 302   }
 303
 304   // Should be the same.
 305   // Don't use EXPECT_EQ here because we're comparing raw binary data and
 306   // we really don't want it dumped to stdout on failure.
 307   EXPECT_TRUE(dynamic_data == generated_data);
 308
 309   // Should output in canonical order.
 310   TestUtil::ExpectAllFieldsAndExtensionsInOrder(dynamic_data);
 311   TestUtil::ExpectAllFieldsAndExtensionsInOrder(generated_data);
 312 }
 313
 314 TEST(WireFormatTest, ParseMultipleExtensionRanges) {
 315   // Make sure we can parse a message that contains multiple extensions ranges.
 316   unittest::TestFieldOrderings source;
 317   string data;
 318
 319   TestUtil::SetAllFieldsAndExtensions(&source);
 320   source.SerializeToString(&data);
 321
 322   {
 323     unittest::TestFieldOrderings dest;
 324     EXPECT_TRUE(dest.ParseFromString(data));
 325     EXPECT_EQ(source.DebugString(), dest.DebugString());
 326   }
 327
 328   // Also test using reflection-based parsing.
 329   {
 330     unittest::TestFieldOrderings dest;
 331     io::ArrayInputStream raw_input(data.data(), data.size());
 332     io::CodedInputStream coded_input(&raw_input);
 333     EXPECT_TRUE(WireFormat::ParseAndMergePartial(&coded_input, &dest));
 334     EXPECT_EQ(source.DebugString(), dest.DebugString());
 335   }
 336 }
 337
 338 const int kUnknownTypeId = 1550055;
 339
 340 TEST(WireFormatTest, SerializeMessageSet) {
 341   // Set up a TestMessageSet with two known messages and an unknown one.
 342   unittest::TestMessageSet message_set;
 343   message_set.MutableExtension(
 344     unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
 345   message_set.MutableExtension(
 346     unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
 347   message_set.mutable_unknown_fields()->AddLengthDelimited(
 348     kUnknownTypeId, "bar");
 349
 350   string data;
 351   ASSERT_TRUE(message_set.SerializeToString(&data));
 352
 353   // Parse back using RawMessageSet and check the contents.
 354   unittest::RawMessageSet raw;
 355   ASSERT_TRUE(raw.ParseFromString(data));
 356
 357   EXPECT_EQ(0, raw.unknown_fields().field_count());
 358
 359   ASSERT_EQ(3, raw.item_size());
 360   EXPECT_EQ(
 361     unittest::TestMessageSetExtension1::descriptor()->extension(0)->number(),
 362     raw.item(0).type_id());
 363   EXPECT_EQ(
 364     unittest::TestMessageSetExtension2::descriptor()->extension(0)->number(),
 365     raw.item(1).type_id());
 366   EXPECT_EQ(kUnknownTypeId, raw.item(2).type_id());
 367
 368   unittest::TestMessageSetExtension1 message1;
 369   EXPECT_TRUE(message1.ParseFromString(raw.item(0).message()));
 370   EXPECT_EQ(123, message1.i());
 371
 372   unittest::TestMessageSetExtension2 message2;
 373   EXPECT_TRUE(message2.ParseFromString(raw.item(1).message()));
 374   EXPECT_EQ("foo", message2.str());
 375
 376   EXPECT_EQ("bar", raw.item(2).message());
 377 }
 378
 379 TEST(WireFormatTest, SerializeMessageSetVariousWaysAreEqual) {
 380   // Serialize a MessageSet to a stream and to a flat array using generated
 381   // code, and also using WireFormat, and check that the results are equal.
 382   // Set up a TestMessageSet with two known messages and an unknown one, as
 383   // above.
 384
 385   unittest::TestMessageSet message_set;
 386   message_set.MutableExtension(
 387     unittest::TestMessageSetExtension1::message_set_extension)->set_i(123);
 388   message_set.MutableExtension(
 389     unittest::TestMessageSetExtension2::message_set_extension)->set_str("foo");
 390   message_set.mutable_unknown_fields()->AddLengthDelimited(
 391     kUnknownTypeId, "bar");
 392
 393   int size = message_set.ByteSize();
 394   EXPECT_EQ(size, message_set.GetCachedSize());
 395   ASSERT_EQ(size, WireFormat::ByteSize(message_set));
 396
 397   string flat_data;
 398   string stream_data;
 399   string dynamic_data;
 400   flat_data.resize(size);
 401   stream_data.resize(size);
 402
 403   // Serialize to flat array
 404   {
 405     uint8* target = reinterpret_cast<uint8*>(string_as_array(&flat_data));
 406     uint8* end = message_set.SerializeWithCachedSizesToArray(target);
 407     EXPECT_EQ(size, end - target);
 408   }
 409
 410   // Serialize to buffer
 411   {
 412     io::ArrayOutputStream array_stream(string_as_array(&stream_data), size, 1);
 413     io::CodedOutputStream output_stream(&array_stream);
 414     message_set.SerializeWithCachedSizes(&output_stream);
 415     ASSERT_FALSE(output_stream.HadError());
 416   }
 417
 418   // Serialize to buffer with WireFormat.
 419   {
 420     io::StringOutputStream string_stream(&dynamic_data);
 421     io::CodedOutputStream output_stream(&string_stream);
 422     WireFormat::SerializeWithCachedSizes(message_set, size, &output_stream);
 423     ASSERT_FALSE(output_stream.HadError());
 424   }
 425
 426   EXPECT_TRUE(flat_data == stream_data);
 427   EXPECT_TRUE(flat_data == dynamic_data);
 428 }
 429
 430 TEST(WireFormatTest, ParseMessageSet) {
 431   // Set up a RawMessageSet with two known messages and an unknown one.
 432   unittest::RawMessageSet raw;
 433
 434   {
 435     unittest::RawMessageSet::Item* item = raw.add_item();
 436     item->set_type_id(
 437       unittest::TestMessageSetExtension1::descriptor()->extension(0)->number());
 438     unittest::TestMessageSetExtension1 message;
 439     message.set_i(123);
 440     message.SerializeToString(item->mutable_message());
 441   }
 442
 443   {
 444     unittest::RawMessageSet::Item* item = raw.add_item();
 445     item->set_type_id(
 446       unittest::TestMessageSetExtension2::descriptor()->extension(0)->number());
 447     unittest::TestMessageSetExtension2 message;
 448     message.set_str("foo");
 449     message.SerializeToString(item->mutable_message());
 450   }
 451
 452   {
 453     unittest::RawMessageSet::Item* item = raw.add_item();
 454     item->set_type_id(kUnknownTypeId);
 455     item->set_message("bar");
 456   }
 457
 458   string data;
 459   ASSERT_TRUE(raw.SerializeToString(&data));
 460
 461   // Parse as a TestMessageSet and check the contents.
 462   unittest::TestMessageSet message_set;
 463   ASSERT_TRUE(message_set.ParseFromString(data));
 464
 465   EXPECT_EQ(123, message_set.GetExtension(
 466     unittest::TestMessageSetExtension1::message_set_extension).i());
 467   EXPECT_EQ("foo", message_set.GetExtension(
 468     unittest::TestMessageSetExtension2::message_set_extension).str());
 469
 470   ASSERT_EQ(1, message_set.unknown_fields().field_count());
 471   ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED,
 472             message_set.unknown_fields().field(0).type());
 473   EXPECT_EQ("bar", message_set.unknown_fields().field(0).length_delimited());
 474
 475   // Also parse using WireFormat.
 476   unittest::TestMessageSet dynamic_message_set;
 477   io::CodedInputStream input(reinterpret_cast<const uint8*>(data.data()),
 478                              data.size());
 479   ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &dynamic_message_set));
 480   EXPECT_EQ(message_set.DebugString(), dynamic_message_set.DebugString());
 481 }
 482
 483 TEST(WireFormatTest, ParseMessageSetWithReverseTagOrder) {
 484   string data;
 485   {
 486     unittest::TestMessageSetExtension1 message;
 487     message.set_i(123);
 488     // Build a MessageSet manually with its message content put before its
 489     // type_id.
 490     io::StringOutputStream output_stream(&data);
 491     io::CodedOutputStream coded_output(&output_stream);
 492     coded_output.WriteTag(WireFormatLite::kMessageSetItemStartTag);
 493     // Write the message content first.
 494     WireFormatLite::WriteTag(WireFormatLite::kMessageSetMessageNumber,
 495                              WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
 496                              &coded_output);
 497     coded_output.WriteVarint32(message.ByteSize());
 498     message.SerializeWithCachedSizes(&coded_output);
 499     // Write the type id.
 500     uint32 type_id = message.GetDescriptor()->extension(0)->number();
 501     WireFormatLite::WriteUInt32(WireFormatLite::kMessageSetTypeIdNumber,
 502                                 type_id, &coded_output);
 503     coded_output.WriteTag(WireFormatLite::kMessageSetItemEndTag);
 504   }
 505   {
 506     unittest::TestMessageSet message_set;
 507     ASSERT_TRUE(message_set.ParseFromString(data));
 508
 509     EXPECT_EQ(123, message_set.GetExtension(
 510         unittest::TestMessageSetExtension1::message_set_extension).i());
 511   }
 512   {
 513     // Test parse the message via Reflection.
 514     unittest::TestMessageSet message_set;
 515     io::CodedInputStream input(
 516         reinterpret_cast<const uint8*>(data.data()), data.size());
 517     EXPECT_TRUE(WireFormat::ParseAndMergePartial(&input, &message_set));
 518     EXPECT_TRUE(input.ConsumedEntireMessage());
 519
 520     EXPECT_EQ(123, message_set.GetExtension(
 521         unittest::TestMessageSetExtension1::message_set_extension).i());
 522   }
 523 }
 524
 525 TEST(WireFormatTest, ParseBrokenMessageSet) {
 526   unittest::TestMessageSet message_set;
 527   string input("goodbye");  // Invalid wire format data.
 528   EXPECT_FALSE(message_set.ParseFromString(input));
 529 }
 530
 531 TEST(WireFormatTest, RecursionLimit) {
 532   unittest::TestRecursiveMessage message;
 533   message.mutable_a()->mutable_a()->mutable_a()->mutable_a()->set_i(1);
 534   string data;
 535   message.SerializeToString(&data);
 536
 537   {
 538     io::ArrayInputStream raw_input(data.data(), data.size());
 539     io::CodedInputStream input(&raw_input);
 540     input.SetRecursionLimit(4);
 541     unittest::TestRecursiveMessage message2;
 542     EXPECT_TRUE(message2.ParseFromCodedStream(&input));
 543   }
 544
 545   {
 546     io::ArrayInputStream raw_input(data.data(), data.size());
 547     io::CodedInputStream input(&raw_input);
 548     input.SetRecursionLimit(3);
 549     unittest::TestRecursiveMessage message2;
 550     EXPECT_FALSE(message2.ParseFromCodedStream(&input));
 551   }
 552 }
 553
 554 TEST(WireFormatTest, UnknownFieldRecursionLimit) {
 555   unittest::TestEmptyMessage message;
 556   message.mutable_unknown_fields()
 557         ->AddGroup(1234)
 558         ->AddGroup(1234)
 559         ->AddGroup(1234)
 560         ->AddGroup(1234)
 561         ->AddVarint(1234, 123);
 562   string data;
 563   message.SerializeToString(&data);
 564
 565   {
 566     io::ArrayInputStream raw_input(data.data(), data.size());
 567     io::CodedInputStream input(&raw_input);
 568     input.SetRecursionLimit(4);
 569     unittest::TestEmptyMessage message2;
 570     EXPECT_TRUE(message2.ParseFromCodedStream(&input));
 571   }
 572
 573   {
 574     io::ArrayInputStream raw_input(data.data(), data.size());
 575     io::CodedInputStream input(&raw_input);
 576     input.SetRecursionLimit(3);
 577     unittest::TestEmptyMessage message2;
 578     EXPECT_FALSE(message2.ParseFromCodedStream(&input));
 579   }
 580 }
 581
 582 TEST(WireFormatTest, ZigZag) {
 583 // avoid line-wrapping
 584 #define LL(x) GOOGLE_LONGLONG(x)
 585 #define ULL(x) GOOGLE_ULONGLONG(x)
 586 #define ZigZagEncode32(x) WireFormatLite::ZigZagEncode32(x)
 587 #define ZigZagDecode32(x) WireFormatLite::ZigZagDecode32(x)
 588 #define ZigZagEncode64(x) WireFormatLite::ZigZagEncode64(x)
 589 #define ZigZagDecode64(x) WireFormatLite::ZigZagDecode64(x)
 590
 591   EXPECT_EQ(0u, ZigZagEncode32( 0));
 592   EXPECT_EQ(1u, ZigZagEncode32(-1));
 593   EXPECT_EQ(2u, ZigZagEncode32( 1));
 594   EXPECT_EQ(3u, ZigZagEncode32(-2));
 595   EXPECT_EQ(0x7FFFFFFEu, ZigZagEncode32(0x3FFFFFFF));
 596   EXPECT_EQ(0x7FFFFFFFu, ZigZagEncode32(0xC0000000));
 597   EXPECT_EQ(0xFFFFFFFEu, ZigZagEncode32(0x7FFFFFFF));
 598   EXPECT_EQ(0xFFFFFFFFu, ZigZagEncode32(0x80000000));
 599
 600   EXPECT_EQ( 0, ZigZagDecode32(0u));
 601   EXPECT_EQ(-1, ZigZagDecode32(1u));
 602   EXPECT_EQ( 1, ZigZagDecode32(2u));
 603   EXPECT_EQ(-2, ZigZagDecode32(3u));
 604   EXPECT_EQ(0x3FFFFFFF, ZigZagDecode32(0x7FFFFFFEu));
 605   EXPECT_EQ(0xC0000000, ZigZagDecode32(0x7FFFFFFFu));
 606   EXPECT_EQ(0x7FFFFFFF, ZigZagDecode32(0xFFFFFFFEu));
 607   EXPECT_EQ(0x80000000, ZigZagDecode32(0xFFFFFFFFu));
 608
 609   EXPECT_EQ(0u, ZigZagEncode64( 0));
 610   EXPECT_EQ(1u, ZigZagEncode64(-1));
 611   EXPECT_EQ(2u, ZigZagEncode64( 1));
 612   EXPECT_EQ(3u, ZigZagEncode64(-2));
 613   EXPECT_EQ(ULL(0x000000007FFFFFFE), ZigZagEncode64(LL(0x000000003FFFFFFF)));
 614   EXPECT_EQ(ULL(0x000000007FFFFFFF), ZigZagEncode64(LL(0xFFFFFFFFC0000000)));
 615   EXPECT_EQ(ULL(0x00000000FFFFFFFE), ZigZagEncode64(LL(0x000000007FFFFFFF)));
 616   EXPECT_EQ(ULL(0x00000000FFFFFFFF), ZigZagEncode64(LL(0xFFFFFFFF80000000)));
 617   EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFE), ZigZagEncode64(LL(0x7FFFFFFFFFFFFFFF)));
 618   EXPECT_EQ(ULL(0xFFFFFFFFFFFFFFFF), ZigZagEncode64(LL(0x8000000000000000)));
 619
 620   EXPECT_EQ( 0, ZigZagDecode64(0u));
 621   EXPECT_EQ(-1, ZigZagDecode64(1u));
 622   EXPECT_EQ( 1, ZigZagDecode64(2u));
 623   EXPECT_EQ(-2, ZigZagDecode64(3u));
 624   EXPECT_EQ(LL(0x000000003FFFFFFF), ZigZagDecode64(ULL(0x000000007FFFFFFE)));
 625   EXPECT_EQ(LL(0xFFFFFFFFC0000000), ZigZagDecode64(ULL(0x000000007FFFFFFF)));
 626   EXPECT_EQ(LL(0x000000007FFFFFFF), ZigZagDecode64(ULL(0x00000000FFFFFFFE)));
 627   EXPECT_EQ(LL(0xFFFFFFFF80000000), ZigZagDecode64(ULL(0x00000000FFFFFFFF)));
 628   EXPECT_EQ(LL(0x7FFFFFFFFFFFFFFF), ZigZagDecode64(ULL(0xFFFFFFFFFFFFFFFE)));
 629   EXPECT_EQ(LL(0x8000000000000000), ZigZagDecode64(ULL(0xFFFFFFFFFFFFFFFF)));
 630
 631   // Some easier-to-verify round-trip tests.  The inputs (other than 0, 1, -1)
 632   // were chosen semi-randomly via keyboard bashing.
 633   EXPECT_EQ(    0, ZigZagDecode32(ZigZagEncode32(    0)));
 634   EXPECT_EQ(    1, ZigZagDecode32(ZigZagEncode32(    1)));
 635   EXPECT_EQ(   -1, ZigZagDecode32(ZigZagEncode32(   -1)));
 636   EXPECT_EQ(14927, ZigZagDecode32(ZigZagEncode32(14927)));
 637   EXPECT_EQ(-3612, ZigZagDecode32(ZigZagEncode32(-3612)));
 638
 639   EXPECT_EQ(    0, ZigZagDecode64(ZigZagEncode64(    0)));
 640   EXPECT_EQ(    1, ZigZagDecode64(ZigZagEncode64(    1)));
 641   EXPECT_EQ(   -1, ZigZagDecode64(ZigZagEncode64(   -1)));
 642   EXPECT_EQ(14927, ZigZagDecode64(ZigZagEncode64(14927)));
 643   EXPECT_EQ(-3612, ZigZagDecode64(ZigZagEncode64(-3612)));
 644
 645   EXPECT_EQ(LL(856912304801416), ZigZagDecode64(ZigZagEncode64(
 646             LL(856912304801416))));
 647   EXPECT_EQ(LL(-75123905439571256), ZigZagDecode64(ZigZagEncode64(
 648             LL(-75123905439571256))));
 649 }
 650
 651 TEST(WireFormatTest, RepeatedScalarsDifferentTagSizes) {
 652   // At one point checks would trigger when parsing repeated fixed scalar
 653   // fields.
 654   protobuf_unittest::TestRepeatedScalarDifferentTagSizes msg1, msg2;
 655   for (int i = 0; i < 100; ++i) {
 656     msg1.add_repeated_fixed32(i);
 657     msg1.add_repeated_int32(i);
 658     msg1.add_repeated_fixed64(i);
 659     msg1.add_repeated_int64(i);
 660     msg1.add_repeated_float(i);
 661     msg1.add_repeated_uint64(i);
 662   }
 663
 664   // Make sure that we have a variety of tag sizes.
 665   const google::protobuf::Descriptor* desc = msg1.GetDescriptor();
 666   const google::protobuf::FieldDescriptor* field;
 667   field = desc->FindFieldByName("repeated_fixed32");
 668   ASSERT_TRUE(field != NULL);
 669   ASSERT_EQ(1, WireFormat::TagSize(field->number(), field->type()));
 670   field = desc->FindFieldByName("repeated_int32");
 671   ASSERT_TRUE(field != NULL);
 672   ASSERT_EQ(1, WireFormat::TagSize(field->number(), field->type()));
 673   field = desc->FindFieldByName("repeated_fixed64");
 674   ASSERT_TRUE(field != NULL);
 675   ASSERT_EQ(2, WireFormat::TagSize(field->number(), field->type()));
 676   field = desc->FindFieldByName("repeated_int64");
 677   ASSERT_TRUE(field != NULL);
 678   ASSERT_EQ(2, WireFormat::TagSize(field->number(), field->type()));
 679   field = desc->FindFieldByName("repeated_float");
 680   ASSERT_TRUE(field != NULL);
 681   ASSERT_EQ(3, WireFormat::TagSize(field->number(), field->type()));
 682   field = desc->FindFieldByName("repeated_uint64");
 683   ASSERT_TRUE(field != NULL);
 684   ASSERT_EQ(3, WireFormat::TagSize(field->number(), field->type()));
 685
 686   EXPECT_TRUE(msg2.ParseFromString(msg1.SerializeAsString()));
 687   EXPECT_EQ(msg1.DebugString(), msg2.DebugString());
 688 }
 689
 690 class WireFormatInvalidInputTest : public testing::Test {
 691  protected:
 692   // Make a serialized TestAllTypes in which the field optional_nested_message
 693   // contains exactly the given bytes, which may be invalid.
 694   string MakeInvalidEmbeddedMessage(const char* bytes, int size) {
 695     const FieldDescriptor* field =
 696       unittest::TestAllTypes::descriptor()->FindFieldByName(
 697         "optional_nested_message");
 698     GOOGLE_CHECK(field != NULL);
 699
 700     string result;
 701
 702     {
 703       io::StringOutputStream raw_output(&result);
 704       io::CodedOutputStream output(&raw_output);
 705
 706       WireFormatLite::WriteBytes(field->number(), string(bytes, size), &output);
 707     }
 708
 709     return result;
 710   }
 711
 712   // Make a serialized TestAllTypes in which the field optionalgroup
 713   // contains exactly the given bytes -- which may be invalid -- and
 714   // possibly no end tag.
 715   string MakeInvalidGroup(const char* bytes, int size, bool include_end_tag) {
 716     const FieldDescriptor* field =
 717       unittest::TestAllTypes::descriptor()->FindFieldByName(
 718         "optionalgroup");
 719     GOOGLE_CHECK(field != NULL);
 720
 721     string result;
 722
 723     {
 724       io::StringOutputStream raw_output(&result);
 725       io::CodedOutputStream output(&raw_output);
 726
 727       output.WriteVarint32(WireFormat::MakeTag(field));
 728       output.WriteString(string(bytes, size));
 729       if (include_end_tag) {
 730         output.WriteVarint32(WireFormatLite::MakeTag(
 731           field->number(), WireFormatLite::WIRETYPE_END_GROUP));
 732       }
 733     }
 734
 735     return result;
 736   }
 737 };
 738
 739 TEST_F(WireFormatInvalidInputTest, InvalidSubMessage) {
 740   unittest::TestAllTypes message;
 741
 742   // Control case.
 743   EXPECT_TRUE(message.ParseFromString(MakeInvalidEmbeddedMessage("", 0)));
 744
 745   // The byte is a valid varint, but not a valid tag (zero).
 746   EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\0", 1)));
 747
 748   // The byte is a malformed varint.
 749   EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\200", 1)));
 750
 751   // The byte is an endgroup tag, but we aren't parsing a group.
 752   EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\014", 1)));
 753
 754   // The byte is a valid varint but not a valid tag (bad wire type).
 755   EXPECT_FALSE(message.ParseFromString(MakeInvalidEmbeddedMessage("\017", 1)));
 756 }
 757
 758 TEST_F(WireFormatInvalidInputTest, InvalidGroup) {
 759   unittest::TestAllTypes message;
 760
 761   // Control case.
 762   EXPECT_TRUE(message.ParseFromString(MakeInvalidGroup("", 0, true)));
 763
 764   // Missing end tag.  Groups cannot end at EOF.
 765   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("", 0, false)));
 766
 767   // The byte is a valid varint, but not a valid tag (zero).
 768   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\0", 1, false)));
 769
 770   // The byte is a malformed varint.
 771   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\200", 1, false)));
 772
 773   // The byte is an endgroup tag, but not the right one for this group.
 774   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\014", 1, false)));
 775
 776   // The byte is a valid varint but not a valid tag (bad wire type).
 777   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\017", 1, true)));
 778 }
 779
 780 TEST_F(WireFormatInvalidInputTest, InvalidUnknownGroup) {
 781   // Use TestEmptyMessage so that the group made by MakeInvalidGroup will not
 782   // be a known tag number.
 783   unittest::TestEmptyMessage message;
 784
 785   // Control case.
 786   EXPECT_TRUE(message.ParseFromString(MakeInvalidGroup("", 0, true)));
 787
 788   // Missing end tag.  Groups cannot end at EOF.
 789   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("", 0, false)));
 790
 791   // The byte is a valid varint, but not a valid tag (zero).
 792   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\0", 1, false)));
 793
 794   // The byte is a malformed varint.
 795   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\200", 1, false)));
 796
 797   // The byte is an endgroup tag, but not the right one for this group.
 798   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\014", 1, false)));
 799
 800   // The byte is a valid varint but not a valid tag (bad wire type).
 801   EXPECT_FALSE(message.ParseFromString(MakeInvalidGroup("\017", 1, true)));
 802 }
 803
 804 TEST_F(WireFormatInvalidInputTest, InvalidStringInUnknownGroup) {
 805   // Test a bug fix:  SkipMessage should fail if the message contains a string
 806   // whose length would extend beyond the message end.
 807
 808   unittest::TestAllTypes message;
 809   message.set_optional_string("foo foo foo foo");
 810   string data;
 811   message.SerializeToString(&data);
 812
 813   // Chop some bytes off the end.
 814   data.resize(data.size() - 4);
 815
 816   // Try to skip it.  Note that the bug was only present when parsing to an
 817   // UnknownFieldSet.
 818   io::ArrayInputStream raw_input(data.data(), data.size());
 819   io::CodedInputStream coded_input(&raw_input);
 820   UnknownFieldSet unknown_fields;
 821   EXPECT_FALSE(WireFormat::SkipMessage(&coded_input, &unknown_fields));
 822 }
 823
 824 // Test differences between string and bytes.
 825 // Value of a string type must be valid UTF-8 string.  When UTF-8
 826 // validation is enabled (GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED):
 827 // WriteInvalidUTF8String:  see error message.
 828 // ReadInvalidUTF8String:  see error message.
 829 // WriteValidUTF8String: fine.
 830 // ReadValidUTF8String:  fine.
 831 // WriteAnyBytes: fine.
 832 // ReadAnyBytes: fine.
 833 const char * kInvalidUTF8String = "Invalid UTF-8: \xA0\xB0\xC0\xD0";
 834 // This used to be "Valid UTF-8: \x01\x02\u8C37\u6B4C", but MSVC seems to
 835 // interpret \u differently from GCC.
 836 const char * kValidUTF8String = "Valid UTF-8: \x01\x02\350\260\267\346\255\214";
 837
 838 template<typename T>
 839 bool WriteMessage(const char *value, T *message, string *wire_buffer) {
 840   message->set_data(value);
 841   wire_buffer->clear();
 842   message->AppendToString(wire_buffer);
 843   return (wire_buffer->size() > 0);
 844 }
 845
 846 template<typename T>
 847 bool ReadMessage(const string &wire_buffer, T *message) {
 848   return message->ParseFromArray(wire_buffer.data(), wire_buffer.size());
 849 }
 850
 851 bool StartsWith(const string& s, const string& prefix) {
 852   return s.substr(0, prefix.length()) == prefix;
 853 }
 854
 855 TEST(Utf8ValidationTest, WriteInvalidUTF8String) {
 856   string wire_buffer;
 857   protobuf_unittest::OneString input;
 858   vector<string> errors;
 859   {
 860     ScopedMemoryLog log;
 861     WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
 862     errors = log.GetMessages(ERROR);
 863   }
 864 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 865   ASSERT_EQ(1, errors.size());
 866   EXPECT_TRUE(StartsWith(errors[0],
 867                          "String field contains invalid UTF-8 data when "
 868                          "serializing a protocol buffer. Use the "
 869                          "'bytes' type if you intend to send raw bytes."));
 870 #else
 871   ASSERT_EQ(0, errors.size());
 872 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 873 }
 874
 875 TEST(Utf8ValidationTest, ReadInvalidUTF8String) {
 876   string wire_buffer;
 877   protobuf_unittest::OneString input;
 878   WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
 879   protobuf_unittest::OneString output;
 880   vector<string> errors;
 881   {
 882     ScopedMemoryLog log;
 883     ReadMessage(wire_buffer, &output);
 884     errors = log.GetMessages(ERROR);
 885   }
 886 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 887   ASSERT_EQ(1, errors.size());
 888   EXPECT_TRUE(StartsWith(errors[0],
 889                          "String field contains invalid UTF-8 data when "
 890                          "parsing a protocol buffer. Use the "
 891                          "'bytes' type if you intend to send raw bytes."));
 892
 893 #else
 894   ASSERT_EQ(0, errors.size());
 895 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 896 }
 897
 898 TEST(Utf8ValidationTest, WriteValidUTF8String) {
 899   string wire_buffer;
 900   protobuf_unittest::OneString input;
 901   vector<string> errors;
 902   {
 903     ScopedMemoryLog log;
 904     WriteMessage(kValidUTF8String, &input, &wire_buffer);
 905     errors = log.GetMessages(ERROR);
 906   }
 907   ASSERT_EQ(0, errors.size());
 908 }
 909
 910 TEST(Utf8ValidationTest, ReadValidUTF8String) {
 911   string wire_buffer;
 912   protobuf_unittest::OneString input;
 913   WriteMessage(kValidUTF8String, &input, &wire_buffer);
 914   protobuf_unittest::OneString output;
 915   vector<string> errors;
 916   {
 917     ScopedMemoryLog log;
 918     ReadMessage(wire_buffer, &output);
 919     errors = log.GetMessages(ERROR);
 920   }
 921   ASSERT_EQ(0, errors.size());
 922   EXPECT_EQ(input.data(), output.data());
 923 }
 924
 925 // Bytes: anything can pass as bytes, use invalid UTF-8 string to test
 926 TEST(Utf8ValidationTest, WriteArbitraryBytes) {
 927   string wire_buffer;
 928   protobuf_unittest::OneBytes input;
 929   vector<string> errors;
 930   {
 931     ScopedMemoryLog log;
 932     WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
 933     errors = log.GetMessages(ERROR);
 934   }
 935   ASSERT_EQ(0, errors.size());
 936 }
 937
 938 TEST(Utf8ValidationTest, ReadArbitraryBytes) {
 939   string wire_buffer;
 940   protobuf_unittest::OneBytes input;
 941   WriteMessage(kInvalidUTF8String, &input, &wire_buffer);
 942   protobuf_unittest::OneBytes output;
 943   vector<string> errors;
 944   {
 945     ScopedMemoryLog log;
 946     ReadMessage(wire_buffer, &output);
 947     errors = log.GetMessages(ERROR);
 948   }
 949   ASSERT_EQ(0, errors.size());
 950   EXPECT_EQ(input.data(), output.data());
 951 }
 952
 953 TEST(Utf8ValidationTest, ParseRepeatedString) {
 954   protobuf_unittest::MoreBytes input;
 955   input.add_data(kValidUTF8String);
 956   input.add_data(kInvalidUTF8String);
 957   input.add_data(kInvalidUTF8String);
 958   string wire_buffer = input.SerializeAsString();
 959
 960   protobuf_unittest::MoreString output;
 961   vector<string> errors;
 962   {
 963     ScopedMemoryLog log;
 964     ReadMessage(wire_buffer, &output);
 965     errors = log.GetMessages(ERROR);
 966   }
 967 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 968   ASSERT_EQ(2, errors.size());
 969 #else
 970   ASSERT_EQ(0, errors.size());
 971 #endif  // GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
 972   EXPECT_EQ(wire_buffer, output.SerializeAsString());
 973 }
 974
 975 }  // namespace
 976 }  // namespace internal
 977 }  // namespace protobuf
 978 }  // namespace google