1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 // Author: kenton@google.com (Kenton Varda)
9
10 #include <climits>
11 #include <cstdint>
12 #include <iostream>
13 #include <limits>
14 #include <string>
15 #include <type_traits>
16 #include <utility>
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include "absl/log/absl_check.h"
21 #include "absl/strings/match.h"
22 #include "absl/strings/str_cat.h"
23 #include "absl/strings/string_view.h"
24 #include "google/protobuf/arena_test_util.h"
25 #include "google/protobuf/io/coded_stream.h"
26 #include "google/protobuf/io/zero_copy_stream.h"
27 #include "google/protobuf/io/zero_copy_stream_impl.h"
28 #include "google/protobuf/io/zero_copy_stream_impl_lite.h"
29 #include "google/protobuf/map_lite_test_util.h"
30 #include "google/protobuf/map_lite_unittest.pb.h"
31 #include "google/protobuf/message_lite.h"
32 #include "google/protobuf/parse_context.h"
33 #include "google/protobuf/test_util_lite.h"
34 #include "google/protobuf/unittest_lite.pb.h"
35 #include "google/protobuf/wire_format_lite.h"
36
37
38 // Must be included last
39 #include "google/protobuf/port_def.inc"
40
41 namespace google {
42 namespace protobuf {
43 namespace {
44
45 // Helper methods to test parsing merge behavior.
ExpectMessageMerged(const unittest::TestAllTypesLite & message)46 void ExpectMessageMerged(const unittest::TestAllTypesLite& message) {
47 EXPECT_EQ(message.optional_int32(), 3);
48 EXPECT_EQ(message.optional_int64(), 2);
49 EXPECT_EQ(message.optional_string(), "hello");
50 }
51
AssignParsingMergeMessages(unittest::TestAllTypesLite * msg1,unittest::TestAllTypesLite * msg2,unittest::TestAllTypesLite * msg3)52 void AssignParsingMergeMessages(unittest::TestAllTypesLite* msg1,
53 unittest::TestAllTypesLite* msg2,
54 unittest::TestAllTypesLite* msg3) {
55 msg1->set_optional_int32(1);
56 msg2->set_optional_int64(2);
57 msg3->set_optional_int32(3);
58 msg3->set_optional_string("hello");
59 }
60
61 // Declare and define the template `T SerializeAs()` function which we
62 // specialize for the typed tests serializing to a string or Cord.
63 template <typename T>
64 T SerializeAs(const MessageLite& msg);
65
66 template <>
SerializeAs(const MessageLite & msg)67 std::string SerializeAs<std::string>(const MessageLite& msg) {
68 return msg.SerializeAsString();
69 }
70
71 template <>
SerializeAs(const MessageLite & msg)72 absl::Cord SerializeAs<absl::Cord>(const MessageLite& msg) {
73 return msg.SerializeAsCord();
74 }
75
76 // `ParseFrom()` is overloaded for string and Cord and used in the
77 // typed tests parsing from string and Cord values.
ParseFrom(const std::string & data,MessageLite & msg)78 bool ParseFrom(const std::string& data, MessageLite& msg) {
79 return msg.ParseFromString(data);
80 }
81
ParseFrom(const absl::Cord & data,MessageLite & msg)82 bool ParseFrom(const absl::Cord& data, MessageLite& msg) {
83 return msg.ParseFromCord(data);
84 }
85
86 template <typename T>
SetAllTypesInEmptyMessageUnknownFields(unittest::TestEmptyMessageLite * empty_message)87 void SetAllTypesInEmptyMessageUnknownFields(
88 unittest::TestEmptyMessageLite* empty_message) {
89 protobuf_unittest::TestAllTypesLite message;
90 TestUtilLite::ExpectClear(message);
91 TestUtilLite::SetAllFields(&message);
92 T data = SerializeAs<T>(message);
93 ParseFrom(data, *empty_message);
94 }
95
SetSomeTypesInEmptyMessageUnknownFields(unittest::TestEmptyMessageLite * empty_message)96 void SetSomeTypesInEmptyMessageUnknownFields(
97 unittest::TestEmptyMessageLite* empty_message) {
98 protobuf_unittest::TestAllTypesLite message;
99 TestUtilLite::ExpectClear(message);
100 message.set_optional_int32(101);
101 message.set_optional_int64(102);
102 message.set_optional_uint32(103);
103 message.set_optional_uint64(104);
104 std::string data = message.SerializeAsString();
105 empty_message->ParseFromString(data);
106 }
107
108
TEST(ParseVarintTest,Varint32)109 TEST(ParseVarintTest, Varint32) {
110 auto test_value = [](uint32_t value, int varint_length) {
111 uint8_t buffer[10] = {0};
112 uint8_t* p = io::CodedOutputStream::WriteVarint32ToArray(value, buffer);
113 ASSERT_EQ(p - buffer, varint_length) << "Value = " << value;
114
115 const char* cbuffer = reinterpret_cast<const char*>(buffer);
116 uint32_t parsed = ~value;
117 const char* r = internal::VarintParse(cbuffer, &parsed);
118 ASSERT_EQ(r - cbuffer, varint_length) << "Value = " << value;
119 ASSERT_EQ(parsed, value);
120 };
121
122 uint32_t base = 73; // 1001011b
123 for (int varint_length = 1; varint_length <= 5; ++varint_length) {
124 uint32_t values[] = {
125 base - 73, base - 72, base, base + 126 - 73, base + 126 - 72,
126 };
127 for (uint32_t value : values) {
128 test_value(value, varint_length);
129 }
130 base = (base << 7) + 73;
131 }
132
133 test_value(std::numeric_limits<uint32_t>::max(), 5);
134 }
135
TEST(ParseVarintTest,Varint64)136 TEST(ParseVarintTest, Varint64) {
137 auto test_value = [](uint64_t value, int varint_length) {
138 uint8_t buffer[10] = {0};
139 uint8_t* p = io::CodedOutputStream::WriteVarint64ToArray(value, buffer);
140 ASSERT_EQ(p - buffer, varint_length) << "Value = " << value;
141
142 const char* cbuffer = reinterpret_cast<const char*>(buffer);
143 uint64_t parsed = ~value;
144 const char* r = internal::VarintParse(cbuffer, &parsed);
145 ASSERT_EQ(r - cbuffer, varint_length) << "Value = " << value;
146 ASSERT_EQ(parsed, value);
147 };
148
149 uint64_t base = 73; // 1001011b
150 for (int varint_length = 1; varint_length <= 10; ++varint_length) {
151 uint64_t values[] = {
152 base - 73, base - 72, base, base + 126 - 73, base + 126 - 72,
153 };
154 for (uint64_t value : values) {
155 test_value(value, varint_length);
156 }
157 base = (base << 7) + 73;
158 }
159
160 test_value(std::numeric_limits<uint64_t>::max(), 10);
161 }
162
163 template <typename T>
164 class LiteTest : public ::testing::Test {};
165
166 struct TypedTestName {
167 template <typename T>
GetNamegoogle::protobuf::__anon97d70a880111::TypedTestName168 static std::string GetName(int /*i*/) {
169 return std::is_same<T, absl::Cord>::value ? "Cord" : "String";
170 }
171 };
172
173 using SerializedDataTypes = ::testing::Types<std::string, absl::Cord>;
174 TYPED_TEST_SUITE(LiteTest, SerializedDataTypes, TypedTestName);
175
TYPED_TEST(LiteTest,AllLite1)176 TYPED_TEST(LiteTest, AllLite1) {
177 {
178 protobuf_unittest::TestAllTypesLite message, message2, message3;
179 TestUtilLite::ExpectClear(message);
180 TestUtilLite::SetAllFields(&message);
181 message2 = message;
182 TypeParam data = SerializeAs<TypeParam>(message2);
183 ParseFrom(data, message3);
184 TestUtilLite::ExpectAllFieldsSet(message);
185 TestUtilLite::ExpectAllFieldsSet(message2);
186 TestUtilLite::ExpectAllFieldsSet(message3);
187 TestUtilLite::ModifyRepeatedFields(&message);
188 TestUtilLite::ExpectRepeatedFieldsModified(message);
189 message.Clear();
190 TestUtilLite::ExpectClear(message);
191 }
192 }
193
TYPED_TEST(LiteTest,AllLite2)194 TYPED_TEST(LiteTest, AllLite2) {
195 {
196 protobuf_unittest::TestAllExtensionsLite message, message2, message3;
197 TestUtilLite::ExpectExtensionsClear(message);
198 TestUtilLite::SetAllExtensions(&message);
199 message2 = message;
200 TypeParam extensions_data = SerializeAs<TypeParam>(message);
201 ParseFrom(extensions_data, message3);
202 TestUtilLite::ExpectAllExtensionsSet(message);
203 TestUtilLite::ExpectAllExtensionsSet(message2);
204 TestUtilLite::ExpectAllExtensionsSet(message3);
205 TestUtilLite::ModifyRepeatedExtensions(&message);
206 TestUtilLite::ExpectRepeatedExtensionsModified(message);
207 message.Clear();
208 TestUtilLite::ExpectExtensionsClear(message);
209 }
210 }
211
TYPED_TEST(LiteTest,AllLite3)212 TYPED_TEST(LiteTest, AllLite3) {
213 TypeParam data, packed_data;
214
215 {
216 protobuf_unittest::TestPackedTypesLite message, message2, message3;
217 TestUtilLite::ExpectPackedClear(message);
218 TestUtilLite::SetPackedFields(&message);
219 message2 = message;
220 packed_data = SerializeAs<TypeParam>(message);
221 ParseFrom(packed_data, message3);
222 TestUtilLite::ExpectPackedFieldsSet(message);
223 TestUtilLite::ExpectPackedFieldsSet(message2);
224 TestUtilLite::ExpectPackedFieldsSet(message3);
225 TestUtilLite::ModifyPackedFields(&message);
226 TestUtilLite::ExpectPackedFieldsModified(message);
227 message.Clear();
228 TestUtilLite::ExpectPackedClear(message);
229 }
230
231 {
232 protobuf_unittest::TestPackedExtensionsLite message, message2, message3;
233 TestUtilLite::ExpectPackedExtensionsClear(message);
234 TestUtilLite::SetPackedExtensions(&message);
235 message2 = message;
236 TypeParam packed_extensions_data = SerializeAs<TypeParam>(message);
237 EXPECT_EQ(packed_extensions_data, packed_data);
238 ParseFrom(packed_extensions_data, message3);
239 TestUtilLite::ExpectPackedExtensionsSet(message);
240 TestUtilLite::ExpectPackedExtensionsSet(message2);
241 TestUtilLite::ExpectPackedExtensionsSet(message3);
242 TestUtilLite::ModifyPackedExtensions(&message);
243 TestUtilLite::ExpectPackedExtensionsModified(message);
244 message.Clear();
245 TestUtilLite::ExpectPackedExtensionsClear(message);
246 }
247 }
248
TYPED_TEST(LiteTest,AllLite5)249 TYPED_TEST(LiteTest, AllLite5) {
250 TypeParam data;
251
252 {
253 // Test that if an optional or required message/group field appears multiple
254 // times in the input, they need to be merged.
255 unittest::TestParsingMergeLite::RepeatedFieldsGenerator generator;
256 unittest::TestAllTypesLite* msg1;
257 unittest::TestAllTypesLite* msg2;
258 unittest::TestAllTypesLite* msg3;
259
260 #define ASSIGN_REPEATED_FIELD(FIELD) \
261 msg1 = generator.add_##FIELD(); \
262 msg2 = generator.add_##FIELD(); \
263 msg3 = generator.add_##FIELD(); \
264 AssignParsingMergeMessages(msg1, msg2, msg3)
265
266 ASSIGN_REPEATED_FIELD(field1);
267 ASSIGN_REPEATED_FIELD(field2);
268 ASSIGN_REPEATED_FIELD(field3);
269 ASSIGN_REPEATED_FIELD(ext1);
270 ASSIGN_REPEATED_FIELD(ext2);
271
272 #undef ASSIGN_REPEATED_FIELD
273 #define ASSIGN_REPEATED_GROUP(FIELD) \
274 msg1 = generator.add_##FIELD()->mutable_field1(); \
275 msg2 = generator.add_##FIELD()->mutable_field1(); \
276 msg3 = generator.add_##FIELD()->mutable_field1(); \
277 AssignParsingMergeMessages(msg1, msg2, msg3)
278
279 ASSIGN_REPEATED_GROUP(group1);
280 ASSIGN_REPEATED_GROUP(group2);
281
282 #undef ASSIGN_REPEATED_GROUP
283
284 TypeParam buffer;
285 buffer = SerializeAs<TypeParam>(generator);
286 // generator.SerializeToString(&buffer);
287 unittest::TestParsingMergeLite parsing_merge;
288 ParseFrom(buffer, parsing_merge);
289
290 // Required and optional fields should be merged.
291 ExpectMessageMerged(parsing_merge.required_all_types());
292 ExpectMessageMerged(parsing_merge.optional_all_types());
293 ExpectMessageMerged(
294 parsing_merge.optionalgroup().optional_group_all_types());
295 ExpectMessageMerged(parsing_merge.GetExtension(
296 unittest::TestParsingMergeLite::optional_ext));
297
298 // Repeated fields should not be merged.
299 EXPECT_EQ(parsing_merge.repeated_all_types_size(), 3);
300 EXPECT_EQ(parsing_merge.repeatedgroup_size(), 3);
301 EXPECT_EQ(parsing_merge.ExtensionSize(
302 unittest::TestParsingMergeLite::repeated_ext),
303 3);
304 }
305 }
306
TYPED_TEST(LiteTest,AllLite6)307 TYPED_TEST(LiteTest, AllLite6) {
308 TypeParam data;
309
310 // Test unknown fields support for lite messages.
311 {
312 protobuf_unittest::TestAllTypesLite message, message2;
313 protobuf_unittest::TestEmptyMessageLite empty_message;
314 TestUtilLite::ExpectClear(message);
315 TestUtilLite::SetAllFields(&message);
316 data = SerializeAs<TypeParam>(message);
317 ASSERT_TRUE(ParseFrom(data, empty_message));
318 data = SerializeAs<TypeParam>(empty_message);
319 EXPECT_TRUE(ParseFrom(data, message2));
320 data = SerializeAs<TypeParam>(message2);
321 TestUtilLite::ExpectAllFieldsSet(message2);
322 message.Clear();
323 TestUtilLite::ExpectClear(message);
324 }
325 }
326
TYPED_TEST(LiteTest,AllLite7)327 TYPED_TEST(LiteTest, AllLite7) {
328 TypeParam data;
329
330 {
331 protobuf_unittest::TestAllExtensionsLite message, message2;
332 protobuf_unittest::TestEmptyMessageLite empty_message;
333 TestUtilLite::ExpectExtensionsClear(message);
334 TestUtilLite::SetAllExtensions(&message);
335 data = SerializeAs<TypeParam>(message);
336 ParseFrom(data, empty_message);
337 data = empty_message.SerializeAsString();
338 ParseFrom(data, message2);
339 data = SerializeAs<TypeParam>(message2);
340 TestUtilLite::ExpectAllExtensionsSet(message2);
341 message.Clear();
342 TestUtilLite::ExpectExtensionsClear(message);
343 }
344 }
345
TYPED_TEST(LiteTest,AllLite8)346 TYPED_TEST(LiteTest, AllLite8) {
347 TypeParam data;
348
349 {
350 protobuf_unittest::TestPackedTypesLite message, message2;
351 protobuf_unittest::TestEmptyMessageLite empty_message;
352 TestUtilLite::ExpectPackedClear(message);
353 TestUtilLite::SetPackedFields(&message);
354 data = SerializeAs<TypeParam>(message);
355 ParseFrom(data, empty_message);
356 data = SerializeAs<TypeParam>(empty_message);
357 ParseFrom(data, message2);
358 data = message2.SerializeAsString();
359 TestUtilLite::ExpectPackedFieldsSet(message2);
360 message.Clear();
361 TestUtilLite::ExpectPackedClear(message);
362 }
363 }
364
TYPED_TEST(LiteTest,AllLite9)365 TYPED_TEST(LiteTest, AllLite9) {
366 TypeParam data;
367
368 {
369 protobuf_unittest::TestPackedExtensionsLite message, message2;
370 protobuf_unittest::TestEmptyMessageLite empty_message;
371 TestUtilLite::ExpectPackedExtensionsClear(message);
372 TestUtilLite::SetPackedExtensions(&message);
373 data = SerializeAs<TypeParam>(message);
374 ParseFrom(data, empty_message);
375 data = SerializeAs<TypeParam>(empty_message);
376 ParseFrom(data, message2);
377 data = SerializeAs<TypeParam>(message2);
378 TestUtilLite::ExpectPackedExtensionsSet(message2);
379 message.Clear();
380 TestUtilLite::ExpectPackedExtensionsClear(message);
381 }
382 }
383
TYPED_TEST(LiteTest,AllLite10)384 TYPED_TEST(LiteTest, AllLite10) {
385 TypeParam data;
386
387 {
388 // Test Unknown fields swap
389 protobuf_unittest::TestEmptyMessageLite empty_message, empty_message2;
390 SetAllTypesInEmptyMessageUnknownFields<TypeParam>(&empty_message);
391 SetSomeTypesInEmptyMessageUnknownFields(&empty_message2);
392 data = SerializeAs<TypeParam>(empty_message);
393 auto data2 = SerializeAs<TypeParam>(empty_message2);
394 empty_message.Swap(&empty_message2);
395 EXPECT_EQ(data, SerializeAs<TypeParam>(empty_message2));
396 EXPECT_EQ(data2, SerializeAs<TypeParam>(empty_message));
397 }
398 }
399
TYPED_TEST(LiteTest,AllLite11)400 TYPED_TEST(LiteTest, AllLite11) {
401 TypeParam data;
402
403 {
404 // Test unknown fields swap with self
405 protobuf_unittest::TestEmptyMessageLite empty_message;
406 SetAllTypesInEmptyMessageUnknownFields<TypeParam>(&empty_message);
407 data = SerializeAs<TypeParam>(empty_message);
408 empty_message.Swap(&empty_message);
409 EXPECT_EQ(data, empty_message.SerializeAsString());
410 }
411 }
412
TYPED_TEST(LiteTest,AllLite12)413 TYPED_TEST(LiteTest, AllLite12) {
414 TypeParam data;
415
416 {
417 // Test MergeFrom with unknown fields
418 protobuf_unittest::TestAllTypesLite message, message2;
419 protobuf_unittest::TestEmptyMessageLite empty_message, empty_message2;
420 message.set_optional_int32(101);
421 message.add_repeated_int32(201);
422 message.set_optional_nested_enum(unittest::TestAllTypesLite::BAZ);
423 message2.set_optional_int64(102);
424 message2.add_repeated_int64(202);
425 message2.set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ);
426
427 data = SerializeAs<TypeParam>(message);
428 ParseFrom(data, empty_message);
429 data = message2.SerializeAsString();
430 ParseFrom(data, empty_message2);
431 message.MergeFrom(message2);
432 empty_message.MergeFrom(empty_message2);
433
434 data = SerializeAs<TypeParam>(empty_message);
435 ParseFrom(data, message2);
436 // We do not compare the serialized output of a normal message and a lite
437 // message because the order of fields do not match. We convert lite message
438 // back into normal message, then compare.
439 EXPECT_EQ(SerializeAs<TypeParam>(message),
440 SerializeAs<TypeParam>(message2));
441 }
442 }
443
TYPED_TEST(LiteTest,AllLite13StringStream)444 TYPED_TEST(LiteTest, AllLite13StringStream) {
445 TypeParam data;
446
447 {
448 // Test unknown enum value
449 protobuf_unittest::TestAllTypesLite message;
450 std::string buffer;
451 {
452 io::StringOutputStream output_stream(&buffer);
453 io::CodedOutputStream coded_output(&output_stream);
454 internal::WireFormatLite::WriteTag(
455 protobuf_unittest::TestAllTypesLite::kOptionalNestedEnumFieldNumber,
456 internal::WireFormatLite::WIRETYPE_VARINT, &coded_output);
457 coded_output.WriteVarint32(10);
458 internal::WireFormatLite::WriteTag(
459 protobuf_unittest::TestAllTypesLite::kRepeatedNestedEnumFieldNumber,
460 internal::WireFormatLite::WIRETYPE_VARINT, &coded_output);
461 coded_output.WriteVarint32(20);
462 }
463 message.ParseFromString(buffer);
464 data = SerializeAs<TypeParam>(message);
465 EXPECT_EQ(data, buffer);
466 }
467 }
468
TYPED_TEST(LiteTest,AllLite13CordStream)469 TYPED_TEST(LiteTest, AllLite13CordStream) {
470 TypeParam data;
471
472 {
473 // Test unknown enum value
474 protobuf_unittest::TestAllTypesLite message;
475 io::CordOutputStream output_stream;
476 {
477 io::CodedOutputStream coded_output(&output_stream);
478 internal::WireFormatLite::WriteTag(
479 protobuf_unittest::TestAllTypesLite::kOptionalNestedEnumFieldNumber,
480 internal::WireFormatLite::WIRETYPE_VARINT, &coded_output);
481 coded_output.WriteVarint32(10);
482 internal::WireFormatLite::WriteTag(
483 protobuf_unittest::TestAllTypesLite::kRepeatedNestedEnumFieldNumber,
484 internal::WireFormatLite::WIRETYPE_VARINT, &coded_output);
485 coded_output.WriteVarint32(20);
486 }
487 absl::Cord buffer = output_stream.Consume();
488 message.ParseFromCord(buffer);
489 data = SerializeAs<TypeParam>(message);
490 EXPECT_EQ(data, buffer);
491 }
492 }
493
TYPED_TEST(LiteTest,AllLite14)494 TYPED_TEST(LiteTest, AllLite14) {
495 {
496 // Test Clear with unknown fields
497 protobuf_unittest::TestEmptyMessageLite empty_message;
498 SetAllTypesInEmptyMessageUnknownFields<TypeParam>(&empty_message);
499 empty_message.Clear();
500 EXPECT_EQ(0, empty_message.unknown_fields().size());
501 }
502 }
503
504 // Tests for map lite =============================================
505
TEST(LiteBasicTest,AllLite15)506 TEST(LiteBasicTest, AllLite15) {
507 {
508 // Accessors
509 protobuf_unittest::TestMapLite message;
510
511 MapLiteTestUtil::SetMapFields(&message);
512 MapLiteTestUtil::ExpectMapFieldsSet(message);
513
514 MapLiteTestUtil::ModifyMapFields(&message);
515 MapLiteTestUtil::ExpectMapFieldsModified(message);
516 }
517 }
518
TYPED_TEST(LiteTest,AllLite16)519 TYPED_TEST(LiteTest, AllLite16) {
520 {
521 // SetMapFieldsInitialized
522 protobuf_unittest::TestMapLite message;
523
524 MapLiteTestUtil::SetMapFieldsInitialized(&message);
525 MapLiteTestUtil::ExpectMapFieldsSetInitialized(message);
526 }
527 }
528
TEST(LiteBasicTest,AllLite17)529 TEST(LiteBasicTest, AllLite17) {
530 {
531 // Clear
532 protobuf_unittest::TestMapLite message;
533
534 MapLiteTestUtil::SetMapFields(&message);
535 message.Clear();
536 MapLiteTestUtil::ExpectClear(message);
537 }
538 }
539
TEST(LiteBasicTest,AllLite18)540 TEST(LiteBasicTest, AllLite18) {
541 {
542 // ClearMessageMap
543 protobuf_unittest::TestMessageMapLite message;
544
545 // Creates a TestAllTypes with default value
546 TestUtilLite::ExpectClear((*message.mutable_map_int32_message())[0]);
547 }
548 }
549
TEST(LiteBasicTest,AllLite19)550 TEST(LiteBasicTest, AllLite19) {
551 {
552 // CopyFrom
553 protobuf_unittest::TestMapLite message1, message2;
554
555 MapLiteTestUtil::SetMapFields(&message1);
556 message2.CopyFrom(message1); // NOLINT
557 MapLiteTestUtil::ExpectMapFieldsSet(message2);
558
559 // Copying from self should be a no-op.
560 message2.CopyFrom(message2); // NOLINT
561 MapLiteTestUtil::ExpectMapFieldsSet(message2);
562 }
563 }
564
TEST(LiteBasicTest,AllLite20)565 TEST(LiteBasicTest, AllLite20) {
566 {
567 // CopyFromMessageMap
568 protobuf_unittest::TestMessageMapLite message1, message2;
569
570 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100);
571 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101);
572
573 message1.CopyFrom(message2); // NOLINT
574
575 // Checks repeated field is overwritten.
576 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size());
577 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0));
578 }
579 }
580
TEST(LiteBasicTest,AllLite21)581 TEST(LiteBasicTest, AllLite21) {
582 {
583 // SwapWithEmpty
584 protobuf_unittest::TestMapLite message1, message2;
585
586 MapLiteTestUtil::SetMapFields(&message1);
587 MapLiteTestUtil::ExpectMapFieldsSet(message1);
588 MapLiteTestUtil::ExpectClear(message2);
589
590 message1.Swap(&message2);
591 MapLiteTestUtil::ExpectMapFieldsSet(message2);
592 MapLiteTestUtil::ExpectClear(message1);
593 }
594 }
595
TEST(LiteBasicTest,AllLite22)596 TEST(LiteBasicTest, AllLite22) {
597 {
598 // SwapWithSelf
599 protobuf_unittest::TestMapLite message;
600
601 MapLiteTestUtil::SetMapFields(&message);
602 MapLiteTestUtil::ExpectMapFieldsSet(message);
603
604 message.Swap(&message);
605 MapLiteTestUtil::ExpectMapFieldsSet(message);
606 }
607 }
608
TEST(LiteBasicTest,AllLite23)609 TEST(LiteBasicTest, AllLite23) {
610 {
611 // SwapWithOther
612 protobuf_unittest::TestMapLite message1, message2;
613
614 MapLiteTestUtil::SetMapFields(&message1);
615 MapLiteTestUtil::SetMapFields(&message2);
616 MapLiteTestUtil::ModifyMapFields(&message2);
617
618 message1.Swap(&message2);
619 MapLiteTestUtil::ExpectMapFieldsModified(message1);
620 MapLiteTestUtil::ExpectMapFieldsSet(message2);
621 }
622 }
623
TEST(LiteBasicTest,AllLite24)624 TEST(LiteBasicTest, AllLite24) {
625 {
626 // CopyConstructor
627 protobuf_unittest::TestMapLite message1;
628 MapLiteTestUtil::SetMapFields(&message1);
629
630 protobuf_unittest::TestMapLite message2(message1);
631 MapLiteTestUtil::ExpectMapFieldsSet(message2);
632 }
633 }
634
TEST(LiteBasicTest,AllLite25)635 TEST(LiteBasicTest, AllLite25) {
636 {
637 // CopyAssignmentOperator
638 protobuf_unittest::TestMapLite message1;
639 MapLiteTestUtil::SetMapFields(&message1);
640
641 protobuf_unittest::TestMapLite message2;
642 message2 = message1;
643 MapLiteTestUtil::ExpectMapFieldsSet(message2);
644
645 // Make sure that self-assignment does something sane.
646 message2.operator=(message2);
647 MapLiteTestUtil::ExpectMapFieldsSet(message2);
648 }
649 }
650
TEST(LiteBasicTest,AllLite26)651 TEST(LiteBasicTest, AllLite26) {
652 {
653 // NonEmptyMergeFrom
654 protobuf_unittest::TestMapLite message1, message2;
655
656 MapLiteTestUtil::SetMapFields(&message1);
657
658 // This field will test merging into an empty spot.
659 (*message2.mutable_map_int32_int32())[1] = 1;
660 message1.mutable_map_int32_int32()->erase(1);
661
662 // This tests overwriting.
663 (*message2.mutable_map_int32_double())[1] = 1;
664 (*message1.mutable_map_int32_double())[1] = 2;
665
666 message1.MergeFrom(message2);
667 MapLiteTestUtil::ExpectMapFieldsSet(message1);
668 }
669 }
670
TYPED_TEST(LiteTest,AllLite27)671 TYPED_TEST(LiteTest, AllLite27) {
672 {
673 // MergeFromMessageMap
674 protobuf_unittest::TestMessageMapLite message1, message2;
675
676 (*message1.mutable_map_int32_message())[0].add_repeated_int32(100);
677 (*message2.mutable_map_int32_message())[0].add_repeated_int32(101);
678
679 message1.MergeFrom(message2);
680
681 // Checks repeated field is overwritten.
682 EXPECT_EQ(1, message1.map_int32_message().at(0).repeated_int32_size());
683 EXPECT_EQ(101, message1.map_int32_message().at(0).repeated_int32(0));
684 }
685 }
686
TEST(LiteStringTest,AllLite28)687 TEST(LiteStringTest, AllLite28) {
688 {
689 // Test the generated SerializeWithCachedSizesToArray()
690 protobuf_unittest::TestMapLite message1, message2;
691 std::string data;
692 MapLiteTestUtil::SetMapFields(&message1);
693 size_t size = message1.ByteSizeLong();
694 data.resize(size);
695 ::uint8_t* start = reinterpret_cast<::uint8_t*>(&data[0]);
696 ::uint8_t* end = message1.SerializeWithCachedSizesToArray(start);
697 EXPECT_EQ(size, end - start);
698 EXPECT_TRUE(message2.ParseFromString(data));
699 MapLiteTestUtil::ExpectMapFieldsSet(message2);
700 }
701 }
702
TEST(LiteStreamTest,AllLite29)703 TEST(LiteStreamTest, AllLite29) {
704 {
705 // Test the generated SerializeWithCachedSizes()
706 protobuf_unittest::TestMapLite message1, message2;
707 MapLiteTestUtil::SetMapFields(&message1);
708 size_t size = message1.ByteSizeLong();
709 std::string data;
710 data.resize(size);
711 {
712 // Allow the output stream to buffer only one byte at a time.
713 io::ArrayOutputStream array_stream(&data[0], size, 1);
714 io::CodedOutputStream output_stream(&array_stream);
715 message1.SerializeWithCachedSizes(&output_stream);
716 EXPECT_FALSE(output_stream.HadError());
717 EXPECT_EQ(size, output_stream.ByteCount());
718 }
719 EXPECT_TRUE(message2.ParseFromString(data));
720 MapLiteTestUtil::ExpectMapFieldsSet(message2);
721 }
722 }
723
724
TYPED_TEST(LiteTest,AllLite32)725 TYPED_TEST(LiteTest, AllLite32) {
726 {
727 // Proto2UnknownEnum
728 protobuf_unittest::TestEnumMapPlusExtraLite from;
729 (*from.mutable_known_map_field())[0] =
730 protobuf_unittest::E_PROTO2_MAP_ENUM_FOO_LITE;
731 (*from.mutable_unknown_map_field())[0] =
732 protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE;
733 TypeParam data;
734 data = SerializeAs<TypeParam>(from);
735
736 protobuf_unittest::TestEnumMapLite to;
737 EXPECT_TRUE(ParseFrom(data, to));
738 EXPECT_EQ(0, to.unknown_map_field().size());
739 EXPECT_FALSE(to.mutable_unknown_fields()->empty());
740 ASSERT_EQ(1, to.known_map_field().size());
741 EXPECT_EQ(protobuf_unittest::PROTO2_MAP_ENUM_FOO_LITE,
742 to.known_map_field().at(0));
743
744 from.Clear();
745 data = SerializeAs<TypeParam>(to);
746 EXPECT_TRUE(ParseFrom(data, from));
747 ASSERT_EQ(1, from.known_map_field().size());
748 EXPECT_EQ(protobuf_unittest::E_PROTO2_MAP_ENUM_FOO_LITE,
749 from.known_map_field().at(0));
750 ASSERT_EQ(1, from.unknown_map_field().size());
751 EXPECT_EQ(protobuf_unittest::E_PROTO2_MAP_ENUM_EXTRA_LITE,
752 from.unknown_map_field().at(0));
753 }
754 }
755
TYPED_TEST(LiteTest,AllLite33)756 TYPED_TEST(LiteTest, AllLite33) {
757 {
758 // StandardWireFormat
759 protobuf_unittest::TestMapLite message;
760 std::string data = "\x0A\x04\x08\x01\x10\x01";
761
762 EXPECT_TRUE(message.ParseFromString(data));
763 ASSERT_EQ(1, message.map_int32_int32().size());
764 EXPECT_EQ(1, message.map_int32_int32().at(1));
765 }
766 }
767
TYPED_TEST(LiteTest,AllLite34)768 TYPED_TEST(LiteTest, AllLite34) {
769 {
770 // UnorderedWireFormat
771 protobuf_unittest::TestMapLite message;
772
773 // put value before key in wire format
774 std::string data = "\x0A\x04\x10\x01\x08\x02";
775
776 EXPECT_TRUE(message.ParseFromString(data));
777 ASSERT_EQ(1, message.map_int32_int32().size());
778 ASSERT_NE(message.map_int32_int32().find(2),
779 message.map_int32_int32().end());
780 EXPECT_EQ(1, message.map_int32_int32().at(2));
781 }
782 }
783
TYPED_TEST(LiteTest,AllLite35)784 TYPED_TEST(LiteTest, AllLite35) {
785 std::string data;
786
787 {
788 // DuplicatedKeyWireFormat
789 protobuf_unittest::TestMapLite message;
790
791 // Two key fields in wire format
792 std::string data = "\x0A\x06\x08\x01\x08\x02\x10\x01";
793
794 EXPECT_TRUE(message.ParseFromString(data));
795 ASSERT_EQ(1, message.map_int32_int32().size());
796 EXPECT_EQ(1, message.map_int32_int32().at(2));
797 }
798 }
799
TYPED_TEST(LiteTest,AllLite36)800 TYPED_TEST(LiteTest, AllLite36) {
801 std::string data;
802
803 {
804 // DuplicatedValueWireFormat
805 protobuf_unittest::TestMapLite message;
806
807 // Two value fields in wire format
808 std::string data = "\x0A\x06\x08\x01\x10\x01\x10\x02";
809
810 EXPECT_TRUE(message.ParseFromString(data));
811 ASSERT_EQ(1, message.map_int32_int32().size());
812 EXPECT_EQ(2, message.map_int32_int32().at(1));
813 }
814 }
815
TYPED_TEST(LiteTest,AllLite37)816 TYPED_TEST(LiteTest, AllLite37) {
817 {
818 // MissedKeyWireFormat
819 protobuf_unittest::TestMapLite message;
820
821 // No key field in wire format
822 std::string data = "\x0A\x02\x10\x01";
823
824 EXPECT_TRUE(message.ParseFromString(data));
825 ASSERT_EQ(1, message.map_int32_int32().size());
826 ASSERT_NE(message.map_int32_int32().find(0),
827 message.map_int32_int32().end());
828 EXPECT_EQ(1, message.map_int32_int32().at(0));
829 }
830 }
831
TYPED_TEST(LiteTest,AllLite38)832 TYPED_TEST(LiteTest, AllLite38) {
833 std::string data;
834
835 {
836 // MissedValueWireFormat
837 protobuf_unittest::TestMapLite message;
838
839 // No value field in wire format
840 std::string data = "\x0A\x02\x08\x01";
841
842 EXPECT_TRUE(message.ParseFromString(data));
843 ASSERT_EQ(1, message.map_int32_int32().size());
844 ASSERT_NE(message.map_int32_int32().find(1),
845 message.map_int32_int32().end());
846 EXPECT_EQ(0, message.map_int32_int32().at(1));
847 }
848 }
849
TYPED_TEST(LiteTest,AllLite39)850 TYPED_TEST(LiteTest, AllLite39) {
851 {
852 // UnknownFieldWireFormat
853 protobuf_unittest::TestMapLite message;
854
855 // Unknown field in wire format
856 std::string data = "\x0A\x06\x08\x02\x10\x03\x18\x01";
857
858 EXPECT_TRUE(message.ParseFromString(data));
859 ASSERT_EQ(1, message.map_int32_int32().size());
860 EXPECT_EQ(3, message.map_int32_int32().at(2));
861 }
862 }
863
TYPED_TEST(LiteTest,AllLite40)864 TYPED_TEST(LiteTest, AllLite40) {
865 {
866 // CorruptedWireFormat
867 protobuf_unittest::TestMapLite message;
868
869 // corrupted data in wire format
870 std::string data = "\x0A\x06\x08\x02\x11\x03";
871
872 EXPECT_FALSE(message.ParseFromString(data));
873 }
874 }
875
TYPED_TEST(LiteTest,AllLite41)876 TYPED_TEST(LiteTest, AllLite41) {
877 {
878 // IsInitialized
879 protobuf_unittest::TestRequiredMessageMapLite map_message;
880
881 // Add an uninitialized message.
882 (*map_message.mutable_map_field())[0];
883 EXPECT_FALSE(map_message.IsInitialized());
884
885 // Initialize uninitialized message
886 (*map_message.mutable_map_field())[0].set_a(0);
887 (*map_message.mutable_map_field())[0].set_b(0);
888 (*map_message.mutable_map_field())[0].set_c(0);
889 EXPECT_TRUE(map_message.IsInitialized());
890 }
891 }
892
TYPED_TEST(LiteTest,AllLite42)893 TYPED_TEST(LiteTest, AllLite42) {
894 {
895 // Check that adding more values to enum does not corrupt message
896 // when passed through an old client.
897 protobuf_unittest::V2MessageLite v2_message;
898 v2_message.set_int_field(800);
899 // Set enum field to the value not understood by the old client.
900 v2_message.set_enum_field(protobuf_unittest::V2_SECOND);
901 std::string v2_bytes = v2_message.SerializeAsString();
902
903 protobuf_unittest::V1MessageLite v1_message;
904 v1_message.ParseFromString(v2_bytes);
905 EXPECT_TRUE(v1_message.IsInitialized());
906 EXPECT_EQ(v1_message.int_field(), v2_message.int_field());
907 // V1 client does not understand V2_SECOND value, so it discards it and
908 // uses default value instead.
909 EXPECT_EQ(v1_message.enum_field(), protobuf_unittest::V1_FIRST);
910
911 // However, when re-serialized, it should preserve enum value.
912 std::string v1_bytes = v1_message.SerializeAsString();
913
914 protobuf_unittest::V2MessageLite same_v2_message;
915 same_v2_message.ParseFromString(v1_bytes);
916
917 EXPECT_EQ(v2_message.int_field(), same_v2_message.int_field());
918 EXPECT_EQ(v2_message.enum_field(), same_v2_message.enum_field());
919 }
920 }
921
922 // Test that when parsing a oneof, we can successfully clear whatever already
923 // happened to be stored in the oneof.
TYPED_TEST(LiteTest,AllLite43)924 TYPED_TEST(LiteTest, AllLite43) {
925 protobuf_unittest::TestOneofParsingLite message1;
926
927 message1.set_oneof_int32(17);
928 std::string serialized;
929 EXPECT_TRUE(message1.SerializeToString(&serialized));
930
931 // Submessage
932 {
933 protobuf_unittest::TestOneofParsingLite message2;
934 message2.mutable_oneof_submessage();
935 io::CodedInputStream input_stream(
936 reinterpret_cast<const ::uint8_t*>(serialized.data()),
937 serialized.size());
938 EXPECT_TRUE(message2.MergeFromCodedStream(&input_stream));
939 EXPECT_EQ(17, message2.oneof_int32());
940 }
941
942 // String
943 {
944 protobuf_unittest::TestOneofParsingLite message2;
945 message2.set_oneof_string("string");
946 io::CodedInputStream input_stream(
947 reinterpret_cast<const ::uint8_t*>(serialized.data()),
948 serialized.size());
949 EXPECT_TRUE(message2.MergeFromCodedStream(&input_stream));
950 EXPECT_EQ(17, message2.oneof_int32());
951 }
952
953 // Bytes
954 {
955 protobuf_unittest::TestOneofParsingLite message2;
956 message2.set_oneof_bytes("bytes");
957 io::CodedInputStream input_stream(
958 reinterpret_cast<const ::uint8_t*>(serialized.data()),
959 serialized.size());
960 EXPECT_TRUE(message2.MergeFromCodedStream(&input_stream));
961 EXPECT_EQ(17, message2.oneof_int32());
962 }
963
964 // Bytes [ctype = CORD]
965 {
966 protobuf_unittest::TestOneofParsingLite message2;
967 message2.set_oneof_bytes_cord("bytes cord");
968 io::CodedInputStream input_stream(
969 reinterpret_cast<const ::uint8_t*>(serialized.data()),
970 serialized.size());
971 EXPECT_TRUE(message2.MergeFromCodedStream(&input_stream));
972 EXPECT_EQ(17, message2.oneof_int32());
973 }
974
975 }
976
977 // Verify that we can successfully parse fields of various types within oneof
978 // fields. We also verify that we can parse the same data twice into the same
979 // message.
TYPED_TEST(LiteTest,AllLite44)980 TYPED_TEST(LiteTest, AllLite44) {
981 // Int32
982 {
983 protobuf_unittest::TestOneofParsingLite original;
984 original.set_oneof_int32(17);
985 std::string serialized;
986 EXPECT_TRUE(original.SerializeToString(&serialized));
987 protobuf_unittest::TestOneofParsingLite parsed;
988 for (int i = 0; i < 2; ++i) {
989 io::CodedInputStream input_stream(
990 reinterpret_cast<const ::uint8_t*>(serialized.data()),
991 serialized.size());
992 EXPECT_TRUE(parsed.MergeFromCodedStream(&input_stream));
993 EXPECT_EQ(17, parsed.oneof_int32());
994 }
995 }
996
997 // Submessage
998 {
999 protobuf_unittest::TestOneofParsingLite original;
1000 original.mutable_oneof_submessage()->set_optional_int32(5);
1001 std::string serialized;
1002 EXPECT_TRUE(original.SerializeToString(&serialized));
1003 protobuf_unittest::TestOneofParsingLite parsed;
1004 for (int i = 0; i < 2; ++i) {
1005 io::CodedInputStream input_stream(
1006 reinterpret_cast<const ::uint8_t*>(serialized.data()),
1007 serialized.size());
1008 EXPECT_TRUE(parsed.MergeFromCodedStream(&input_stream));
1009 EXPECT_EQ(5, parsed.oneof_submessage().optional_int32());
1010 }
1011 }
1012
1013 // String
1014 {
1015 protobuf_unittest::TestOneofParsingLite original;
1016 original.set_oneof_string("string");
1017 std::string serialized;
1018 EXPECT_TRUE(original.SerializeToString(&serialized));
1019 protobuf_unittest::TestOneofParsingLite parsed;
1020 for (int i = 0; i < 2; ++i) {
1021 io::CodedInputStream input_stream(
1022 reinterpret_cast<const ::uint8_t*>(serialized.data()),
1023 serialized.size());
1024 EXPECT_TRUE(parsed.MergeFromCodedStream(&input_stream));
1025 EXPECT_EQ("string", parsed.oneof_string());
1026 }
1027 }
1028
1029 // Bytes
1030 {
1031 protobuf_unittest::TestOneofParsingLite original;
1032 original.set_oneof_bytes("bytes");
1033 std::string serialized;
1034 EXPECT_TRUE(original.SerializeToString(&serialized));
1035 protobuf_unittest::TestOneofParsingLite parsed;
1036 for (int i = 0; i < 2; ++i) {
1037 io::CodedInputStream input_stream(
1038 reinterpret_cast<const ::uint8_t*>(serialized.data()),
1039 serialized.size());
1040 EXPECT_TRUE(parsed.MergeFromCodedStream(&input_stream));
1041 EXPECT_EQ("bytes", parsed.oneof_bytes());
1042 }
1043 }
1044
1045 // Enum
1046 {
1047 protobuf_unittest::TestOneofParsingLite original;
1048 original.set_oneof_enum(protobuf_unittest::V2_SECOND);
1049 std::string serialized;
1050 EXPECT_TRUE(original.SerializeToString(&serialized));
1051 protobuf_unittest::TestOneofParsingLite parsed;
1052 for (int i = 0; i < 2; ++i) {
1053 io::CodedInputStream input_stream(
1054 reinterpret_cast<const ::uint8_t*>(serialized.data()),
1055 serialized.size());
1056 EXPECT_TRUE(parsed.MergeFromCodedStream(&input_stream));
1057 EXPECT_EQ(protobuf_unittest::V2_SECOND, parsed.oneof_enum());
1058 }
1059 }
1060
1061 // Bytes [ctype = CORD]
1062 {
1063 protobuf_unittest::TestOneofParsingLite original;
1064 original.set_oneof_bytes_cord("bytes cord");
1065 std::string serialized;
1066 EXPECT_TRUE(original.SerializeToString(&serialized));
1067 protobuf_unittest::TestOneofParsingLite parsed;
1068 EXPECT_TRUE(parsed.MergeFromString(serialized));
1069 EXPECT_EQ("bytes cord", std::string(parsed.oneof_bytes_cord()));
1070 EXPECT_TRUE(parsed.MergeFromString(serialized));
1071 }
1072
1073 std::cout << "PASS" << std::endl;
1074 }
1075
TYPED_TEST(LiteTest,AllLite45)1076 TYPED_TEST(LiteTest, AllLite45) {
1077 // Test unknown fields are not discarded upon parsing.
1078 std::string data = "\20\1"; // varint 1 with field number 2
1079
1080 protobuf_unittest::ForeignMessageLite a;
1081 EXPECT_TRUE(a.ParseFromString(data));
1082 io::CodedInputStream input_stream(
1083 reinterpret_cast<const ::uint8_t*>(data.data()), data.size());
1084 EXPECT_TRUE(a.MergePartialFromCodedStream(&input_stream));
1085
1086 std::string serialized = a.SerializeAsString();
1087 EXPECT_EQ(serialized.substr(0, 2), data);
1088 EXPECT_EQ(serialized.substr(2), data);
1089 }
1090
1091 // The following two tests check for wire compatibility between packed and
1092 // unpacked repeated fields. There used to be a bug in the generated parsing
1093 // code that caused us to calculate the highest possible tag number without
1094 // taking into account that a repeated field might not be in the packed (or
1095 // unpacked) state we expect. These tests specifically check for that issue by
1096 // making sure we can parse repeated fields when the tag is higher than we would
1097 // expect.
TYPED_TEST(LiteTest,AllLite46)1098 TYPED_TEST(LiteTest, AllLite46) {
1099 protobuf_unittest::PackedInt32 packed;
1100 packed.add_repeated_int32(42);
1101 std::string serialized;
1102 ASSERT_TRUE(packed.SerializeToString(&serialized));
1103
1104 protobuf_unittest::NonPackedInt32 non_packed;
1105 ASSERT_TRUE(non_packed.ParseFromString(serialized));
1106 ASSERT_EQ(1, non_packed.repeated_int32_size());
1107 EXPECT_EQ(42, non_packed.repeated_int32(0));
1108 }
1109
TYPED_TEST(LiteTest,AllLite47)1110 TYPED_TEST(LiteTest, AllLite47) {
1111 protobuf_unittest::NonPackedFixed32 non_packed;
1112 non_packed.add_repeated_fixed32(42);
1113 std::string serialized;
1114 ASSERT_TRUE(non_packed.SerializeToString(&serialized));
1115
1116 protobuf_unittest::PackedFixed32 packed;
1117 ASSERT_TRUE(packed.ParseFromString(serialized));
1118 ASSERT_EQ(1, packed.repeated_fixed32_size());
1119 EXPECT_EQ(42, packed.repeated_fixed32(0));
1120 }
1121
TYPED_TEST(LiteTest,MapCrash)1122 TYPED_TEST(LiteTest, MapCrash) {
1123 // See b/113635730
1124 Arena arena;
1125 auto msg = Arena::Create<protobuf_unittest::TestMapLite>(&arena);
1126 // Payload for the map<string, Enum> with a enum varint that's longer >
1127 // 10 bytes. This causes a parse fail and a subsequent delete. field 16
1128 // (map<int32, MapEnumLite>) tag = 128+2 = \202 \1
1129 // 13 long \15
1130 // int32 key = 1 (\10 \1)
1131 // MapEnumLite value = too long varint (parse error)
1132 EXPECT_FALSE(msg->ParseFromString(
1133 "\202\1\15\10\1\200\200\200\200\200\200\200\200\200\200\1"));
1134 }
1135
TYPED_TEST(LiteTest,CorrectEnding)1136 TYPED_TEST(LiteTest, CorrectEnding) {
1137 protobuf_unittest::TestAllTypesLite msg;
1138 {
1139 // All proto wireformat parsers should act the same on parsing data in as
1140 // much as it concerns the parsing, ie. not the interpretation of the data.
1141 // TestAllTypesLite is not a group inside another message. So in practice
1142 // will not encounter an end-group tag. However the parser should behave
1143 // like any wire format parser should.
1144 static const char kWireFormat[] = "\204\1";
1145 io::CodedInputStream cis(reinterpret_cast<const uint8_t*>(kWireFormat), 2);
1146 // The old CodedInputStream parser got an optimization (ReadTagNoLastTag)
1147 // for non-group messages (like TestAllTypesLite) which made it not accept
1148 // end-group. This is not a real big deal, but I think going forward its
1149 // good to have all parse loops behave 'exactly' the same.
1150 EXPECT_TRUE(msg.MergePartialFromCodedStream(&cis));
1151 EXPECT_FALSE(cis.ConsumedEntireMessage());
1152 EXPECT_TRUE(cis.LastTagWas(132));
1153 }
1154 {
1155 // This is an incomplete end-group tag. This should be a genuine parse
1156 // failure.
1157 static const char kWireFormat[] = "\214";
1158 io::CodedInputStream cis(reinterpret_cast<const uint8_t*>(kWireFormat), 1);
1159 // Unfortunately the old parser detects a parse error in ReadTag and returns
1160 // 0 (as it states 0 is an invalid tag). However 0 is not an invalid tag
1161 // as it can be used to terminate the stream, so this returns true.
1162 EXPECT_FALSE(msg.MergePartialFromCodedStream(&cis));
1163 }
1164 }
1165
TYPED_TEST(LiteTest,DebugString)1166 TYPED_TEST(LiteTest, DebugString) {
1167 protobuf_unittest::TestAllTypesLite message1, message2;
1168 EXPECT_TRUE(absl::StartsWith(message1.DebugString(), "MessageLite at 0x"));
1169 EXPECT_TRUE(absl::StartsWith(message2.DebugString(), "MessageLite at 0x"));
1170
1171 // DebugString() and ShortDebugString() are the same for now.
1172 EXPECT_EQ(message1.DebugString(), message1.ShortDebugString());
1173
1174 // Even identical lite protos should have different DebugString() output. Part
1175 // of the reason for including the memory address is so that we get some
1176 // non-determinism, which should make it easier for us to change the output
1177 // later without breaking any code.
1178 EXPECT_NE(message1.DebugString(), message2.DebugString());
1179 }
1180
1181
TYPED_TEST(LiteTest,EnumValueToName)1182 TYPED_TEST(LiteTest, EnumValueToName) {
1183 EXPECT_EQ("FOREIGN_LITE_FOO", protobuf_unittest::ForeignEnumLite_Name(
1184 protobuf_unittest::FOREIGN_LITE_FOO));
1185 EXPECT_EQ("FOREIGN_LITE_BAR", protobuf_unittest::ForeignEnumLite_Name(
1186 protobuf_unittest::FOREIGN_LITE_BAR));
1187 EXPECT_EQ("FOREIGN_LITE_BAZ", protobuf_unittest::ForeignEnumLite_Name(
1188 protobuf_unittest::FOREIGN_LITE_BAZ));
1189 EXPECT_EQ("", protobuf_unittest::ForeignEnumLite_Name(0));
1190 EXPECT_EQ("", protobuf_unittest::ForeignEnumLite_Name(999));
1191 }
1192
1193
TYPED_TEST(LiteTest,NestedEnumValueToName)1194 TYPED_TEST(LiteTest, NestedEnumValueToName) {
1195 EXPECT_EQ("FOO", protobuf_unittest::TestAllTypesLite::NestedEnum_Name(
1196 protobuf_unittest::TestAllTypesLite::FOO));
1197 EXPECT_EQ("BAR", protobuf_unittest::TestAllTypesLite::NestedEnum_Name(
1198 protobuf_unittest::TestAllTypesLite::BAR));
1199 EXPECT_EQ("BAZ", protobuf_unittest::TestAllTypesLite::NestedEnum_Name(
1200 protobuf_unittest::TestAllTypesLite::BAZ));
1201 EXPECT_EQ("", protobuf_unittest::TestAllTypesLite::NestedEnum_Name(0));
1202 EXPECT_EQ("", protobuf_unittest::TestAllTypesLite::NestedEnum_Name(999));
1203 }
1204
TYPED_TEST(LiteTest,EnumNameToValue)1205 TYPED_TEST(LiteTest, EnumNameToValue) {
1206 protobuf_unittest::ForeignEnumLite value;
1207
1208 ASSERT_TRUE(
1209 protobuf_unittest::ForeignEnumLite_Parse("FOREIGN_LITE_FOO", &value));
1210 EXPECT_EQ(protobuf_unittest::FOREIGN_LITE_FOO, value);
1211
1212 ASSERT_TRUE(
1213 protobuf_unittest::ForeignEnumLite_Parse("FOREIGN_LITE_BAR", &value));
1214 EXPECT_EQ(protobuf_unittest::FOREIGN_LITE_BAR, value);
1215
1216 ASSERT_TRUE(
1217 protobuf_unittest::ForeignEnumLite_Parse("FOREIGN_LITE_BAZ", &value));
1218 EXPECT_EQ(protobuf_unittest::FOREIGN_LITE_BAZ, value);
1219
1220 // Non-existent values
1221 EXPECT_FALSE(protobuf_unittest::ForeignEnumLite_Parse("E", &value));
1222 EXPECT_FALSE(
1223 protobuf_unittest::ForeignEnumLite_Parse("FOREIGN_LITE_C", &value));
1224 EXPECT_FALSE(protobuf_unittest::ForeignEnumLite_Parse("G", &value));
1225 }
1226
TYPED_TEST(LiteTest,NestedEnumNameToValue)1227 TYPED_TEST(LiteTest, NestedEnumNameToValue) {
1228 protobuf_unittest::TestAllTypesLite::NestedEnum value;
1229
1230 ASSERT_TRUE(
1231 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("FOO", &value));
1232 EXPECT_EQ(protobuf_unittest::TestAllTypesLite::FOO, value);
1233
1234 ASSERT_TRUE(
1235 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("BAR", &value));
1236 EXPECT_EQ(protobuf_unittest::TestAllTypesLite::BAR, value);
1237
1238 ASSERT_TRUE(
1239 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("BAZ", &value));
1240 EXPECT_EQ(protobuf_unittest::TestAllTypesLite::BAZ, value);
1241
1242 // Non-existent values
1243 EXPECT_FALSE(
1244 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("A", &value));
1245 EXPECT_FALSE(
1246 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("C", &value));
1247 EXPECT_FALSE(
1248 protobuf_unittest::TestAllTypesLite::NestedEnum_Parse("G", &value));
1249 }
1250
TYPED_TEST(LiteTest,AliasedEnum)1251 TYPED_TEST(LiteTest, AliasedEnum) {
1252 // Enums with allow_alias = true can have multiple entries with the same
1253 // value.
1254 EXPECT_EQ("FOO1", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(
1255 protobuf_unittest::DupEnum::FOO1));
1256 EXPECT_EQ("FOO1", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(
1257 protobuf_unittest::DupEnum::FOO2));
1258 EXPECT_EQ("BAR1", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(
1259 protobuf_unittest::DupEnum::BAR1));
1260 EXPECT_EQ("BAR1", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(
1261 protobuf_unittest::DupEnum::BAR2));
1262 EXPECT_EQ("BAZ", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(
1263 protobuf_unittest::DupEnum::BAZ));
1264 EXPECT_EQ("", protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Name(999));
1265
1266 protobuf_unittest::DupEnum::TestEnumWithDupValueLite value;
1267 ASSERT_TRUE(
1268 protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Parse("FOO1", &value));
1269 EXPECT_EQ(protobuf_unittest::DupEnum::FOO1, value);
1270
1271 value = static_cast<protobuf_unittest::DupEnum::TestEnumWithDupValueLite>(0);
1272 ASSERT_TRUE(
1273 protobuf_unittest::DupEnum::TestEnumWithDupValueLite_Parse("FOO2", &value));
1274 EXPECT_EQ(protobuf_unittest::DupEnum::FOO2, value);
1275 }
1276
1277
TEST(LiteBasicTest,CodedInputStreamRollback)1278 TEST(LiteBasicTest, CodedInputStreamRollback) {
1279 {
1280 protobuf_unittest::TestAllTypesLite m;
1281 m.set_optional_bytes(std::string(30, 'a'));
1282 std::string serialized = m.SerializeAsString();
1283 serialized += '\014';
1284 serialized += std::string(3, ' ');
1285 io::ArrayInputStream is(serialized.data(), serialized.size(),
1286 serialized.size() - 6);
1287 {
1288 io::CodedInputStream cis(&is);
1289 m.Clear();
1290 m.MergePartialFromCodedStream(&cis);
1291 EXPECT_TRUE(cis.LastTagWas(12));
1292 EXPECT_FALSE(cis.ConsumedEntireMessage());
1293 // Should leave is with 3 spaces;
1294 }
1295 const void* data;
1296 int size;
1297 ASSERT_TRUE(is.Next(&data, &size));
1298 ASSERT_EQ(size, 3);
1299 EXPECT_EQ(memcmp(data, " ", 3), 0);
1300 }
1301 {
1302 protobuf_unittest::TestPackedTypesLite m;
1303 constexpr int kCount = 30;
1304 for (int i = 0; i < kCount; i++) m.add_packed_fixed32(i);
1305 std::string serialized = m.SerializeAsString();
1306 serialized += '\014';
1307 serialized += std::string(3, ' ');
1308 // Buffer breaks in middle of a fixed32.
1309 io::ArrayInputStream is(serialized.data(), serialized.size(),
1310 serialized.size() - 7);
1311 {
1312 io::CodedInputStream cis(&is);
1313 m.Clear();
1314 m.MergePartialFromCodedStream(&cis);
1315 EXPECT_TRUE(cis.LastTagWas(12));
1316 EXPECT_FALSE(cis.ConsumedEntireMessage());
1317 // Should leave is with 3 spaces;
1318 }
1319 ASSERT_EQ(m.packed_fixed32_size(), kCount);
1320 for (int i = 0; i < kCount; i++) EXPECT_EQ(m.packed_fixed32(i), i);
1321 const void* data;
1322 int size;
1323 ASSERT_TRUE(is.Next(&data, &size));
1324 ASSERT_EQ(size, 3);
1325 EXPECT_EQ(memcmp(data, " ", 3), 0);
1326 }
1327 {
1328 protobuf_unittest::TestPackedTypesLite m;
1329 constexpr int kCount = 30;
1330 // Make sure we output 2 byte varints
1331 for (int i = 0; i < kCount; i++) m.add_packed_fixed32(128 + i);
1332 std::string serialized = m.SerializeAsString();
1333 serialized += '\014';
1334 serialized += std::string(3, ' ');
1335 // Buffer breaks in middle of a 2 byte varint.
1336 io::ArrayInputStream is(serialized.data(), serialized.size(),
1337 serialized.size() - 5);
1338 {
1339 io::CodedInputStream cis(&is);
1340 m.Clear();
1341 m.MergePartialFromCodedStream(&cis);
1342 EXPECT_TRUE(cis.LastTagWas(12));
1343 EXPECT_FALSE(cis.ConsumedEntireMessage());
1344 // Should leave is with 3 spaces;
1345 }
1346 ASSERT_EQ(m.packed_fixed32_size(), kCount);
1347 for (int i = 0; i < kCount; i++) EXPECT_EQ(m.packed_fixed32(i), i + 128);
1348 const void* data;
1349 int size;
1350 ASSERT_TRUE(is.Next(&data, &size));
1351 ASSERT_EQ(size, 3);
1352 EXPECT_EQ(memcmp(data, " ", 3), 0);
1353 }
1354 }
1355
1356 // Two arbitrary types
1357 using CastType1 = protobuf_unittest::TestAllTypesLite;
1358 using CastType2 = protobuf_unittest::TestPackedTypesLite;
1359
TEST(LiteTest,DynamicCastMessage)1360 TEST(LiteTest, DynamicCastMessage) {
1361 CastType1 test_type_1;
1362
1363 MessageLite* test_type_1_pointer = &test_type_1;
1364 EXPECT_EQ(&test_type_1, DynamicCastMessage<CastType1>(test_type_1_pointer));
1365 EXPECT_EQ(nullptr, DynamicCastMessage<CastType2>(test_type_1_pointer));
1366
1367 const MessageLite* test_type_1_pointer_const = &test_type_1;
1368 EXPECT_EQ(&test_type_1,
1369 DynamicCastMessage<const CastType1>(test_type_1_pointer_const));
1370 EXPECT_EQ(nullptr,
1371 DynamicCastMessage<const CastType2>(test_type_1_pointer_const));
1372
1373 MessageLite* test_type_1_pointer_nullptr = nullptr;
1374 EXPECT_EQ(nullptr,
1375 DynamicCastMessage<CastType1>(test_type_1_pointer_nullptr));
1376
1377 MessageLite& test_type_1_pointer_ref = test_type_1;
1378 EXPECT_EQ(&test_type_1,
1379 &DynamicCastMessage<CastType1>(test_type_1_pointer_ref));
1380
1381 const MessageLite& test_type_1_pointer_const_ref = test_type_1;
1382 EXPECT_EQ(&test_type_1,
1383 &DynamicCastMessage<CastType1>(test_type_1_pointer_const_ref));
1384 }
1385
1386 #if GTEST_HAS_DEATH_TEST
TEST(LiteTest,DynamicCastMessageInvalidReferenceType)1387 TEST(LiteTest, DynamicCastMessageInvalidReferenceType) {
1388 CastType1 test_type_1;
1389 const MessageLite& test_type_1_pointer_const_ref = test_type_1;
1390 ASSERT_DEATH(
1391 DynamicCastMessage<CastType2>(test_type_1_pointer_const_ref),
1392 absl::StrCat("Cannot downcast ", test_type_1.GetTypeName(), " to ",
1393 CastType2::default_instance().GetTypeName()));
1394 }
1395 #endif // GTEST_HAS_DEATH_TEST
1396
TEST(LiteTest,DownCastMessageValidType)1397 TEST(LiteTest, DownCastMessageValidType) {
1398 CastType1 test_type_1;
1399
1400 MessageLite* test_type_1_pointer = &test_type_1;
1401 EXPECT_EQ(&test_type_1, DownCastMessage<CastType1>(test_type_1_pointer));
1402
1403 const MessageLite* test_type_1_pointer_const = &test_type_1;
1404 EXPECT_EQ(&test_type_1,
1405 DownCastMessage<const CastType1>(test_type_1_pointer_const));
1406
1407 MessageLite* test_type_1_pointer_nullptr = nullptr;
1408 EXPECT_EQ(nullptr, DownCastMessage<CastType1>(test_type_1_pointer_nullptr));
1409
1410 MessageLite& test_type_1_pointer_ref = test_type_1;
1411 EXPECT_EQ(&test_type_1, &DownCastMessage<CastType1>(test_type_1_pointer_ref));
1412
1413 const MessageLite& test_type_1_pointer_const_ref = test_type_1;
1414 EXPECT_EQ(&test_type_1,
1415 &DownCastMessage<CastType1>(test_type_1_pointer_const_ref));
1416 }
1417
1418 #if GTEST_HAS_DEATH_TEST
TEST(LiteTest,DownCastMessageInvalidPointerType)1419 TEST(LiteTest, DownCastMessageInvalidPointerType) {
1420 CastType1 test_type_1;
1421
1422 MessageLite* test_type_1_pointer = &test_type_1;
1423
1424 ASSERT_DEBUG_DEATH(
1425 DownCastMessage<CastType2>(test_type_1_pointer),
1426 absl::StrCat("Cannot downcast ", test_type_1.GetTypeName(), " to ",
1427 CastType2::default_instance().GetTypeName()));
1428 }
1429
TEST(LiteTest,DownCastMessageInvalidReferenceType)1430 TEST(LiteTest, DownCastMessageInvalidReferenceType) {
1431 CastType1 test_type_1;
1432
1433 MessageLite& test_type_1_pointer = test_type_1;
1434
1435 ASSERT_DEBUG_DEATH(
1436 DownCastMessage<CastType2>(test_type_1_pointer),
1437 absl::StrCat("Cannot downcast ", test_type_1.GetTypeName(), " to ",
1438 CastType2::default_instance().GetTypeName()));
1439 }
1440 #endif // GTEST_HAS_DEATH_TEST
1441
1442 } // namespace
1443 } // namespace protobuf
1444 } // namespace google
1445
1446 #include "google/protobuf/port_undef.inc"
1447