← Back to branch summary

~ubuntu-branches/ubuntu/maverick/protobuf/maverick

« back to all changes in this revision

Viewing changes to src/google/protobuf/compiler/cpp/cpp_unittest.cc

  • Committer: Bazaar Package Importer
  • Author(s): Manny Vindiola
  • Date: 2008-12-18 01:26:29 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081218012629-l93kqt3jptydn9zh
Tags: 2.0.3-0ubuntu1
https://launchpad.net/bugs/309237
https://launchpad.net/bugs/308829
* Merge from new upstream version (LP: #309237), remaining changes:
   * debian/control Moving python-support from Build-Depends-Indep
     to Build-Depends to fix build failures.  
* Fix FTBFS on ia64 architecture due to lack of clone(2)
   - src/gtest/internal/gtest-port.h (LP: #308829)
     disable death tests if architecture is IA64
     adapted from gtest upstream fix at:
     http://codereview.appspot.com/8690/show
* Fix FTBFS on x64 architectures due to python 2.x int vs long issue
  test expects return type long but on x64 architecture return type 
  unpacks to int
   -python/google/protobuf/internal/decoder_test.py
    explicitly type the result value as long 
   taken from upstream discussion:
   http://groups.google.com/group/protobuf/browse_thread
       /thread/2357176cb1f50e10/

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/compiler/cpp/cpp_unittest.cc
67
67
namespace compiler {
68
68
namespace cpp {
69
69
 
70
 
namespace {
 
70
// Can't use an anonymous namespace here due to brokenness of Tru64 compiler.
 
71
namespace cpp_unittest {
71
72
 
72
73
 
73
74
class MockErrorCollector : public MultiFileErrorCollector {
235
236
  TestUtil::ExpectAllFieldsSet(message2);
236
237
}
237
238
 
 
239
TEST(GeneratedMessageTest, SwapWithEmpty) {
 
240
  unittest::TestAllTypes message1, message2;
 
241
  TestUtil::SetAllFields(&message1);
 
242
 
 
243
  TestUtil::ExpectAllFieldsSet(message1);
 
244
  TestUtil::ExpectClear(message2);
 
245
  message1.Swap(&message2);
 
246
  TestUtil::ExpectAllFieldsSet(message2);
 
247
  TestUtil::ExpectClear(message1);
 
248
}
 
249
 
 
250
TEST(GeneratedMessageTest, SwapWithSelf) {
 
251
  unittest::TestAllTypes message;
 
252
  TestUtil::SetAllFields(&message);
 
253
  TestUtil::ExpectAllFieldsSet(message);
 
254
  message.Swap(&message);
 
255
  TestUtil::ExpectAllFieldsSet(message);
 
256
}
 
257
 
 
258
TEST(GeneratedMessageTest, SwapWithOther) {
 
259
  unittest::TestAllTypes message1, message2;
 
260
 
 
261
  message1.set_optional_int32(123);
 
262
  message1.set_optional_string("abc");
 
263
  message1.mutable_optional_nested_message()->set_bb(1);
 
264
  message1.set_optional_nested_enum(unittest::TestAllTypes::FOO);
 
265
  message1.add_repeated_int32(1);
 
266
  message1.add_repeated_int32(2);
 
267
  message1.add_repeated_string("a");
 
268
  message1.add_repeated_string("b");
 
269
  message1.add_repeated_nested_message()->set_bb(7);
 
270
  message1.add_repeated_nested_message()->set_bb(8);
 
271
  message1.add_repeated_nested_enum(unittest::TestAllTypes::FOO);
 
272
  message1.add_repeated_nested_enum(unittest::TestAllTypes::BAR);
 
273
 
 
274
  message2.set_optional_int32(456);
 
275
  message2.set_optional_string("def");
 
276
  message2.mutable_optional_nested_message()->set_bb(2);
 
277
  message2.set_optional_nested_enum(unittest::TestAllTypes::BAR);
 
278
  message2.add_repeated_int32(3);
 
279
  message2.add_repeated_string("c");
 
280
  message2.add_repeated_nested_message()->set_bb(9);
 
281
  message2.add_repeated_nested_enum(unittest::TestAllTypes::BAZ);
 
282
 
 
283
  message1.Swap(&message2);
 
284
 
 
285
  EXPECT_EQ(456, message1.optional_int32());
 
286
  EXPECT_EQ("def", message1.optional_string());
 
287
  EXPECT_EQ(2, message1.optional_nested_message().bb());
 
288
  EXPECT_EQ(unittest::TestAllTypes::BAR, message1.optional_nested_enum());
 
289
  ASSERT_EQ(1, message1.repeated_int32_size());
 
290
  EXPECT_EQ(3, message1.repeated_int32(0));
 
291
  ASSERT_EQ(1, message1.repeated_string_size());
 
292
  EXPECT_EQ("c", message1.repeated_string(0));
 
293
  ASSERT_EQ(1, message1.repeated_nested_message_size());
 
294
  EXPECT_EQ(9, message1.repeated_nested_message(0).bb());
 
295
  ASSERT_EQ(1, message1.repeated_nested_enum_size());
 
296
  EXPECT_EQ(unittest::TestAllTypes::BAZ, message1.repeated_nested_enum(0));
 
297
 
 
298
  EXPECT_EQ(123, message2.optional_int32());
 
299
  EXPECT_EQ("abc", message2.optional_string());
 
300
  EXPECT_EQ(1, message2.optional_nested_message().bb());
 
301
  EXPECT_EQ(unittest::TestAllTypes::FOO, message2.optional_nested_enum());
 
302
  ASSERT_EQ(2, message2.repeated_int32_size());
 
303
  EXPECT_EQ(1, message2.repeated_int32(0));
 
304
  EXPECT_EQ(2, message2.repeated_int32(1));
 
305
  ASSERT_EQ(2, message2.repeated_string_size());
 
306
  EXPECT_EQ("a", message2.repeated_string(0));
 
307
  EXPECT_EQ("b", message2.repeated_string(1));
 
308
  ASSERT_EQ(2, message2.repeated_nested_message_size());
 
309
  EXPECT_EQ(7, message2.repeated_nested_message(0).bb());
 
310
  EXPECT_EQ(8, message2.repeated_nested_message(1).bb());
 
311
  ASSERT_EQ(2, message2.repeated_nested_enum_size());
 
312
  EXPECT_EQ(unittest::TestAllTypes::FOO, message2.repeated_nested_enum(0));
 
313
  EXPECT_EQ(unittest::TestAllTypes::BAR, message2.repeated_nested_enum(1));
 
314
}
 
315
 
238
316
TEST(GeneratedMessageTest, CopyConstructor) {
239
317
  unittest::TestAllTypes message1;
240
318
  TestUtil::SetAllFields(&message1);
491
569
  EXPECT_EQ(2, message2.repeated_message(0).msg().c());
492
570
}
493
571
 
 
572
TEST(GeneratedMessageTest, TestSpaceUsed) {
 
573
  unittest::TestAllTypes message1;
 
574
  // sizeof provides a lower bound on SpaceUsed().
 
575
  EXPECT_LE(sizeof(unittest::TestAllTypes), message1.SpaceUsed());
 
576
  const int empty_message_size = message1.SpaceUsed();
 
577
 
 
578
  // Setting primitive types shouldn't affect the space used.
 
579
  message1.set_optional_int32(123);
 
580
  message1.set_optional_int64(12345);
 
581
  message1.set_optional_uint32(123);
 
582
  message1.set_optional_uint64(12345);
 
583
  EXPECT_EQ(empty_message_size, message1.SpaceUsed());
 
584
 
 
585
  // On some STL implementations, setting the string to a small value should
 
586
  // only increase SpaceUsed() by the size of a string object, though this is
 
587
  // not true everywhere.
 
588
  message1.set_optional_string("abc");
 
589
  EXPECT_LE(empty_message_size + sizeof(string), message1.SpaceUsed());
 
590
 
 
591
  // Setting a string to a value larger than the string object itself should
 
592
  // increase SpaceUsed(), because it cannot store the value internally.
 
593
  message1.set_optional_string(string(sizeof(string) + 1, 'x'));
 
594
  int min_expected_increase = message1.optional_string().capacity() +
 
595
      sizeof(string);
 
596
  EXPECT_LE(empty_message_size + min_expected_increase,
 
597
            message1.SpaceUsed());
 
598
 
 
599
  int previous_size = message1.SpaceUsed();
 
600
  // Adding an optional message should increase the size by the size of the
 
601
  // nested message type. NestedMessage is simple enough (1 int field) that it
 
602
  // is equal to sizeof(NestedMessage)
 
603
  message1.mutable_optional_nested_message();
 
604
  ASSERT_EQ(sizeof(unittest::TestAllTypes::NestedMessage),
 
605
            message1.optional_nested_message().SpaceUsed());
 
606
  EXPECT_EQ(previous_size +
 
607
            sizeof(unittest::TestAllTypes::NestedMessage),
 
608
            message1.SpaceUsed());
 
609
}
 
610
 
494
611
// ===================================================================
495
612
 
496
613
TEST(GeneratedEnumTest, EnumValuesAsSwitchCases) {
854
971
  EXPECT_TRUE(controller.called_);
855
972
}
856
973
 
857
 
}  // namespace
 
974
}  // namespace cpp_unittest
858
975
 
859
976
}  // namespace cpp
860
977
}  // namespace compiler