src/google/protobuf/unknown_field_set_unittest.cc

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.
   3 // http://code.google.com/p/protobuf/
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 // Author: kenton@google.com (Kenton Varda)
  18 //  Based on original Protocol Buffers design by
  19 //  Sanjay Ghemawat, Jeff Dean, and others.
  20 //
  21 // This test is testing a lot more than just the UnknownFieldSet class.  It
  22 // tests handling of unknown fields throughout the system.
  23
  24 #include <google/protobuf/unknown_field_set.h>
  25 #include <google/protobuf/descriptor.h>
  26 #include <google/protobuf/io/zero_copy_stream_impl.h>
  27 #include <google/protobuf/io/coded_stream.h>
  28 #include <google/protobuf/wire_format.h>
  29 #include <google/protobuf/unittest.pb.h>
  30 #include <google/protobuf/test_util.h>
  31
  32 #include <google/protobuf/stubs/common.h>
  33 #include <google/protobuf/testing/googletest.h>
  34 #include <gtest/gtest.h>
  35
  36 namespace google {
  37 namespace protobuf {
  38
  39 using internal::WireFormat;
  40
  41 namespace {
  42
  43 class UnknownFieldSetTest : public testing::Test {
  44  protected:
  45   virtual void SetUp() {
  46     descriptor_ = unittest::TestAllTypes::descriptor();
  47     TestUtil::SetAllFields(&all_fields_);
  48     all_fields_.SerializeToString(&all_fields_data_);
  49     ASSERT_TRUE(empty_message_.ParseFromString(all_fields_data_));
  50     unknown_fields_ = empty_message_.mutable_unknown_fields();
  51   }
  52
  53   const UnknownField* GetField(const string& name) {
  54     const FieldDescriptor* field = descriptor_->FindFieldByName(name);
  55     if (field == NULL) return NULL;
  56     return unknown_fields_->FindFieldByNumber(field->number());
  57   }
  58
  59   // Constructs a protocol buffer which contains fields with all the same
  60   // numbers as all_fields_data_ except that each field is some other wire
  61   // type.
  62   string GetBizarroData() {
  63     unittest::TestEmptyMessage bizarro_message;
  64     UnknownFieldSet* bizarro_unknown_fields =
  65       bizarro_message.mutable_unknown_fields();
  66     for (int i = 0; i < unknown_fields_->field_count(); i++) {
  67       const UnknownField& unknown_field = unknown_fields_->field(i);
  68       UnknownField* bizarro_field =
  69         bizarro_unknown_fields->AddField(unknown_field.number());
  70       if (unknown_field.varint_size() == 0) {
  71         bizarro_field->add_varint(1);
  72       } else {
  73         bizarro_field->add_fixed32(1);
  74       }
  75     }
  76
  77     string data;
  78     EXPECT_TRUE(bizarro_message.SerializeToString(&data));
  79     return data;
  80   }
  81
  82   const Descriptor* descriptor_;
  83   unittest::TestAllTypes all_fields_;
  84   string all_fields_data_;
  85
  86   // An empty message that has been parsed from all_fields_data_.  So, it has
  87   // unknown fields of every type.
  88   unittest::TestEmptyMessage empty_message_;
  89   UnknownFieldSet* unknown_fields_;
  90 };
  91
  92 TEST_F(UnknownFieldSetTest, Index) {
  93   for (int i = 0; i < unknown_fields_->field_count(); i++) {
  94     EXPECT_EQ(i, unknown_fields_->field(i).index());
  95   }
  96 }
  97
  98 TEST_F(UnknownFieldSetTest, FindFieldByNumber) {
  99   // All fields of TestAllTypes should be present.  Fields that are not valid
 100   // field numbers of TestAllTypes should NOT be present.
 101
 102   for (int i = 0; i < 1000; i++) {
 103     if (descriptor_->FindFieldByNumber(i) == NULL) {
 104       EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) == NULL);
 105     } else {
 106       EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) != NULL);
 107     }
 108   }
 109 }
 110
 111 TEST_F(UnknownFieldSetTest, Varint) {
 112   const UnknownField* field = GetField("optional_int32");
 113   ASSERT_TRUE(field != NULL);
 114
 115   ASSERT_EQ(1, field->varint_size());
 116   EXPECT_EQ(all_fields_.optional_int32(), field->varint(0));
 117 }
 118
 119 TEST_F(UnknownFieldSetTest, Fixed32) {
 120   const UnknownField* field = GetField("optional_fixed32");
 121   ASSERT_TRUE(field != NULL);
 122
 123   ASSERT_EQ(1, field->fixed32_size());
 124   EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32(0));
 125 }
 126
 127 TEST_F(UnknownFieldSetTest, Fixed64) {
 128   const UnknownField* field = GetField("optional_fixed64");
 129   ASSERT_TRUE(field != NULL);
 130
 131   ASSERT_EQ(1, field->fixed64_size());
 132   EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64(0));
 133 }
 134
 135 TEST_F(UnknownFieldSetTest, LengthDelimited) {
 136   const UnknownField* field = GetField("optional_string");
 137   ASSERT_TRUE(field != NULL);
 138
 139   ASSERT_EQ(1, field->length_delimited_size());
 140   EXPECT_EQ(all_fields_.optional_string(), field->length_delimited(0));
 141 }
 142
 143 TEST_F(UnknownFieldSetTest, Group) {
 144   const UnknownField* field = GetField("optionalgroup");
 145   ASSERT_TRUE(field != NULL);
 146
 147   ASSERT_EQ(1, field->group_size());
 148   EXPECT_EQ(1, field->group(0).field_count());
 149
 150   const UnknownField& nested_field = field->group(0).field(0);
 151   const FieldDescriptor* nested_field_descriptor =
 152     unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
 153   ASSERT_TRUE(nested_field_descriptor != NULL);
 154
 155   EXPECT_EQ(nested_field_descriptor->number(), nested_field.number());
 156   EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint(0));
 157 }
 158
 159 TEST_F(UnknownFieldSetTest, Serialize) {
 160   // Check that serializing the UnknownFieldSet produces the original data
 161   // again.
 162
 163   string data;
 164   empty_message_.SerializeToString(&data);
 165
 166   // Don't use EXPECT_EQ because we don't want to dump raw binary data to
 167   // stdout.
 168   EXPECT_TRUE(data == all_fields_data_);
 169 }
 170
 171 TEST_F(UnknownFieldSetTest, ParseViaReflection) {
 172   // Make sure fields are properly parsed to the UnknownFieldSet when parsing
 173   // via reflection.
 174
 175   unittest::TestEmptyMessage message;
 176   io::ArrayInputStream raw_input(all_fields_data_.data(),
 177                                  all_fields_data_.size());
 178   io::CodedInputStream input(&raw_input);
 179   ASSERT_TRUE(WireFormat::ParseAndMergePartial(message.GetDescriptor(), &input,
 180                                                message.GetReflection()));
 181
 182   EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
 183 }
 184
 185 TEST_F(UnknownFieldSetTest, SerializeViaReflection) {
 186   // Make sure fields are properly written from the UnknownFieldSet when
 187   // serializing via reflection.
 188
 189   string data;
 190
 191   {
 192     io::StringOutputStream raw_output(&data);
 193     io::CodedOutputStream output(&raw_output);
 194     int size = WireFormat::ByteSize(empty_message_.GetDescriptor(),
 195                                     empty_message_.GetReflection());
 196     ASSERT_TRUE(
 197       WireFormat::SerializeWithCachedSizes(empty_message_.GetDescriptor(),
 198                                            empty_message_.GetReflection(),
 199                                            size, &output));
 200   }
 201
 202   // Don't use EXPECT_EQ because we don't want to dump raw binary data to
 203   // stdout.
 204   EXPECT_TRUE(data == all_fields_data_);
 205 }
 206
 207 TEST_F(UnknownFieldSetTest, CopyFrom) {
 208   unittest::TestEmptyMessage message;
 209
 210   message.CopyFrom(empty_message_);
 211
 212   EXPECT_EQ(empty_message_.DebugString(), message.DebugString());
 213 }
 214
 215 TEST_F(UnknownFieldSetTest, MergeFrom) {
 216   unittest::TestEmptyMessage source, destination;
 217
 218   destination.mutable_unknown_fields()->AddField(1)->add_varint(1);
 219   destination.mutable_unknown_fields()->AddField(3)->add_varint(2);
 220   source.mutable_unknown_fields()->AddField(2)->add_varint(3);
 221   source.mutable_unknown_fields()->AddField(3)->add_varint(4);
 222
 223   destination.MergeFrom(source);
 224
 225   EXPECT_EQ(
 226     // Note:  The ordering of fields here depends on the ordering of adds
 227     //   and merging, above.
 228     "1: 1\n"
 229     "3: 2\n"
 230     "3: 4\n"
 231     "2: 3\n",
 232     destination.DebugString());
 233 }
 234
 235 TEST_F(UnknownFieldSetTest, Clear) {
 236   // Get a pointer to a contained field object.
 237   const UnknownField* field = GetField("optional_int32");
 238   ASSERT_TRUE(field != NULL);
 239   ASSERT_EQ(1, field->varint_size());
 240   int number = field->number();
 241
 242   // Clear the set.
 243   empty_message_.Clear();
 244   EXPECT_EQ(0, unknown_fields_->field_count());
 245
 246   // If we add that field again we should get the same object.
 247   ASSERT_EQ(field, unknown_fields_->AddField(number));
 248
 249   // But it should be cleared.
 250   EXPECT_EQ(0, field->varint_size());
 251 }
 252
 253 TEST_F(UnknownFieldSetTest, ParseKnownAndUnknown) {
 254   // Test mixing known and unknown fields when parsing.
 255
 256   unittest::TestEmptyMessage source;
 257   source.mutable_unknown_fields()->AddField(123456)->add_varint(654321);
 258   string data;
 259   ASSERT_TRUE(source.SerializeToString(&data));
 260
 261   unittest::TestAllTypes destination;
 262   ASSERT_TRUE(destination.ParseFromString(all_fields_data_ + data));
 263
 264   TestUtil::ExpectAllFieldsSet(destination);
 265   ASSERT_EQ(1, destination.unknown_fields().field_count());
 266   ASSERT_EQ(1, destination.unknown_fields().field(0).varint_size());
 267   EXPECT_EQ(654321, destination.unknown_fields().field(0).varint(0));
 268 }
 269
 270 TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknown) {
 271   // Test that fields of the wrong wire type are treated like unknown fields
 272   // when parsing.
 273
 274   unittest::TestAllTypes all_types_message;
 275   unittest::TestEmptyMessage empty_message;
 276   string bizarro_data = GetBizarroData();
 277   ASSERT_TRUE(all_types_message.ParseFromString(bizarro_data));
 278   ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
 279
 280   // All fields should have been interpreted as unknown, so the debug strings
 281   // should be the same.
 282   EXPECT_EQ(empty_message.DebugString(), all_types_message.DebugString());
 283 }
 284
 285 TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknownViaReflection) {
 286   // Same as WrongTypeTreatedAsUnknown but via the reflection interface.
 287
 288   unittest::TestAllTypes all_types_message;
 289   unittest::TestEmptyMessage empty_message;
 290   string bizarro_data = GetBizarroData();
 291   io::ArrayInputStream raw_input(bizarro_data.data(), bizarro_data.size());
 292   io::CodedInputStream input(&raw_input);
 293   ASSERT_TRUE(WireFormat::ParseAndMergePartial(
 294     all_types_message.GetDescriptor(), &input,
 295     all_types_message.GetReflection()));
 296   ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
 297
 298   EXPECT_EQ(empty_message.DebugString(), all_types_message.DebugString());
 299 }
 300
 301 TEST_F(UnknownFieldSetTest, UnknownExtensions) {
 302   // Make sure fields are properly parsed to the UnknownFieldSet even when
 303   // they are declared as extension numbers.
 304
 305   unittest::TestEmptyMessageWithExtensions message;
 306   ASSERT_TRUE(message.ParseFromString(all_fields_data_));
 307
 308   EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
 309 }
 310
 311 TEST_F(UnknownFieldSetTest, UnknownExtensionsReflection) {
 312   // Same as UnknownExtensions except parsing via reflection.
 313
 314   unittest::TestEmptyMessageWithExtensions message;
 315   io::ArrayInputStream raw_input(all_fields_data_.data(),
 316                                  all_fields_data_.size());
 317   io::CodedInputStream input(&raw_input);
 318   ASSERT_TRUE(WireFormat::ParseAndMergePartial(message.GetDescriptor(), &input,
 319                                                message.GetReflection()));
 320
 321   EXPECT_EQ(message.DebugString(), empty_message_.DebugString());
 322 }
 323
 324 TEST_F(UnknownFieldSetTest, WrongExtensionTypeTreatedAsUnknown) {
 325   // Test that fields of the wrong wire type are treated like unknown fields
 326   // when parsing extensions.
 327
 328   unittest::TestAllExtensions all_extensions_message;
 329   unittest::TestEmptyMessage empty_message;
 330   string bizarro_data = GetBizarroData();
 331   ASSERT_TRUE(all_extensions_message.ParseFromString(bizarro_data));
 332   ASSERT_TRUE(empty_message.ParseFromString(bizarro_data));
 333
 334   // All fields should have been interpreted as unknown, so the debug strings
 335   // should be the same.
 336   EXPECT_EQ(empty_message.DebugString(), all_extensions_message.DebugString());
 337 }
 338
 339 TEST_F(UnknownFieldSetTest, UnknownEnumValue) {
 340   using unittest::TestAllTypes;
 341   using unittest::TestAllExtensions;
 342   using unittest::TestEmptyMessage;
 343
 344   const FieldDescriptor* singular_field =
 345     TestAllTypes::descriptor()->FindFieldByName("optional_nested_enum");
 346   const FieldDescriptor* repeated_field =
 347     TestAllTypes::descriptor()->FindFieldByName("repeated_nested_enum");
 348   ASSERT_TRUE(singular_field != NULL);
 349   ASSERT_TRUE(repeated_field != NULL);
 350
 351   string data;
 352
 353   {
 354     TestEmptyMessage empty_message;
 355     UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
 356     UnknownField* singular_unknown_field =
 357       unknown_fields->AddField(singular_field->number());
 358     singular_unknown_field->add_varint(TestAllTypes::BAR);
 359     singular_unknown_field->add_varint(5);  // not valid
 360     UnknownField* repeated_unknown_field =
 361       unknown_fields->AddField(repeated_field->number());
 362     repeated_unknown_field->add_varint(TestAllTypes::FOO);
 363     repeated_unknown_field->add_varint(4);  // not valid
 364     repeated_unknown_field->add_varint(TestAllTypes::BAZ);
 365     repeated_unknown_field->add_varint(6);  // not valid
 366     empty_message.SerializeToString(&data);
 367   }
 368
 369   {
 370     TestAllTypes message;
 371     ASSERT_TRUE(message.ParseFromString(data));
 372     EXPECT_EQ(TestAllTypes::BAR, message.optional_nested_enum());
 373     ASSERT_EQ(2, message.repeated_nested_enum_size());
 374     EXPECT_EQ(TestAllTypes::FOO, message.repeated_nested_enum(0));
 375     EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(1));
 376
 377     const UnknownFieldSet& unknown_fields = message.unknown_fields();
 378     ASSERT_EQ(2, unknown_fields.field_count());
 379
 380     const UnknownField& singular_unknown_field = unknown_fields.field(0);
 381     ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
 382     ASSERT_EQ(1, singular_unknown_field.varint_size());
 383     EXPECT_EQ(5, singular_unknown_field.varint(0));
 384
 385     const UnknownField& repeated_unknown_field = unknown_fields.field(1);
 386     ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
 387     ASSERT_EQ(2, repeated_unknown_field.varint_size());
 388     EXPECT_EQ(4, repeated_unknown_field.varint(0));
 389     EXPECT_EQ(6, repeated_unknown_field.varint(1));
 390   }
 391
 392   {
 393     using unittest::optional_nested_enum_extension;
 394     using unittest::repeated_nested_enum_extension;
 395
 396     TestAllExtensions message;
 397     ASSERT_TRUE(message.ParseFromString(data));
 398     EXPECT_EQ(TestAllTypes::BAR,
 399               message.GetExtension(optional_nested_enum_extension));
 400     ASSERT_EQ(2, message.ExtensionSize(repeated_nested_enum_extension));
 401     EXPECT_EQ(TestAllTypes::FOO,
 402               message.GetExtension(repeated_nested_enum_extension, 0));
 403     EXPECT_EQ(TestAllTypes::BAZ,
 404               message.GetExtension(repeated_nested_enum_extension, 1));
 405
 406     const UnknownFieldSet& unknown_fields = message.unknown_fields();
 407     ASSERT_EQ(2, unknown_fields.field_count());
 408
 409     const UnknownField& singular_unknown_field = unknown_fields.field(0);
 410     ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
 411     ASSERT_EQ(1, singular_unknown_field.varint_size());
 412     EXPECT_EQ(5, singular_unknown_field.varint(0));
 413
 414     const UnknownField& repeated_unknown_field = unknown_fields.field(1);
 415     ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
 416     ASSERT_EQ(2, repeated_unknown_field.varint_size());
 417     EXPECT_EQ(4, repeated_unknown_field.varint(0));
 418     EXPECT_EQ(6, repeated_unknown_field.varint(1));
 419   }
 420 }
 421
 422 }  // namespace
 423 }  // namespace protobuf
 424 }  // namespace google