← Back to branch summary

~ubuntu-branches/ubuntu/precise/protobuf/precise

« back to all changes in this revision

Viewing changes to src/google/protobuf/unknown_field_set_unittest.cc

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2009-11-16 10:41:33 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20091116104133-ykhy3deg5l4975tw
Tags: 2.1.0-1ubuntu1
* Merge from Debian testing.
* Remaining Ubuntu changes:
  - Disable the death tests on IA64, now as a quilt patch.
  - Don't use python2.4, also as a quilt patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/unknown_field_set_unittest.cc
37
37
 
38
38
#include <google/protobuf/unknown_field_set.h>
39
39
#include <google/protobuf/descriptor.h>
 
40
#include <google/protobuf/io/coded_stream.h>
40
41
#include <google/protobuf/io/zero_copy_stream_impl.h>
41
 
#include <google/protobuf/io/coded_stream.h>
42
42
#include <google/protobuf/wire_format.h>
43
43
#include <google/protobuf/unittest.pb.h>
44
44
#include <google/protobuf/test_util.h>
46
46
#include <google/protobuf/stubs/common.h>
47
47
#include <google/protobuf/testing/googletest.h>
48
48
#include <gtest/gtest.h>
 
49
#include <google/protobuf/stubs/stl_util-inl.h>
49
50
 
50
51
namespace google {
51
52
namespace protobuf {
67
68
  const UnknownField* GetField(const string& name) {
68
69
    const FieldDescriptor* field = descriptor_->FindFieldByName(name);
69
70
    if (field == NULL) return NULL;
70
 
    return unknown_fields_->FindFieldByNumber(field->number());
 
71
    for (int i = 0; i < unknown_fields_->field_count(); i++) {
 
72
      if (unknown_fields_->field(i).number() == field->number()) {
 
73
        return &unknown_fields_->field(i);
 
74
      }
 
75
    }
 
76
    return NULL;
71
77
  }
72
78
 
73
79
  // Constructs a protocol buffer which contains fields with all the same
79
85
      bizarro_message.mutable_unknown_fields();
80
86
    for (int i = 0; i < unknown_fields_->field_count(); i++) {
81
87
      const UnknownField& unknown_field = unknown_fields_->field(i);
82
 
      UnknownField* bizarro_field =
83
 
        bizarro_unknown_fields->AddField(unknown_field.number());
84
 
      if (unknown_field.varint_size() == 0) {
85
 
        bizarro_field->add_varint(1);
 
88
      if (unknown_field.type() == UnknownField::TYPE_VARINT) {
 
89
        bizarro_unknown_fields->AddFixed32(unknown_field.number(), 1);
86
90
      } else {
87
 
        bizarro_field->add_fixed32(1);
 
91
        bizarro_unknown_fields->AddVarint(unknown_field.number(), 1);
88
92
      }
89
93
    }
90
94
 
103
107
  UnknownFieldSet* unknown_fields_;
104
108
};
105
109
 
106
 
TEST_F(UnknownFieldSetTest, Index) {
107
 
  for (int i = 0; i < unknown_fields_->field_count(); i++) {
108
 
    EXPECT_EQ(i, unknown_fields_->field(i).index());
109
 
  }
110
 
}
 
110
TEST_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.
111
114
 
112
 
TEST_F(UnknownFieldSetTest, FindFieldByNumber) {
113
 
  // All fields of TestAllTypes should be present.  Fields that are not valid
114
 
  // field numbers of TestAllTypes should NOT be present.
 
115
  int pos = 0;
115
116
 
116
117
  for (int i = 0; i < 1000; i++) {
117
 
    if (descriptor_->FindFieldByNumber(i) == NULL) {
118
 
      EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) == NULL);
119
 
    } else {
120
 
      EXPECT_TRUE(unknown_fields_->FindFieldByNumber(i) != NULL);
 
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
      }
121
127
    }
122
128
  }
 
129
  EXPECT_EQ(unknown_fields_->field_count(), pos);
123
130
}
124
131
 
125
132
TEST_F(UnknownFieldSetTest, Varint) {
126
133
  const UnknownField* field = GetField("optional_int32");
127
134
  ASSERT_TRUE(field != NULL);
128
135
 
129
 
  ASSERT_EQ(1, field->varint_size());
130
 
  EXPECT_EQ(all_fields_.optional_int32(), field->varint(0));
 
136
  ASSERT_EQ(UnknownField::TYPE_VARINT, field->type());
 
137
  EXPECT_EQ(all_fields_.optional_int32(), field->varint());
131
138
}
132
139
 
133
140
TEST_F(UnknownFieldSetTest, Fixed32) {
134
141
  const UnknownField* field = GetField("optional_fixed32");
135
142
  ASSERT_TRUE(field != NULL);
136
143
 
137
 
  ASSERT_EQ(1, field->fixed32_size());
138
 
  EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32(0));
 
144
  ASSERT_EQ(UnknownField::TYPE_FIXED32, field->type());
 
145
  EXPECT_EQ(all_fields_.optional_fixed32(), field->fixed32());
139
146
}
140
147
 
141
148
TEST_F(UnknownFieldSetTest, Fixed64) {
142
149
  const UnknownField* field = GetField("optional_fixed64");
143
150
  ASSERT_TRUE(field != NULL);
144
151
 
145
 
  ASSERT_EQ(1, field->fixed64_size());
146
 
  EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64(0));
 
152
  ASSERT_EQ(UnknownField::TYPE_FIXED64, field->type());
 
153
  EXPECT_EQ(all_fields_.optional_fixed64(), field->fixed64());
147
154
}
148
155
 
149
156
TEST_F(UnknownFieldSetTest, LengthDelimited) {
150
157
  const UnknownField* field = GetField("optional_string");
151
158
  ASSERT_TRUE(field != NULL);
152
159
 
153
 
  ASSERT_EQ(1, field->length_delimited_size());
154
 
  EXPECT_EQ(all_fields_.optional_string(), field->length_delimited(0));
 
160
  ASSERT_EQ(UnknownField::TYPE_LENGTH_DELIMITED, field->type());
 
161
  EXPECT_EQ(all_fields_.optional_string(), field->length_delimited());
155
162
}
156
163
 
157
164
TEST_F(UnknownFieldSetTest, Group) {
158
165
  const UnknownField* field = GetField("optionalgroup");
159
166
  ASSERT_TRUE(field != NULL);
160
167
 
161
 
  ASSERT_EQ(1, field->group_size());
162
 
  EXPECT_EQ(1, field->group(0).field_count());
 
168
  ASSERT_EQ(UnknownField::TYPE_GROUP, field->type());
 
169
  ASSERT_EQ(1, field->group().field_count());
163
170
 
164
 
  const UnknownField& nested_field = field->group(0).field(0);
 
171
  const UnknownField& nested_field = field->group().field(0);
165
172
  const FieldDescriptor* nested_field_descriptor =
166
173
    unittest::TestAllTypes::OptionalGroup::descriptor()->FindFieldByName("a");
167
174
  ASSERT_TRUE(nested_field_descriptor != NULL);
168
175
 
169
176
  EXPECT_EQ(nested_field_descriptor->number(), nested_field.number());
170
 
  EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint(0));
 
177
  ASSERT_EQ(UnknownField::TYPE_VARINT, nested_field.type());
 
178
  EXPECT_EQ(all_fields_.optionalgroup().a(), nested_field.varint());
 
179
}
 
180
 
 
181
TEST_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);
171
202
}
172
203
 
173
204
TEST_F(UnknownFieldSetTest, Serialize) {
205
236
    io::StringOutputStream raw_output(&data);
206
237
    io::CodedOutputStream output(&raw_output);
207
238
    int size = WireFormat::ByteSize(empty_message_);
208
 
    ASSERT_TRUE(
209
 
      WireFormat::SerializeWithCachedSizes(empty_message_, size, &output));
 
239
    WireFormat::SerializeWithCachedSizes(empty_message_, size, &output);
 
240
    ASSERT_FALSE(output.HadError());
210
241
  }
211
242
 
212
243
  // Don't use EXPECT_EQ because we don't want to dump raw binary data to
249
280
TEST_F(UnknownFieldSetTest, MergeFrom) {
250
281
  unittest::TestEmptyMessage source, destination;
251
282
 
252
 
  destination.mutable_unknown_fields()->AddField(1)->add_varint(1);
253
 
  destination.mutable_unknown_fields()->AddField(3)->add_varint(2);
254
 
  source.mutable_unknown_fields()->AddField(2)->add_varint(3);
255
 
  source.mutable_unknown_fields()->AddField(3)->add_varint(4);
 
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);
256
287
 
257
288
  destination.MergeFrom(source);
258
289
 
261
292
    //   and merging, above.
262
293
    "1: 1\n"
263
294
    "3: 2\n"
264
 
    "3: 4\n"
265
 
    "2: 3\n",
 
295
    "2: 3\n"
 
296
    "3: 4\n",
266
297
    destination.DebugString());
267
298
}
268
299
 
269
300
TEST_F(UnknownFieldSetTest, Clear) {
270
 
  // Get a pointer to a contained field object.
271
 
  const UnknownField* field = GetField("optional_int32");
272
 
  ASSERT_TRUE(field != NULL);
273
 
  ASSERT_EQ(1, field->varint_size());
274
 
  int number = field->number();
275
 
 
276
301
  // Clear the set.
277
302
  empty_message_.Clear();
278
303
  EXPECT_EQ(0, unknown_fields_->field_count());
279
 
 
280
 
  // If we add that field again we should get the same object.
281
 
  ASSERT_EQ(field, unknown_fields_->AddField(number));
282
 
 
283
 
  // But it should be cleared.
284
 
  EXPECT_EQ(0, field->varint_size());
285
304
}
286
305
 
287
306
TEST_F(UnknownFieldSetTest, ParseKnownAndUnknown) {
288
307
  // Test mixing known and unknown fields when parsing.
289
308
 
290
309
  unittest::TestEmptyMessage source;
291
 
  source.mutable_unknown_fields()->AddField(123456)->add_varint(654321);
 
310
  source.mutable_unknown_fields()->AddVarint(123456, 654321);
292
311
  string data;
293
312
  ASSERT_TRUE(source.SerializeToString(&data));
294
313
 
297
316
 
298
317
  TestUtil::ExpectAllFieldsSet(destination);
299
318
  ASSERT_EQ(1, destination.unknown_fields().field_count());
300
 
  ASSERT_EQ(1, destination.unknown_fields().field(0).varint_size());
301
 
  EXPECT_EQ(654321, destination.unknown_fields().field(0).varint(0));
 
319
  ASSERT_EQ(UnknownField::TYPE_VARINT,
 
320
            destination.unknown_fields().field(0).type());
 
321
  EXPECT_EQ(654321, destination.unknown_fields().field(0).varint());
302
322
}
303
323
 
304
324
TEST_F(UnknownFieldSetTest, WrongTypeTreatedAsUnknown) {
384
404
  {
385
405
    TestEmptyMessage empty_message;
386
406
    UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
387
 
    UnknownField* singular_unknown_field =
388
 
      unknown_fields->AddField(singular_field->number());
389
 
    singular_unknown_field->add_varint(TestAllTypes::BAR);
390
 
    singular_unknown_field->add_varint(5);  // not valid
391
 
    UnknownField* repeated_unknown_field =
392
 
      unknown_fields->AddField(repeated_field->number());
393
 
    repeated_unknown_field->add_varint(TestAllTypes::FOO);
394
 
    repeated_unknown_field->add_varint(4);  // not valid
395
 
    repeated_unknown_field->add_varint(TestAllTypes::BAZ);
396
 
    repeated_unknown_field->add_varint(6);  // not valid
 
407
    unknown_fields->AddVarint(singular_field->number(), TestAllTypes::BAR);
 
408
    unknown_fields->AddVarint(singular_field->number(), 5);  // not valid
 
409
    unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::FOO);
 
410
    unknown_fields->AddVarint(repeated_field->number(), 4);  // not valid
 
411
    unknown_fields->AddVarint(repeated_field->number(), TestAllTypes::BAZ);
 
412
    unknown_fields->AddVarint(repeated_field->number(), 6);  // not valid
397
413
    empty_message.SerializeToString(&data);
398
414
  }
399
415
 
406
422
    EXPECT_EQ(TestAllTypes::BAZ, message.repeated_nested_enum(1));
407
423
 
408
424
    const UnknownFieldSet& unknown_fields = message.unknown_fields();
409
 
    ASSERT_EQ(2, unknown_fields.field_count());
410
 
 
411
 
    const UnknownField& singular_unknown_field = unknown_fields.field(0);
412
 
    ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
413
 
    ASSERT_EQ(1, singular_unknown_field.varint_size());
414
 
    EXPECT_EQ(5, singular_unknown_field.varint(0));
415
 
 
416
 
    const UnknownField& repeated_unknown_field = unknown_fields.field(1);
417
 
    ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
418
 
    ASSERT_EQ(2, repeated_unknown_field.varint_size());
419
 
    EXPECT_EQ(4, repeated_unknown_field.varint(0));
420
 
    EXPECT_EQ(6, repeated_unknown_field.varint(1));
 
425
    ASSERT_EQ(3, unknown_fields.field_count());
 
426
 
 
427
    EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
 
428
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
 
429
    EXPECT_EQ(5, unknown_fields.field(0).varint());
 
430
 
 
431
    EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
 
432
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
 
433
    EXPECT_EQ(4, unknown_fields.field(1).varint());
 
434
 
 
435
    EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
 
436
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
 
437
    EXPECT_EQ(6, unknown_fields.field(2).varint());
421
438
  }
422
439
 
423
440
  {
435
452
              message.GetExtension(repeated_nested_enum_extension, 1));
436
453
 
437
454
    const UnknownFieldSet& unknown_fields = message.unknown_fields();
438
 
    ASSERT_EQ(2, unknown_fields.field_count());
439
 
 
440
 
    const UnknownField& singular_unknown_field = unknown_fields.field(0);
441
 
    ASSERT_EQ(singular_field->number(), singular_unknown_field.number());
442
 
    ASSERT_EQ(1, singular_unknown_field.varint_size());
443
 
    EXPECT_EQ(5, singular_unknown_field.varint(0));
444
 
 
445
 
    const UnknownField& repeated_unknown_field = unknown_fields.field(1);
446
 
    ASSERT_EQ(repeated_field->number(), repeated_unknown_field.number());
447
 
    ASSERT_EQ(2, repeated_unknown_field.varint_size());
448
 
    EXPECT_EQ(4, repeated_unknown_field.varint(0));
449
 
    EXPECT_EQ(6, repeated_unknown_field.varint(1));
450
 
  }
451
 
}
452
 
 
453
 
TEST_F(UnknownFieldSetTest, SpaceUsedExcludingSelf) {
454
 
  {
455
 
    // Make sure an unknown field set has zero space used until a field is
456
 
    // actually added.
457
 
    unittest::TestEmptyMessage empty_message;
458
 
    const int empty_message_size = empty_message.SpaceUsed();
459
 
    UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
460
 
    EXPECT_EQ(empty_message_size, empty_message.SpaceUsed());
461
 
    unknown_fields->AddField(1)->add_varint(0);
462
 
    EXPECT_LT(empty_message_size, empty_message.SpaceUsed());
463
 
  }
464
 
  {
465
 
    // Test varints.
466
 
    UnknownFieldSet unknown_fields;
467
 
    UnknownField* field = unknown_fields.AddField(1);
468
 
    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
469
 
    for (int i = 0; i < 16; ++i) {
470
 
      field->add_varint(i);
471
 
    }
472
 
    // Should just defer computation to the RepeatedField.
473
 
    int expected_size = base_size + field->varint().SpaceUsedExcludingSelf();
474
 
    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
475
 
  }
476
 
  {
477
 
    // Test fixed32s.
478
 
    UnknownFieldSet unknown_fields;
479
 
    UnknownField* field = unknown_fields.AddField(1);
480
 
    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
481
 
    for (int i = 0; i < 16; ++i) {
482
 
      field->add_fixed32(i);
483
 
    }
484
 
    int expected_size = base_size + field->fixed32().SpaceUsedExcludingSelf();
485
 
    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
486
 
  }
487
 
  {
488
 
    // Test fixed64s.
489
 
    UnknownFieldSet unknown_fields;
490
 
    UnknownField* field = unknown_fields.AddField(1);
491
 
    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
492
 
    for (int i = 0; i < 16; ++i) {
493
 
      field->add_fixed64(i);
494
 
    }
495
 
    int expected_size = base_size + field->fixed64().SpaceUsedExcludingSelf();
496
 
    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
497
 
  }
498
 
  {
499
 
    // Test length-delimited types.
500
 
    UnknownFieldSet unknown_fields;
501
 
    UnknownField* field = unknown_fields.AddField(1);
502
 
    const int base_size = unknown_fields.SpaceUsedExcludingSelf();
503
 
    for (int i = 0; i < 16; ++i) {
504
 
      field->add_length_delimited()->assign("my length delimited string");
505
 
    }
506
 
    int expected_size = base_size +
507
 
        field->length_delimited().SpaceUsedExcludingSelf();
508
 
    EXPECT_EQ(expected_size, unknown_fields.SpaceUsedExcludingSelf());
 
455
    ASSERT_EQ(3, unknown_fields.field_count());
 
456
 
 
457
    EXPECT_EQ(singular_field->number(), unknown_fields.field(0).number());
 
458
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(0).type());
 
459
    EXPECT_EQ(5, unknown_fields.field(0).varint());
 
460
 
 
461
    EXPECT_EQ(repeated_field->number(), unknown_fields.field(1).number());
 
462
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(1).type());
 
463
    EXPECT_EQ(4, unknown_fields.field(1).varint());
 
464
 
 
465
    EXPECT_EQ(repeated_field->number(), unknown_fields.field(2).number());
 
466
    ASSERT_EQ(UnknownField::TYPE_VARINT, unknown_fields.field(2).type());
 
467
    EXPECT_EQ(6, unknown_fields.field(2).varint());
509
468
  }
510
469
}
511
470
 
512
471
TEST_F(UnknownFieldSetTest, SpaceUsed) {
 
472
  unittest::TestEmptyMessage empty_message;
 
473
 
 
474
  // Make sure an unknown field set has zero space used until a field is
 
475
  // actually added.
 
476
  int base_size = empty_message.SpaceUsed();
 
477
  UnknownFieldSet* unknown_fields = empty_message.mutable_unknown_fields();
 
478
  EXPECT_EQ(base_size, empty_message.SpaceUsed());
 
479
 
 
480
  // Make sure each thing we add to the set increases the SpaceUsed().
 
481
  unknown_fields->AddVarint(1, 0);
 
482
  EXPECT_LT(base_size, empty_message.SpaceUsed());
 
483
  base_size = empty_message.SpaceUsed();
 
484
 
 
485
  string* str = unknown_fields->AddLengthDelimited(1);
 
486
  EXPECT_LT(base_size, empty_message.SpaceUsed());
 
487
  base_size = empty_message.SpaceUsed();
 
488
 
 
489
  str->assign(sizeof(string) + 1, 'x');
 
490
  EXPECT_LT(base_size, empty_message.SpaceUsed());
 
491
  base_size = empty_message.SpaceUsed();
 
492
 
 
493
  UnknownFieldSet* group = unknown_fields->AddGroup(1);
 
494
  EXPECT_LT(base_size, empty_message.SpaceUsed());
 
495
  base_size = empty_message.SpaceUsed();
 
496
 
 
497
  group->AddVarint(1, 0);
 
498
  EXPECT_LT(base_size, empty_message.SpaceUsed());
 
499
}
 
500
 
 
501
TEST_F(UnknownFieldSetTest, Empty) {
513
502
  UnknownFieldSet unknown_fields;
514
 
  const int expected_size = sizeof(unknown_fields) +
515
 
      unknown_fields.SpaceUsedExcludingSelf();
516
 
  EXPECT_EQ(expected_size, unknown_fields.SpaceUsed());
 
503
  EXPECT_TRUE(unknown_fields.empty());
 
504
  unknown_fields.AddVarint(6, 123);
 
505
  EXPECT_FALSE(unknown_fields.empty());
 
506
  unknown_fields.Clear();
 
507
  EXPECT_TRUE(unknown_fields.empty());
517
508
}
518
509
 
519
510
}  // namespace