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