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