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