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 // This test is testing a lot more than just the UnknownFieldSet class. It
36 // tests handling of unknown fields throughout the system.
37
38 #include <google/protobuf/unknown_field_set.h>
39
40 #include <unordered_set>
41
42 #include <google/protobuf/stubs/callback.h>
43 #include <google/protobuf/stubs/common.h>
44 #include <google/protobuf/stubs/logging.h>
45 #include <google/protobuf/test_util.h>
46 #include <google/protobuf/unittest.pb.h>
47 #include <google/protobuf/unittest_lite.pb.h>
48 #include <google/protobuf/io/coded_stream.h>
49 #include <google/protobuf/io/zero_copy_stream_impl.h>
50 #include <google/protobuf/descriptor.h>
51 #include <google/protobuf/stubs/mutex.h>
52 #include <google/protobuf/wire_format.h>
53 #include <google/protobuf/testing/googletest.h>
54 #include <gtest/gtest.h>
55 #include <google/protobuf/stubs/time.h>
56 #include <google/protobuf/stubs/stl_util.h>
57
58 namespace google {
59 namespace protobuf {
60
61 using internal::WireFormat;
62
63 class UnknownFieldSetTest : public testing::Test {
64 protected:
SetUp()65 virtual void SetUp() {
66 descriptor_ = unittest::TestAllTypes::descriptor();
67 TestUtil::SetAllFields(&all_fields_);
68 all_fields_.SerializeToString(&all_fields_data_);
69 ASSERT_TRUE(empty_message_.ParseFromString(all_fields_data_));
70 unknown_fields_ = empty_message_.mutable_unknown_fields();
71 }
72
GetField(const std::string & name)73 const UnknownField* GetField(const std::string& name) {
74 const FieldDescriptor* field = descriptor_->FindFieldByName(name);
75 if (field == NULL) return NULL;
76 for (int i = 0; i < unknown_fields_->field_count(); i++) {
77 if (unknown_fields_->field(i).number() == field->number()) {
78 return &unknown_fields_->field(i);
79 }
80 }
81 return NULL;
82 }
83
84 // Constructs a protocol buffer which contains fields with all the same
85 // numbers as all_fields_data_ except that each field is some other wire
86 // type.
GetBizarroData()87 std::string GetBizarroData() {
88 unittest::TestEmptyMessage bizarro_message;
89 UnknownFieldSet* bizarro_unknown_fields =
90 bizarro_message.mutable_unknown_fields();
91 for (int i = 0; i < unknown_fields_->field_count(); i++) {
92 const UnknownField& unknown_field = unknown_fields_->field(i);
93 if (unknown_field.type() == UnknownField::TYPE_VARINT) {
94 bizarro_unknown_fields->AddFixed32(unknown_field.number(), 1);
95 } else {
96 bizarro_unknown_fields->AddVarint(unknown_field.number(), 1);
97 }
98 }
99
100 std::string data;
101 EXPECT_TRUE(bizarro_message.SerializeToString(&data));
102 return data;
103 }
104
105 const Descriptor* descriptor_;
106 unittest::TestAllTypes all_fields_;
107 std::string all_fields_data_;
108
109 // An empty message that has been parsed from all_fields_data_. So, it has
110 // unknown fields of every type.
111 unittest::TestEmptyMessage empty_message_;
112 UnknownFieldSet* unknown_fields_;
113 };
114
115 namespace {
116
TEST_F(UnknownFieldSetTest,AllFieldsPresent)117 TEST_F(UnknownFieldSetTest, AllFieldsPresent) {
118 // Verifies the following:
119 // --all unknown tags belong to TestAllTypes.
120 // --all fields in TestAllTypes is present in UnknownFieldSet except unset
121 // oneof fields.
122 //
123 // Should handle repeated fields that may appear multiple times in
124 // UnknownFieldSet.
125
126 int non_oneof_count = 0;
127 for (int i = 0; i < descriptor_->field_count(); i++) {
128 if (!descriptor_->field(i)->containing_oneof()) {
129 non_oneof_count++;
130 }
131 }
132
133 std::unordered_set<uint32> unknown_tags;
134 for (int i = 0; i < unknown_fields_->field_count(); i++) {
135 unknown_tags.insert(unknown_fields_->field(i).number());
136 }
137
138 for (uint32 t : unknown_tags) {
139 EXPECT_NE(descriptor_->FindFieldByNumber(t), nullptr);
140 }
141
142 EXPECT_EQ(non_oneof_count + descriptor_->oneof_decl_count(),
143 unknown_tags.size());
144 }
145
TEST_F(UnknownFieldSetTest,Varint)146 TEST_F(UnknownFieldSetTest, Varint) {
147 const UnknownField* field = GetField("optional_int32");
148 ASSERT_TRUE(field != NULL);
149
150 ASSERT_EQ(UnknownField::TYPE_VARINT, field->type());
151 EXPECT_EQ(all_fields_.optional_int32(), field->varint());
152 }
153
TEST_F(UnknownFieldSetTest,Fixed32)154 TEST_F(UnknownFieldSetTest, Fixed32) {
155 const UnknownField* field = GetField("optional_fixed32");
156 ASSERT_TRUE(field != NULL);
157
158 ASSERT_EQ(UnknownField::TYPE_FIXED32, field->type());
159 EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32());
160 }
161
TEST_F(UnknownFieldSetTest,Fixed64)162 TEST_F(UnknownFieldSetTest, Fixed64) {
163 const UnknownField* field = GetField("optional_fixed64");
164 ASSERT_TRUE(field != NULL);
165
166 ASSERT_EQ(UnknownField::TYPE_FIXED64, field->type());
167 EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64());
168 }
169
TEST_F(UnknownFieldSetTest,LengthDelimited)170 TEST_F(UnknownFieldSetTest, LengthDelimited) {
171 const UnknownField* field = GetField("optional_string");
172 ASSERT_TRUE(field != NULL);
173
174 ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED, field->type());
175 EXPECT_EQ(all_fields_.optional_string(), field->length_delimited());
176 }
177
TEST_F(UnknownFieldSetTest,Group)178 TEST_F(UnknownFieldSetTest, Group) {
179 const UnknownField* field = GetField("optionalgroup");
180 ASSERT_TRUE(field != NULL);
181
182 ASSERT_EQ(UnknownField::TYPE_GROUP, field->type());
183 ASSERT_EQ(1, field->group().field_count());
184
185 const UnknownField& nested_field = field->group().field(0);
186 const FieldDescriptor* nested_field_descriptor =
187 unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
188 ASSERT_TRUE(nested_field_descriptor != NULL);
189
190 EXPECT_EQ(nested_field_descriptor->number(), nested_field.number());
191 ASSERT_EQ(UnknownField::TYPE_VARINT, nested_field.type());
192 EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint());
193 }
194
TEST_F(UnknownFieldSetTest,SerializeFastAndSlowAreEquivalent)195 TEST_F(UnknownFieldSetTest, SerializeFastAndSlowAreEquivalent) {
196 int size =
197 WireFormat::ComputeUnknownFieldsSize(empty_message_.unknown_fields());
198 std::string slow_buffer;
199 std::string fast_buffer;
200 slow_buffer.resize(size);
201 fast_buffer.resize(size);
202
203 uint8* target = reinterpret_cast<uint8*>(::google::protobuf::string_as_array(&fast_buffer));
204 uint8* result = WireFormat::SerializeUnknownFieldsToArray(
205 empty_message_.unknown_fields(), target);
206 EXPECT_EQ(size, result - target);
207
208 {
209 io::ArrayOutputStream raw_stream(::google::protobuf::string_as_array(&slow_buffer), size,
210 1);
211 io::CodedOutputStream output_stream(&raw_stream);
212 WireFormat::SerializeUnknownFields(empty_message_.unknown_fields(),
213 &output_stream);
214 ASSERT_FALSE(output_stream.HadError());
215 }
216 EXPECT_TRUE(fast_buffer == slow_buffer);
217 }
218
TEST_F(UnknownFieldSetTest,Serialize)219 TEST_F(UnknownFieldSetTest, Serialize) {
220 // Check that serializing the UnknownFieldSet produces the original data
221 // again.
222
223 std::string data;
224 empty_message_.SerializeToString(&data);
225
226 // Don't use EXPECT_EQ because we don't want to dump raw binary data to
227 // stdout.
228 EXPECT_TRUE(data == all_fields_data_);
229 }
230
TEST_F(UnknownFieldSetTest,ParseViaReflection)231 TEST_F(UnknownFieldSetTest, ParseViaReflection) {
232 // Make sure fields are properly parsed to the UnknownFieldSet when parsing
233 // via reflection.
234
235 unittest::TestEmptyMessage message;
236 io::ArrayInputStream raw_input(all_fields_data_.data(),
237 all_fields_data_.size());
238 io::CodedInputStream input(&raw_input);
239 ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &message));
240
241 EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
242 }
243
TEST_F(UnknownFieldSetTest,SerializeViaReflection)244 TEST_F(UnknownFieldSetTest, SerializeViaReflection) {
245 // Make sure fields are properly written from the UnknownFieldSet when
246 // serializing via reflection.
247
248 std::string data;
249
250 {
251 io::StringOutputStream raw_output(&data);
252 io::CodedOutputStream output(&raw_output);
253 size_t size = WireFormat::ByteSize(empty_message_);
254 WireFormat::SerializeWithCachedSizes(empty_message_, size, &output);
255 ASSERT_FALSE(output.HadError());
256 }
257
258 // Don't use EXPECT_EQ because we don't want to dump raw binary data to
259 // stdout.
260 EXPECT_TRUE(data == all_fields_data_);
261 }
262
TEST_F(UnknownFieldSetTest,CopyFrom)263 TEST_F(UnknownFieldSetTest, CopyFrom) {
264 unittest::TestEmptyMessage message;
265
266 message.CopyFrom(empty_message_);
267
268 EXPECT_EQ(empty_message_.DebugString(), message.DebugString());
269 }
270
TEST_F(UnknownFieldSetTest,Swap)271 TEST_F(UnknownFieldSetTest, Swap) {
272 unittest::TestEmptyMessage other_message;
273 ASSERT_TRUE(other_message.ParseFromString(GetBizarroData()));
274
275 EXPECT_GT(empty_message_.unknown_fields().field_count(), 0);
276 EXPECT_GT(other_message.unknown_fields().field_count(), 0);
277 const std::string debug_string = empty_message_.DebugString();
278 const std::string other_debug_string = other_message.DebugString();
279 EXPECT_NE(debug_string, other_debug_string);
280
281 empty_message_.Swap(&other_message);
282 EXPECT_EQ(debug_string, other_message.DebugString());
283 EXPECT_EQ(other_debug_string, empty_message_.DebugString());
284 }
285
TEST_F(UnknownFieldSetTest,SwapWithSelf)286 TEST_F(UnknownFieldSetTest, SwapWithSelf) {
287 const std::string debug_string = empty_message_.DebugString();
288 EXPECT_GT(empty_message_.unknown_fields().field_count(), 0);
289
290 empty_message_.Swap(&empty_message_);
291 EXPECT_GT(empty_message_.unknown_fields().field_count(), 0);
292 EXPECT_EQ(debug_string, empty_message_.DebugString());
293 }
294
TEST_F(UnknownFieldSetTest,MergeFrom)295 TEST_F(UnknownFieldSetTest, MergeFrom) {
296 unittest::TestEmptyMessage source, destination;
297
298 destination.mutable_unknown_fields()->AddVarint(1, 1);
299 destination.mutable_unknown_fields()->AddVarint(3, 2);
300 source.mutable_unknown_fields()->AddVarint(2, 3);
301 source.mutable_unknown_fields()->AddVarint(3, 4);
302
303 destination.MergeFrom(source);
304
305 EXPECT_EQ(
306 // Note: The ordering of fields here depends on the ordering of adds
307 // and merging, above.
308 "1: 1\n"
309 "3: 2\n"
310 "2: 3\n"
311 "3: 4\n",
312 destination.DebugString());
313 }
314
TEST_F(UnknownFieldSetTest,MergeFromMessage)315 TEST_F(UnknownFieldSetTest, MergeFromMessage) {
316 unittest::TestEmptyMessage source, destination;
317
318 destination.mutable_unknown_fields()->AddVarint(1, 1);
319 destination.mutable_unknown_fields()->AddVarint(3, 2);
320 source.mutable_unknown_fields()->AddVarint(2, 3);
321 source.mutable_unknown_fields()->AddVarint(3, 4);
322
323 destination.mutable_unknown_fields()->MergeFromMessage(source);
324
325 EXPECT_EQ(
326 // Note: The ordering of fields here depends on the ordering of adds
327 // and merging, above.
328 "1: 1\n"
329 "3: 2\n"
330 "2: 3\n"
331 "3: 4\n",
332 destination.DebugString());
333 }
334
TEST_F(UnknownFieldSetTest,MergeFromMessageLite)335 TEST_F(UnknownFieldSetTest, MergeFromMessageLite) {
336 unittest::TestAllTypesLite source;
337 unittest::TestEmptyMessageLite destination;
338
339 source.set_optional_fixed32(42);
340 destination.ParseFromString(source.SerializeAsString());
341
342 UnknownFieldSet unknown_field_set;
343 EXPECT_TRUE(unknown_field_set.MergeFromMessage(destination));
344 EXPECT_EQ(unknown_field_set.field_count(), 1);
345
346 const UnknownField& unknown_field = unknown_field_set.field(0);
347 EXPECT_EQ(unknown_field.number(), 7);
348 EXPECT_EQ(unknown_field.fixed32(), 42);
349 }
350
351
TEST_F(UnknownFieldSetTest,Clear)352 TEST_F(UnknownFieldSetTest, Clear) {
353 // Clear the set.
354 empty_message_.Clear();
355 EXPECT_EQ(0, unknown_fields_->field_count());
356 }
357
TEST_F(UnknownFieldSetTest,ClearAndFreeMemory)358 TEST_F(UnknownFieldSetTest, ClearAndFreeMemory) {
359 EXPECT_GT(unknown_fields_->field_count(), 0);
360 unknown_fields_->ClearAndFreeMemory();
361 EXPECT_EQ(0, unknown_fields_->field_count());
362 unknown_fields_->AddVarint(123456, 654321);
363 EXPECT_EQ(1, unknown_fields_->field_count());
364 }
365
TEST_F(UnknownFieldSetTest,ParseKnownAndUnknown)366 TEST_F(UnknownFieldSetTest, ParseKnownAndUnknown) {
367 // Test mixing known and unknown fields when parsing.
368
369 unittest::TestEmptyMessage source;
370 source.mutable_unknown_fields()->AddVarint(123456, 654321);
371 std::string data;
372 ASSERT_TRUE(source.SerializeToString(&data));
373
374 unittest::TestAllTypes destination;
375 ASSERT_TRUE(destination.ParseFromString(all_fields_data_ + data));
376
377 TestUtil::ExpectAllFieldsSet(destination);
378 ASSERT_EQ(1, destination.unknown_fields().field_count());
379 ASSERT_EQ(UnknownField::TYPE_VARINT,
380 destination.unknown_fields().field(0).type());
381 EXPECT_EQ(654321, destination.unknown_fields().field(0).varint());
382 }
383
TEST_F(UnknownFieldSetTest,WrongTypeTreatedAsUnknown)384 TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknown) {
385 // Test that fields of the wrong wire type are treated like unknown fields
386 // when parsing.
387
388 unittest::TestAllTypes all_types_message;
389 unittest::TestEmptyMessage empty_message;
390 std::string bizarro_data = GetBizarroData();
391 ASSERT_TRUE(all_types_message.ParseFromString(bizarro_data));
392 ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
393
394 // All fields should have been interpreted as unknown, so the debug strings
395 // should be the same.
396 EXPECT_EQ(empty_message.DebugString(), all_types_message.DebugString());
397 }
398
TEST_F(UnknownFieldSetTest,WrongTypeTreatedAsUnknownViaReflection)399 TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknownViaReflection) {
400 // Same as WrongTypeTreatedAsUnknown but via the reflection interface.
401
402 unittest::TestAllTypes all_types_message;
403 unittest::TestEmptyMessage empty_message;
404 std::string bizarro_data = GetBizarroData();
405 io::ArrayInputStream raw_input(bizarro_data.data(), bizarro_data.size());
406 io::CodedInputStream input(&raw_input);
407 ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &all_types_message));
408 ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
409
410 EXPECT_EQ(empty_message.DebugString(), all_types_message.DebugString());
411 }
412
TEST_F(UnknownFieldSetTest,UnknownExtensions)413 TEST_F(UnknownFieldSetTest, UnknownExtensions) {
414 // Make sure fields are properly parsed to the UnknownFieldSet even when
415 // they are declared as extension numbers.
416
417 unittest::TestEmptyMessageWithExtensions message;
418 ASSERT_TRUE(message.ParseFromString(all_fields_data_));
419
420 EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
421 }
422
TEST_F(UnknownFieldSetTest,UnknownExtensionsReflection)423 TEST_F(UnknownFieldSetTest, UnknownExtensionsReflection) {
424 // Same as UnknownExtensions except parsing via reflection.
425
426 unittest::TestEmptyMessageWithExtensions message;
427 io::ArrayInputStream raw_input(all_fields_data_.data(),
428 all_fields_data_.size());
429 io::CodedInputStream input(&raw_input);
430 ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &message));
431
432 EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
433 }
434
TEST_F(UnknownFieldSetTest,WrongExtensionTypeTreatedAsUnknown)435 TEST_F(UnknownFieldSetTest, WrongExtensionTypeTreatedAsUnknown) {
436 // Test that fields of the wrong wire type are treated like unknown fields
437 // when parsing extensions.
438
439 unittest::TestAllExtensions all_extensions_message;
440 unittest::TestEmptyMessage empty_message;
441 std::string bizarro_data = GetBizarroData();
442 ASSERT_TRUE(all_extensions_message.ParseFromString(bizarro_data));
443 ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
444
445 // All fields should have been interpreted as unknown, so the debug strings
446 // should be the same.
447 EXPECT_EQ(empty_message.DebugString(), all_extensions_message.DebugString());
448 }
449
TEST_F(UnknownFieldSetTest,UnknownEnumValue)450 TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
451 using unittest::TestAllExtensions;
452 using unittest::TestAllTypes;
453 using unittest::TestEmptyMessage;
454
455 const FieldDescriptor* singular_field =
456 TestAllTypes::descriptor()->FindFieldByName("optional_nested_enum");
457 const FieldDescriptor* repeated_field =
458 TestAllTypes::descriptor()->FindFieldByName("repeated_nested_enum");
459 ASSERT_TRUE(singular_field != NULL);
460 ASSERT_TRUE(repeated_field != NULL);
461
462 std::string data;
463
464 {
465 TestEmptyMessage empty_message;
466 UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
467 unknown_fields->AddVarint(singular_field->number(), TestAllTypes::BAR);
468 unknown_fields->AddVarint(singular_field->number(), 5); // not valid
469 unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::FOO);
470 unknown_fields->AddVarint(repeated_field->number(), 4); // not valid
471 unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::BAZ);
472 unknown_fields->AddVarint(repeated_field->number(), 6); // not valid
473 empty_message.SerializeToString(&data);
474 }
475
476 {
477 TestAllTypes message;
478 ASSERT_TRUE(message.ParseFromString(data));
479 EXPECT_EQ(TestAllTypes::BAR, message.optional_nested_enum());
480 ASSERT_EQ(2, message.repeated_nested_enum_size());
481 EXPECT_EQ(TestAllTypes::FOO, message.repeated_nested_enum(0));
482 EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(1));
483
484 const UnknownFieldSet& unknown_fields = message.unknown_fields();
485 ASSERT_EQ(3, unknown_fields.field_count());
486
487 EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
488 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
489 EXPECT_EQ(5, unknown_fields.field(0).varint());
490
491 EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
492 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
493 EXPECT_EQ(4, unknown_fields.field(1).varint());
494
495 EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
496 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
497 EXPECT_EQ(6, unknown_fields.field(2).varint());
498 }
499
500 {
501 using unittest::optional_nested_enum_extension;
502 using unittest::repeated_nested_enum_extension;
503
504 TestAllExtensions message;
505 ASSERT_TRUE(message.ParseFromString(data));
506 EXPECT_EQ(TestAllTypes::BAR,
507 message.GetExtension(optional_nested_enum_extension));
508 ASSERT_EQ(2, message.ExtensionSize(repeated_nested_enum_extension));
509 EXPECT_EQ(TestAllTypes::FOO,
510 message.GetExtension(repeated_nested_enum_extension, 0));
511 EXPECT_EQ(TestAllTypes::BAZ,
512 message.GetExtension(repeated_nested_enum_extension, 1));
513
514 const UnknownFieldSet& unknown_fields = message.unknown_fields();
515 ASSERT_EQ(3, unknown_fields.field_count());
516
517 EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
518 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
519 EXPECT_EQ(5, unknown_fields.field(0).varint());
520
521 EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
522 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
523 EXPECT_EQ(4, unknown_fields.field(1).varint());
524
525 EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
526 ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
527 EXPECT_EQ(6, unknown_fields.field(2).varint());
528 }
529 }
530
TEST_F(UnknownFieldSetTest,SpaceUsedExcludingSelf)531 TEST_F(UnknownFieldSetTest, SpaceUsedExcludingSelf) {
532 UnknownFieldSet empty;
533 empty.AddVarint(1, 0);
534 EXPECT_EQ(sizeof(std::vector<UnknownField>) + sizeof(UnknownField),
535 empty.SpaceUsedExcludingSelf());
536 }
537
TEST_F(UnknownFieldSetTest,SpaceUsed)538 TEST_F(UnknownFieldSetTest, SpaceUsed) {
539 unittest::TestEmptyMessage empty_message;
540
541 // Make sure an unknown field set has zero space used until a field is
542 // actually added.
543 size_t base_size = empty_message.SpaceUsedLong();
544 UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
545 EXPECT_EQ(base_size, empty_message.SpaceUsedLong());
546
547 // Make sure each thing we add to the set increases the SpaceUsedLong().
548 unknown_fields->AddVarint(1, 0);
549 EXPECT_LT(base_size, empty_message.SpaceUsedLong());
550 base_size = empty_message.SpaceUsedLong();
551
552 std::string* str = unknown_fields->AddLengthDelimited(1);
553 EXPECT_LT(base_size, empty_message.SpaceUsedLong());
554 base_size = empty_message.SpaceUsedLong();
555
556 str->assign(sizeof(std::string) + 1, 'x');
557 EXPECT_LT(base_size, empty_message.SpaceUsedLong());
558 base_size = empty_message.SpaceUsedLong();
559
560 UnknownFieldSet* group = unknown_fields->AddGroup(1);
561 EXPECT_LT(base_size, empty_message.SpaceUsedLong());
562 base_size = empty_message.SpaceUsedLong();
563
564 group->AddVarint(1, 0);
565 EXPECT_LT(base_size, empty_message.SpaceUsedLong());
566 }
567
568
TEST_F(UnknownFieldSetTest,Empty)569 TEST_F(UnknownFieldSetTest, Empty) {
570 UnknownFieldSet unknown_fields;
571 EXPECT_TRUE(unknown_fields.empty());
572 unknown_fields.AddVarint(6, 123);
573 EXPECT_FALSE(unknown_fields.empty());
574 unknown_fields.Clear();
575 EXPECT_TRUE(unknown_fields.empty());
576 }
577
TEST_F(UnknownFieldSetTest,DeleteSubrange)578 TEST_F(UnknownFieldSetTest, DeleteSubrange) {
579 // Exhaustively test the deletion of every possible subrange in arrays of all
580 // sizes from 0 through 9.
581 for (int size = 0; size < 10; ++size) {
582 for (int num = 0; num <= size; ++num) {
583 for (int start = 0; start < size - num; ++start) {
584 // Create a set with "size" fields.
585 UnknownFieldSet unknown;
586 for (int i = 0; i < size; ++i) {
587 unknown.AddFixed32(i, i);
588 }
589 // Delete the specified subrange.
590 unknown.DeleteSubrange(start, num);
591 // Make sure the resulting field values are still correct.
592 EXPECT_EQ(size - num, unknown.field_count());
593 for (int i = 0; i < unknown.field_count(); ++i) {
594 if (i < start) {
595 EXPECT_EQ(i, unknown.field(i).fixed32());
596 } else {
597 EXPECT_EQ(i + num, unknown.field(i).fixed32());
598 }
599 }
600 }
601 }
602 }
603 }
604
CheckDeleteByNumber(const std::vector<int> & field_numbers,int deleted_number,const std::vector<int> & expected_field_nubmers)605 void CheckDeleteByNumber(const std::vector<int>& field_numbers,
606 int deleted_number,
607 const std::vector<int>& expected_field_nubmers) {
608 UnknownFieldSet unknown_fields;
609 for (int i = 0; i < field_numbers.size(); ++i) {
610 unknown_fields.AddFixed32(field_numbers[i], i);
611 }
612 unknown_fields.DeleteByNumber(deleted_number);
613 ASSERT_EQ(expected_field_nubmers.size(), unknown_fields.field_count());
614 for (int i = 0; i < expected_field_nubmers.size(); ++i) {
615 EXPECT_EQ(expected_field_nubmers[i], unknown_fields.field(i).number());
616 }
617 }
618
619 #define MAKE_VECTOR(x) std::vector<int>(x, x + GOOGLE_ARRAYSIZE(x))
TEST_F(UnknownFieldSetTest,DeleteByNumber)620 TEST_F(UnknownFieldSetTest, DeleteByNumber) {
621 CheckDeleteByNumber(std::vector<int>(), 1, std::vector<int>());
622 static const int kTestFieldNumbers1[] = {1, 2, 3};
623 static const int kFieldNumberToDelete1 = 1;
624 static const int kExpectedFieldNumbers1[] = {2, 3};
625 CheckDeleteByNumber(MAKE_VECTOR(kTestFieldNumbers1), kFieldNumberToDelete1,
626 MAKE_VECTOR(kExpectedFieldNumbers1));
627 static const int kTestFieldNumbers2[] = {1, 2, 3};
628 static const int kFieldNumberToDelete2 = 2;
629 static const int kExpectedFieldNumbers2[] = {1, 3};
630 CheckDeleteByNumber(MAKE_VECTOR(kTestFieldNumbers2), kFieldNumberToDelete2,
631 MAKE_VECTOR(kExpectedFieldNumbers2));
632 static const int kTestFieldNumbers3[] = {1, 2, 3};
633 static const int kFieldNumberToDelete3 = 3;
634 static const int kExpectedFieldNumbers3[] = {1, 2};
635 CheckDeleteByNumber(MAKE_VECTOR(kTestFieldNumbers3), kFieldNumberToDelete3,
636 MAKE_VECTOR(kExpectedFieldNumbers3));
637 static const int kTestFieldNumbers4[] = {1, 2, 1, 4, 1};
638 static const int kFieldNumberToDelete4 = 1;
639 static const int kExpectedFieldNumbers4[] = {2, 4};
640 CheckDeleteByNumber(MAKE_VECTOR(kTestFieldNumbers4), kFieldNumberToDelete4,
641 MAKE_VECTOR(kExpectedFieldNumbers4));
642 static const int kTestFieldNumbers5[] = {1, 2, 3, 4, 5};
643 static const int kFieldNumberToDelete5 = 6;
644 static const int kExpectedFieldNumbers5[] = {1, 2, 3, 4, 5};
645 CheckDeleteByNumber(MAKE_VECTOR(kTestFieldNumbers5), kFieldNumberToDelete5,
646 MAKE_VECTOR(kExpectedFieldNumbers5));
647 }
648 #undef MAKE_VECTOR
649 } // namespace
650
651 } // namespace protobuf
652 } // namespace google
653