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