← Back to branch summary

~ubuntu-branches/debian/stretch/protobuf/stretch

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Robert S. Edmonds
  • Date: 2014-09-11 22:50:10 UTC
  • mfrom: (10.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20140911225010-wt4yo9dpc1fzuq5g
Tags: 2.6.0-3
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/compiler/cpp/cpp_unittest.cc
46
46
 
47
47
#include <google/protobuf/compiler/cpp/cpp_unittest.h>
48
48
 
 
49
#include <memory>
49
50
#include <vector>
50
51
 
51
52
#include <google/protobuf/unittest.pb.h>
53
54
#include <google/protobuf/unittest_embed_optimize_for.pb.h>
54
55
#include <google/protobuf/unittest_no_generic_services.pb.h>
55
56
#include <google/protobuf/test_util.h>
 
57
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
56
58
#include <google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h>
57
59
#include <google/protobuf/compiler/importer.h>
58
60
#include <google/protobuf/io/coded_stream.h>
148
150
            &message.optional_import_message());
149
151
}
150
152
 
 
153
TEST(GeneratedMessageTest, Int32StringConversion) {
 
154
  EXPECT_EQ("971", Int32ToString(971));
 
155
  EXPECT_EQ("(~0x7fffffff)", Int32ToString(kint32min));
 
156
  EXPECT_EQ("2147483647", Int32ToString(kint32max));
 
157
}
 
158
 
 
159
TEST(GeneratedMessageTest, Int64StringConversion) {
 
160
  EXPECT_EQ("GOOGLE_LONGLONG(971)", Int64ToString(971));
 
161
  EXPECT_EQ("GOOGLE_LONGLONG(-2147483648)", Int64ToString(kint32min));
 
162
  EXPECT_EQ("GOOGLE_LONGLONG(~0x7fffffffffffffff)", Int64ToString(kint64min));
 
163
  EXPECT_EQ("GOOGLE_LONGLONG(9223372036854775807)", Int64ToString(kint64max));
 
164
}
 
165
 
151
166
TEST(GeneratedMessageTest, FloatingPointDefaults) {
152
167
  const unittest::TestExtremeDefaultValues& extreme_default =
153
168
      unittest::TestExtremeDefaultValues::default_instance();
181
196
TEST(GeneratedMessageTest, ExtremeSmallIntegerDefault) {
182
197
  const unittest::TestExtremeDefaultValues& extreme_default =
183
198
      unittest::TestExtremeDefaultValues::default_instance();
184
 
  EXPECT_EQ(-0x80000000, kint32min);
185
 
  EXPECT_EQ(GOOGLE_LONGLONG(-0x8000000000000000), kint64min);
 
199
  EXPECT_EQ(~0x7fffffff, kint32min);
 
200
  EXPECT_EQ(GOOGLE_LONGLONG(~0x7fffffffffffffff), kint64min);
186
201
  EXPECT_EQ(kint32min, extreme_default.really_small_int32());
187
202
  EXPECT_EQ(kint64min, extreme_default.really_small_int64());
188
203
}
233
248
 
234
249
  message.set_default_string("blah");
235
250
  EXPECT_TRUE(message.has_default_string());
236
 
  string* str = message.release_default_string();
 
251
  scoped_ptr<string> str(message.release_default_string());
237
252
  EXPECT_FALSE(message.has_default_string());
238
253
  ASSERT_TRUE(str != NULL);
239
254
  EXPECT_EQ("blah", *str);
240
 
  delete str;
241
255
 
242
256
  EXPECT_EQ(NULL, message.release_default_string());
243
257
  EXPECT_FALSE(message.has_default_string());
253
267
  EXPECT_FALSE(message.has_optional_nested_message());
254
268
 
255
269
  message.mutable_optional_nested_message()->set_bb(1);
256
 
  unittest::TestAllTypes::NestedMessage* nest =
257
 
      message.release_optional_nested_message();
 
270
  scoped_ptr<unittest::TestAllTypes::NestedMessage> nest(
 
271
      message.release_optional_nested_message());
258
272
  EXPECT_FALSE(message.has_optional_nested_message());
259
273
  ASSERT_TRUE(nest != NULL);
260
274
  EXPECT_EQ(1, nest->bb());
261
 
  delete nest;
262
275
 
263
276
  EXPECT_EQ(NULL, message.release_optional_nested_message());
264
277
  EXPECT_FALSE(message.has_optional_nested_message());
381
394
  EXPECT_EQ("wx", message.repeated_string(0));
382
395
}
383
396
 
 
397
 
384
398
TEST(GeneratedMessageTest, CopyFrom) {
385
399
  unittest::TestAllTypes message1, message2;
386
400
 
393
407
  TestUtil::ExpectAllFieldsSet(message2);
394
408
}
395
409
 
 
410
 
396
411
TEST(GeneratedMessageTest, SwapWithEmpty) {
397
412
  unittest::TestAllTypes message1, message2;
398
413
  TestUtil::SetAllFields(&message1);
763
778
  message.set_friend_(5);
764
779
  EXPECT_EQ(5, message.friend_());
765
780
 
 
781
  message.set_class_(6);
 
782
  EXPECT_EQ(6, message.class_());
 
783
 
766
784
  // Instantiate extension template functions to test conflicting template
767
785
  // parameter names.
768
786
  typedef protobuf_unittest::TestConflictingSymbolNamesExtension ExtensionMessage;
840
858
            message1.SpaceUsed());
841
859
}
842
860
 
 
861
TEST(GeneratedMessageTest, TestOneofSpaceUsed) {
 
862
  unittest::TestOneof2 message1;
 
863
  EXPECT_LE(sizeof(unittest::TestOneof2), message1.SpaceUsed());
 
864
 
 
865
  const int empty_message_size = message1.SpaceUsed();
 
866
  // Setting primitive types shouldn't affect the space used.
 
867
  message1.set_foo_int(123);
 
868
  message1.set_bar_int(12345);
 
869
  EXPECT_EQ(empty_message_size, message1.SpaceUsed());
 
870
 
 
871
  // Setting a string in oneof to a small value should only increase SpaceUsed()
 
872
  // by the size of a string object.
 
873
  message1.set_foo_string("abc");
 
874
  EXPECT_LE(empty_message_size + sizeof(string), message1.SpaceUsed());
 
875
 
 
876
  // Setting a string in oneof to a value larger than the string object itself
 
877
  // should increase SpaceUsed(), because it cannot store the value internally.
 
878
  message1.set_foo_string(string(sizeof(string) + 1, 'x'));
 
879
  int min_expected_increase = message1.foo_string().capacity() +
 
880
      sizeof(string);
 
881
  EXPECT_LE(empty_message_size + min_expected_increase,
 
882
            message1.SpaceUsed());
 
883
 
 
884
  // Setting a message in oneof should delete the other fields and increase the
 
885
  // size by the size of the nested message type. NestedMessage is simple enough
 
886
  // that it is equal to sizeof(NestedMessage)
 
887
  message1.mutable_foo_message();
 
888
  ASSERT_EQ(sizeof(unittest::TestOneof2::NestedMessage),
 
889
            message1.foo_message().SpaceUsed());
 
890
  EXPECT_EQ(empty_message_size +
 
891
            sizeof(unittest::TestOneof2::NestedMessage),
 
892
            message1.SpaceUsed());
 
893
}
 
894
 
843
895
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
844
896
 
845
897
 
887
939
    case unittest::TestAllTypes::BAZ:
888
940
      i = 3;
889
941
      break;
 
942
    case unittest::TestAllTypes::NEG:
 
943
      i = -1;
 
944
      break;
890
945
    // no default case:  We want to make sure the compiler recognizes that
891
946
    //   all cases are covered.  (GCC warns if you do not cover all cases of
892
947
    //   an enum in a switch.)
915
970
}
916
971
 
917
972
TEST(GeneratedEnumTest, MinAndMax) {
918
 
  EXPECT_EQ(unittest::TestAllTypes::FOO,
 
973
  EXPECT_EQ(unittest::TestAllTypes::NEG,
919
974
            unittest::TestAllTypes::NestedEnum_MIN);
920
975
  EXPECT_EQ(unittest::TestAllTypes::BAZ,
921
976
            unittest::TestAllTypes::NestedEnum_MAX);
989
1044
            GetEnumDescriptor<unittest::TestSparseEnum>());
990
1045
}
991
1046
 
 
1047
enum NonProtoEnum {
 
1048
  kFoo = 1,
 
1049
};
 
1050
 
 
1051
TEST(GeneratedEnumTest, IsProtoEnumTypeTrait) {
 
1052
  EXPECT_TRUE(is_proto_enum<unittest::TestAllTypes::NestedEnum>::value);
 
1053
  EXPECT_TRUE(is_proto_enum<unittest::ForeignEnum>::value);
 
1054
  EXPECT_TRUE(is_proto_enum<unittest::TestEnumWithDupValue>::value);
 
1055
  EXPECT_TRUE(is_proto_enum<unittest::TestSparseEnum>::value);
 
1056
 
 
1057
  EXPECT_FALSE(is_proto_enum<int>::value);
 
1058
  EXPECT_FALSE(is_proto_enum<NonProtoEnum>::value);
 
1059
}
 
1060
 
992
1061
#endif  // PROTOBUF_TEST_NO_DESCRIPTORS
993
1062
 
994
1063
// ===================================================================
1288
1357
  EXPECT_TRUE(controller.called_);
1289
1358
}
1290
1359
 
 
1360
// ===================================================================
 
1361
 
 
1362
class OneofTest : public testing::Test {
 
1363
 protected:
 
1364
  virtual void SetUp() {
 
1365
  }
 
1366
 
 
1367
  void ExpectEnumCasesWork(const unittest::TestOneof2 &message) {
 
1368
    switch (message.foo_case()) {
 
1369
      case unittest::TestOneof2::kFooInt:
 
1370
        EXPECT_TRUE(message.has_foo_int());
 
1371
        break;
 
1372
      case unittest::TestOneof2::kFooString:
 
1373
        EXPECT_TRUE(message.has_foo_string());
 
1374
        break;
 
1375
      case unittest::TestOneof2::kFooBytes:
 
1376
        EXPECT_TRUE(message.has_foo_bytes());
 
1377
        break;
 
1378
      case unittest::TestOneof2::kFooEnum:
 
1379
        EXPECT_TRUE(message.has_foo_enum());
 
1380
        break;
 
1381
      case unittest::TestOneof2::kFooMessage:
 
1382
        EXPECT_TRUE(message.has_foo_message());
 
1383
        break;
 
1384
      case unittest::TestOneof2::kFoogroup:
 
1385
        EXPECT_TRUE(message.has_foogroup());
 
1386
        break;
 
1387
      case unittest::TestOneof2::FOO_NOT_SET:
 
1388
        break;
 
1389
    }
 
1390
  }
 
1391
};
 
1392
 
 
1393
TEST_F(OneofTest, SettingOneFieldClearsOthers) {
 
1394
  unittest::TestOneof2 message;
 
1395
 
 
1396
  message.set_foo_int(123);
 
1397
  EXPECT_TRUE(message.has_foo_int());
 
1398
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1399
 
 
1400
  message.set_foo_string("foo");
 
1401
  EXPECT_TRUE(message.has_foo_string());
 
1402
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1403
 
 
1404
 
 
1405
  message.set_foo_bytes("qux");
 
1406
  EXPECT_TRUE(message.has_foo_bytes());
 
1407
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1408
 
 
1409
  message.set_foo_enum(unittest::TestOneof2::FOO);
 
1410
  EXPECT_TRUE(message.has_foo_enum());
 
1411
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1412
 
 
1413
  message.mutable_foo_message()->set_qux_int(234);
 
1414
  EXPECT_TRUE(message.has_foo_message());
 
1415
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1416
 
 
1417
  message.mutable_foogroup()->set_a(345);
 
1418
  EXPECT_TRUE(message.has_foogroup());
 
1419
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1420
 
 
1421
 
 
1422
  // we repeat this because we didn't test if this properly clears other fields
 
1423
  // at the beginning.
 
1424
  message.set_foo_int(123);
 
1425
  EXPECT_TRUE(message.has_foo_int());
 
1426
  TestUtil::ExpectAtMostOneFieldSetInOneof(message);
 
1427
}
 
1428
 
 
1429
TEST_F(OneofTest, EnumCases) {
 
1430
  unittest::TestOneof2 message;
 
1431
 
 
1432
  message.set_foo_int(123);
 
1433
  ExpectEnumCasesWork(message);
 
1434
  message.set_foo_string("foo");
 
1435
  ExpectEnumCasesWork(message);
 
1436
  message.set_foo_bytes("qux");
 
1437
  ExpectEnumCasesWork(message);
 
1438
  message.set_foo_enum(unittest::TestOneof2::FOO);
 
1439
  ExpectEnumCasesWork(message);
 
1440
  message.mutable_foo_message()->set_qux_int(234);
 
1441
  ExpectEnumCasesWork(message);
 
1442
  message.mutable_foogroup()->set_a(345);
 
1443
  ExpectEnumCasesWork(message);
 
1444
}
 
1445
 
 
1446
TEST_F(OneofTest, PrimitiveType) {
 
1447
  unittest::TestOneof2 message;
 
1448
  // Unset field returns default value
 
1449
  EXPECT_EQ(message.foo_int(), 0);
 
1450
 
 
1451
  message.set_foo_int(123);
 
1452
  EXPECT_TRUE(message.has_foo_int());
 
1453
  EXPECT_EQ(message.foo_int(), 123);
 
1454
  message.clear_foo_int();
 
1455
  EXPECT_FALSE(message.has_foo_int());
 
1456
}
 
1457
 
 
1458
TEST_F(OneofTest, EnumType) {
 
1459
  unittest::TestOneof2 message;
 
1460
  // Unset field returns default value
 
1461
  EXPECT_EQ(message.foo_enum(), 1);
 
1462
 
 
1463
  message.set_foo_enum(unittest::TestOneof2::FOO);
 
1464
  EXPECT_TRUE(message.has_foo_enum());
 
1465
  EXPECT_EQ(message.foo_enum(), unittest::TestOneof2::FOO);
 
1466
  message.clear_foo_enum();
 
1467
  EXPECT_FALSE(message.has_foo_enum());
 
1468
}
 
1469
 
 
1470
TEST_F(OneofTest, SetString) {
 
1471
  // Check that setting a string field in various ways works
 
1472
  unittest::TestOneof2 message;
 
1473
 
 
1474
  // Unset field returns default value
 
1475
  EXPECT_EQ(message.foo_string(), "");
 
1476
 
 
1477
  message.set_foo_string("foo");
 
1478
  EXPECT_TRUE(message.has_foo_string());
 
1479
  EXPECT_EQ(message.foo_string(), "foo");
 
1480
  message.clear_foo_string();
 
1481
  EXPECT_FALSE(message.has_foo_string());
 
1482
 
 
1483
  message.set_foo_string(string("bar"));
 
1484
  EXPECT_TRUE(message.has_foo_string());
 
1485
  EXPECT_EQ(message.foo_string(), "bar");
 
1486
  message.clear_foo_string();
 
1487
  EXPECT_FALSE(message.has_foo_string());
 
1488
 
 
1489
 
 
1490
  message.set_foo_string("qux", 3);
 
1491
  EXPECT_TRUE(message.has_foo_string());
 
1492
  EXPECT_EQ(message.foo_string(), "qux");
 
1493
  message.clear_foo_string();
 
1494
  EXPECT_FALSE(message.has_foo_string());
 
1495
 
 
1496
  message.mutable_foo_string()->assign("quux");
 
1497
  EXPECT_TRUE(message.has_foo_string());
 
1498
  EXPECT_EQ(message.foo_string(), "quux");
 
1499
  message.clear_foo_string();
 
1500
  EXPECT_FALSE(message.has_foo_string());
 
1501
 
 
1502
  message.set_foo_string("corge");
 
1503
  EXPECT_TRUE(message.has_foo_string());
 
1504
  EXPECT_EQ(message.foo_string(), "corge");
 
1505
  message.clear_foo_string();
 
1506
  EXPECT_FALSE(message.has_foo_string());
 
1507
}
 
1508
 
 
1509
TEST_F(OneofTest, ReleaseString) {
 
1510
  // Check that release_foo() starts out NULL, and gives us a value
 
1511
  // that we can delete after it's been set.
 
1512
  unittest::TestOneof2 message;
 
1513
 
 
1514
  EXPECT_EQ(NULL, message.release_foo_string());
 
1515
  EXPECT_FALSE(message.has_foo_string());
 
1516
 
 
1517
  message.set_foo_string("blah");
 
1518
  EXPECT_TRUE(message.has_foo_string());
 
1519
  scoped_ptr<string> str(message.release_foo_string());
 
1520
  EXPECT_FALSE(message.has_foo_string());
 
1521
  ASSERT_TRUE(str != NULL);
 
1522
  EXPECT_EQ("blah", *str);
 
1523
 
 
1524
  EXPECT_EQ(NULL, message.release_foo_string());
 
1525
  EXPECT_FALSE(message.has_foo_string());
 
1526
}
 
1527
 
 
1528
TEST_F(OneofTest, SetAllocatedString) {
 
1529
  // Check that set_allocated_foo() works for strings.
 
1530
  unittest::TestOneof2 message;
 
1531
 
 
1532
  EXPECT_FALSE(message.has_foo_string());
 
1533
  const string kHello("hello");
 
1534
  message.set_foo_string(kHello);
 
1535
  EXPECT_TRUE(message.has_foo_string());
 
1536
 
 
1537
  message.set_allocated_foo_string(NULL);
 
1538
  EXPECT_FALSE(message.has_foo_string());
 
1539
  EXPECT_EQ("", message.foo_string());
 
1540
 
 
1541
  message.set_allocated_foo_string(new string(kHello));
 
1542
  EXPECT_TRUE(message.has_foo_string());
 
1543
  EXPECT_EQ(kHello, message.foo_string());
 
1544
}
 
1545
 
 
1546
 
 
1547
TEST_F(OneofTest, SetMessage) {
 
1548
  // Check that setting a message field works
 
1549
  unittest::TestOneof2 message;
 
1550
 
 
1551
  // Unset field returns default instance
 
1552
  EXPECT_EQ(&message.foo_message(),
 
1553
            &unittest::TestOneof2_NestedMessage::default_instance());
 
1554
  EXPECT_EQ(message.foo_message().qux_int(), 0);
 
1555
 
 
1556
  message.mutable_foo_message()->set_qux_int(234);
 
1557
  EXPECT_TRUE(message.has_foo_message());
 
1558
  EXPECT_EQ(message.foo_message().qux_int(), 234);
 
1559
  message.clear_foo_message();
 
1560
  EXPECT_FALSE(message.has_foo_message());
 
1561
}
 
1562
 
 
1563
TEST_F(OneofTest, ReleaseMessage) {
 
1564
  // Check that release_foo() starts out NULL, and gives us a value
 
1565
  // that we can delete after it's been set.
 
1566
  unittest::TestOneof2 message;
 
1567
 
 
1568
  EXPECT_EQ(NULL, message.release_foo_message());
 
1569
  EXPECT_FALSE(message.has_foo_message());
 
1570
 
 
1571
  message.mutable_foo_message()->set_qux_int(1);
 
1572
  EXPECT_TRUE(message.has_foo_message());
 
1573
  scoped_ptr<unittest::TestOneof2_NestedMessage> mes(
 
1574
      message.release_foo_message());
 
1575
  EXPECT_FALSE(message.has_foo_message());
 
1576
  ASSERT_TRUE(mes != NULL);
 
1577
  EXPECT_EQ(1, mes->qux_int());
 
1578
 
 
1579
  EXPECT_EQ(NULL, message.release_foo_message());
 
1580
  EXPECT_FALSE(message.has_foo_message());
 
1581
}
 
1582
 
 
1583
TEST_F(OneofTest, SetAllocatedMessage) {
 
1584
  // Check that set_allocated_foo() works for messages.
 
1585
  unittest::TestOneof2 message;
 
1586
 
 
1587
  EXPECT_FALSE(message.has_foo_message());
 
1588
 
 
1589
  message.mutable_foo_message()->set_qux_int(1);
 
1590
  EXPECT_TRUE(message.has_foo_message());
 
1591
 
 
1592
  message.set_allocated_foo_message(NULL);
 
1593
  EXPECT_FALSE(message.has_foo_message());
 
1594
  EXPECT_EQ(&message.foo_message(),
 
1595
            &unittest::TestOneof2_NestedMessage::default_instance());
 
1596
 
 
1597
  message.mutable_foo_message()->set_qux_int(1);
 
1598
  unittest::TestOneof2_NestedMessage* mes = message.release_foo_message();
 
1599
  ASSERT_TRUE(mes != NULL);
 
1600
  EXPECT_FALSE(message.has_foo_message());
 
1601
 
 
1602
  message.set_allocated_foo_message(mes);
 
1603
  EXPECT_TRUE(message.has_foo_message());
 
1604
  EXPECT_EQ(1, message.foo_message().qux_int());
 
1605
}
 
1606
 
 
1607
 
 
1608
TEST_F(OneofTest, Clear) {
 
1609
  unittest::TestOneof2 message;
 
1610
 
 
1611
  message.set_foo_int(1);
 
1612
  EXPECT_TRUE(message.has_foo_int());
 
1613
  message.clear_foo_int();
 
1614
  EXPECT_FALSE(message.has_foo_int());
 
1615
}
 
1616
 
 
1617
TEST_F(OneofTest, Defaults) {
 
1618
  unittest::TestOneof2 message;
 
1619
 
 
1620
  EXPECT_FALSE(message.has_foo_int());
 
1621
  EXPECT_EQ(message.foo_int(), 0);
 
1622
 
 
1623
  EXPECT_FALSE(message.has_foo_string());
 
1624
  EXPECT_EQ(message.foo_string(), "");
 
1625
 
 
1626
 
 
1627
  EXPECT_FALSE(message.has_foo_bytes());
 
1628
  EXPECT_EQ(message.foo_bytes(), "");
 
1629
 
 
1630
  EXPECT_FALSE(message.has_foo_enum());
 
1631
  EXPECT_EQ(message.foo_enum(), 1);
 
1632
 
 
1633
  EXPECT_FALSE(message.has_foo_message());
 
1634
  EXPECT_EQ(message.foo_message().qux_int(), 0);
 
1635
 
 
1636
  EXPECT_FALSE(message.has_foogroup());
 
1637
  EXPECT_EQ(message.foogroup().a(), 0);
 
1638
 
 
1639
 
 
1640
  EXPECT_FALSE(message.has_bar_int());
 
1641
  EXPECT_EQ(message.bar_int(), 5);
 
1642
 
 
1643
  EXPECT_FALSE(message.has_bar_string());
 
1644
  EXPECT_EQ(message.bar_string(), "STRING");
 
1645
 
 
1646
 
 
1647
  EXPECT_FALSE(message.has_bar_bytes());
 
1648
  EXPECT_EQ(message.bar_bytes(), "BYTES");
 
1649
 
 
1650
  EXPECT_FALSE(message.has_bar_enum());
 
1651
  EXPECT_EQ(message.bar_enum(), 2);
 
1652
}
 
1653
 
 
1654
TEST_F(OneofTest, SwapWithEmpty) {
 
1655
  unittest::TestOneof2 message1, message2;
 
1656
  message1.set_foo_string("FOO");
 
1657
  EXPECT_TRUE(message1.has_foo_string());
 
1658
  message1.Swap(&message2);
 
1659
  EXPECT_FALSE(message1.has_foo_string());
 
1660
  EXPECT_TRUE(message2.has_foo_string());
 
1661
  EXPECT_EQ(message2.foo_string(), "FOO");
 
1662
}
 
1663
 
 
1664
TEST_F(OneofTest, SwapWithSelf) {
 
1665
  unittest::TestOneof2 message;
 
1666
  message.set_foo_string("FOO");
 
1667
  EXPECT_TRUE(message.has_foo_string());
 
1668
  message.Swap(&message);
 
1669
  EXPECT_TRUE(message.has_foo_string());
 
1670
  EXPECT_EQ(message.foo_string(), "FOO");
 
1671
}
 
1672
 
 
1673
TEST_F(OneofTest, SwapBothHasFields) {
 
1674
  unittest::TestOneof2 message1, message2;
 
1675
 
 
1676
  message1.set_foo_string("FOO");
 
1677
  EXPECT_TRUE(message1.has_foo_string());
 
1678
  message2.mutable_foo_message()->set_qux_int(1);
 
1679
  EXPECT_TRUE(message2.has_foo_message());
 
1680
 
 
1681
  message1.Swap(&message2);
 
1682
  EXPECT_FALSE(message1.has_foo_string());
 
1683
  EXPECT_FALSE(message2.has_foo_message());
 
1684
  EXPECT_TRUE(message1.has_foo_message());
 
1685
  EXPECT_EQ(message1.foo_message().qux_int(), 1);
 
1686
  EXPECT_TRUE(message2.has_foo_string());
 
1687
  EXPECT_EQ(message2.foo_string(), "FOO");
 
1688
}
 
1689
 
 
1690
TEST_F(OneofTest, CopyContructor) {
 
1691
  unittest::TestOneof2 message1;
 
1692
  message1.set_foo_bytes("FOO");
 
1693
 
 
1694
  unittest::TestOneof2 message2(message1);
 
1695
  EXPECT_TRUE(message2.has_foo_bytes());
 
1696
  EXPECT_EQ(message2.foo_bytes(), "FOO");
 
1697
}
 
1698
 
 
1699
TEST_F(OneofTest, CopyFrom) {
 
1700
  unittest::TestOneof2 message1, message2;
 
1701
  message1.set_foo_enum(unittest::TestOneof2::BAR);
 
1702
  EXPECT_TRUE(message1.has_foo_enum());
 
1703
 
 
1704
  message2.CopyFrom(message1);
 
1705
  EXPECT_TRUE(message2.has_foo_enum());
 
1706
  EXPECT_EQ(message2.foo_enum(), unittest::TestOneof2::BAR);
 
1707
 
 
1708
  // Copying from self should be a no-op.
 
1709
  message2.CopyFrom(message2);
 
1710
  EXPECT_TRUE(message2.has_foo_enum());
 
1711
  EXPECT_EQ(message2.foo_enum(), unittest::TestOneof2::BAR);
 
1712
}
 
1713
 
 
1714
TEST_F(OneofTest, CopyAssignmentOperator) {
 
1715
  unittest::TestOneof2 message1;
 
1716
  message1.mutable_foo_message()->set_qux_int(123);
 
1717
  EXPECT_TRUE(message1.has_foo_message());
 
1718
 
 
1719
  unittest::TestOneof2 message2;
 
1720
  message2 = message1;
 
1721
  EXPECT_EQ(message2.foo_message().qux_int(), 123);
 
1722
 
 
1723
  // Make sure that self-assignment does something sane.
 
1724
  message2 = message2;
 
1725
  EXPECT_EQ(message2.foo_message().qux_int(), 123);
 
1726
}
 
1727
 
 
1728
TEST_F(OneofTest, UpcastCopyFrom) {
 
1729
  // Test the CopyFrom method that takes in the generic const Message&
 
1730
  // parameter.
 
1731
  unittest::TestOneof2 message1, message2;
 
1732
  message1.mutable_foogroup()->set_a(123);
 
1733
  EXPECT_TRUE(message1.has_foogroup());
 
1734
 
 
1735
  const Message* source = implicit_cast<const Message*>(&message1);
 
1736
  message2.CopyFrom(*source);
 
1737
 
 
1738
  EXPECT_TRUE(message2.has_foogroup());
 
1739
  EXPECT_EQ(message2.foogroup().a(), 123);
 
1740
}
 
1741
 
 
1742
// Test the generated SerializeWithCachedSizesToArray(),
 
1743
// This indirectly tests MergePartialFromCodedStream()
 
1744
// We have to test each field type separately because we cannot set them at the
 
1745
// same time
 
1746
TEST_F(OneofTest, SerializationToArray) {
 
1747
  // Primitive type
 
1748
  {
 
1749
    unittest::TestOneof2 message1, message2;
 
1750
    string data;
 
1751
    message1.set_foo_int(123);
 
1752
    int size = message1.ByteSize();
 
1753
    data.resize(size);
 
1754
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1755
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1756
    EXPECT_EQ(size, end - start);
 
1757
    EXPECT_TRUE(message2.ParseFromString(data));
 
1758
    EXPECT_EQ(message2.foo_int(), 123);
 
1759
  }
 
1760
 
 
1761
  // String
 
1762
  {
 
1763
    unittest::TestOneof2 message1, message2;
 
1764
    string data;
 
1765
    message1.set_foo_string("foo");
 
1766
    int size = message1.ByteSize();
 
1767
    data.resize(size);
 
1768
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1769
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1770
    EXPECT_EQ(size, end - start);
 
1771
    EXPECT_TRUE(message2.ParseFromString(data));
 
1772
    EXPECT_EQ(message2.foo_string(), "foo");
 
1773
  }
 
1774
 
 
1775
 
 
1776
  // Bytes
 
1777
  {
 
1778
    unittest::TestOneof2 message1, message2;
 
1779
    string data;
 
1780
    message1.set_foo_bytes("qux");
 
1781
    int size = message1.ByteSize();
 
1782
    data.resize(size);
 
1783
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1784
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1785
    EXPECT_EQ(size, end - start);
 
1786
    EXPECT_TRUE(message2.ParseFromString(data));
 
1787
    EXPECT_EQ(message2.foo_bytes(), "qux");
 
1788
  }
 
1789
 
 
1790
  // Enum
 
1791
  {
 
1792
    unittest::TestOneof2 message1, message2;
 
1793
    string data;
 
1794
    message1.set_foo_enum(unittest::TestOneof2::FOO);
 
1795
    int size = message1.ByteSize();
 
1796
    data.resize(size);
 
1797
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1798
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1799
    EXPECT_EQ(size, end - start);
 
1800
    EXPECT_TRUE(message2.ParseFromString(data));
 
1801
    EXPECT_EQ(message2.foo_enum(), unittest::TestOneof2::FOO);
 
1802
  }
 
1803
 
 
1804
  // Message
 
1805
  {
 
1806
    unittest::TestOneof2 message1, message2;
 
1807
    string data;
 
1808
    message1.mutable_foo_message()->set_qux_int(234);
 
1809
    int size = message1.ByteSize();
 
1810
    data.resize(size);
 
1811
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1812
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1813
    EXPECT_EQ(size, end - start);
 
1814
    EXPECT_TRUE(message2.ParseFromString(data));
 
1815
    EXPECT_EQ(message2.foo_message().qux_int(), 234);
 
1816
  }
 
1817
 
 
1818
  // Group
 
1819
  {
 
1820
    unittest::TestOneof2 message1, message2;
 
1821
    string data;
 
1822
    message1.mutable_foogroup()->set_a(345);
 
1823
    int size = message1.ByteSize();
 
1824
    data.resize(size);
 
1825
    uint8* start = reinterpret_cast<uint8*>(string_as_array(&data));
 
1826
    uint8* end = message1.SerializeWithCachedSizesToArray(start);
 
1827
    EXPECT_EQ(size, end - start);
 
1828
    EXPECT_TRUE(message2.ParseFromString(data));
 
1829
    EXPECT_EQ(message2.foogroup().a(), 345);
 
1830
  }
 
1831
 
 
1832
}
 
1833
 
 
1834
// Test the generated SerializeWithCachedSizes() by forcing the buffer to write
 
1835
// one byte at a time.
 
1836
// This indirectly tests MergePartialFromCodedStream()
 
1837
// We have to test each field type separately because we cannot set them at the
 
1838
// same time
 
1839
TEST_F(OneofTest, SerializationToStream) {
 
1840
  // Primitive type
 
1841
  {
 
1842
    unittest::TestOneof2 message1, message2;
 
1843
    string data;
 
1844
    message1.set_foo_int(123);
 
1845
    int size = message1.ByteSize();
 
1846
    data.resize(size);
 
1847
 
 
1848
    {
 
1849
      // Allow the output stream to buffer only one byte at a time.
 
1850
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1851
      io::CodedOutputStream output_stream(&array_stream);
 
1852
      message1.SerializeWithCachedSizes(&output_stream);
 
1853
      EXPECT_FALSE(output_stream.HadError());
 
1854
      EXPECT_EQ(size, output_stream.ByteCount());
 
1855
    }
 
1856
 
 
1857
    EXPECT_TRUE(message2.ParseFromString(data));
 
1858
    EXPECT_EQ(message2.foo_int(), 123);
 
1859
  }
 
1860
 
 
1861
  // String
 
1862
  {
 
1863
    unittest::TestOneof2 message1, message2;
 
1864
    string data;
 
1865
    message1.set_foo_string("foo");
 
1866
    int size = message1.ByteSize();
 
1867
    data.resize(size);
 
1868
 
 
1869
    {
 
1870
      // Allow the output stream to buffer only one byte at a time.
 
1871
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1872
      io::CodedOutputStream output_stream(&array_stream);
 
1873
      message1.SerializeWithCachedSizes(&output_stream);
 
1874
      EXPECT_FALSE(output_stream.HadError());
 
1875
      EXPECT_EQ(size, output_stream.ByteCount());
 
1876
    }
 
1877
 
 
1878
    EXPECT_TRUE(message2.ParseFromString(data));
 
1879
    EXPECT_EQ(message2.foo_string(), "foo");
 
1880
  }
 
1881
 
 
1882
 
 
1883
  // Bytes
 
1884
  {
 
1885
    unittest::TestOneof2 message1, message2;
 
1886
    string data;
 
1887
    message1.set_foo_bytes("qux");
 
1888
    int size = message1.ByteSize();
 
1889
    data.resize(size);
 
1890
 
 
1891
    {
 
1892
      // Allow the output stream to buffer only one byte at a time.
 
1893
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1894
      io::CodedOutputStream output_stream(&array_stream);
 
1895
      message1.SerializeWithCachedSizes(&output_stream);
 
1896
      EXPECT_FALSE(output_stream.HadError());
 
1897
      EXPECT_EQ(size, output_stream.ByteCount());
 
1898
    }
 
1899
 
 
1900
    EXPECT_TRUE(message2.ParseFromString(data));
 
1901
    EXPECT_EQ(message2.foo_bytes(), "qux");
 
1902
  }
 
1903
 
 
1904
  // Enum
 
1905
  {
 
1906
    unittest::TestOneof2 message1, message2;
 
1907
    string data;
 
1908
    message1.set_foo_enum(unittest::TestOneof2::FOO);
 
1909
    int size = message1.ByteSize();
 
1910
    data.resize(size);
 
1911
 
 
1912
    {
 
1913
      // Allow the output stream to buffer only one byte at a time.
 
1914
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1915
      io::CodedOutputStream output_stream(&array_stream);
 
1916
      message1.SerializeWithCachedSizes(&output_stream);
 
1917
      EXPECT_FALSE(output_stream.HadError());
 
1918
      EXPECT_EQ(size, output_stream.ByteCount());
 
1919
    }
 
1920
 
 
1921
    EXPECT_TRUE(message2.ParseFromString(data));
 
1922
    EXPECT_EQ(message2.foo_enum(), unittest::TestOneof2::FOO);
 
1923
  }
 
1924
 
 
1925
  // Message
 
1926
  {
 
1927
    unittest::TestOneof2 message1, message2;
 
1928
    string data;
 
1929
    message1.mutable_foo_message()->set_qux_int(234);
 
1930
    int size = message1.ByteSize();
 
1931
    data.resize(size);
 
1932
 
 
1933
    {
 
1934
      // Allow the output stream to buffer only one byte at a time.
 
1935
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1936
      io::CodedOutputStream output_stream(&array_stream);
 
1937
      message1.SerializeWithCachedSizes(&output_stream);
 
1938
      EXPECT_FALSE(output_stream.HadError());
 
1939
      EXPECT_EQ(size, output_stream.ByteCount());
 
1940
    }
 
1941
 
 
1942
    EXPECT_TRUE(message2.ParseFromString(data));
 
1943
    EXPECT_EQ(message2.foo_message().qux_int(), 234);
 
1944
  }
 
1945
 
 
1946
  // Group
 
1947
  {
 
1948
    unittest::TestOneof2 message1, message2;
 
1949
    string data;
 
1950
    message1.mutable_foogroup()->set_a(345);
 
1951
    int size = message1.ByteSize();
 
1952
    data.resize(size);
 
1953
 
 
1954
    {
 
1955
      // Allow the output stream to buffer only one byte at a time.
 
1956
      io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
 
1957
      io::CodedOutputStream output_stream(&array_stream);
 
1958
      message1.SerializeWithCachedSizes(&output_stream);
 
1959
      EXPECT_FALSE(output_stream.HadError());
 
1960
      EXPECT_EQ(size, output_stream.ByteCount());
 
1961
    }
 
1962
 
 
1963
    EXPECT_TRUE(message2.ParseFromString(data));
 
1964
    EXPECT_EQ(message2.foogroup().a(), 345);
 
1965
  }
 
1966
 
 
1967
}
 
1968
 
 
1969
TEST_F(OneofTest, MergeFrom) {
 
1970
  unittest::TestOneof2 message1, message2;
 
1971
 
 
1972
  message1.set_foo_int(123);
 
1973
  message2.MergeFrom(message1);
 
1974
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
1975
  EXPECT_TRUE(message2.has_foo_int());
 
1976
  EXPECT_EQ(message2.foo_int(), 123);
 
1977
 
 
1978
  message1.set_foo_string("foo");
 
1979
  message2.MergeFrom(message1);
 
1980
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
1981
  EXPECT_TRUE(message2.has_foo_string());
 
1982
  EXPECT_EQ(message2.foo_string(), "foo");
 
1983
 
 
1984
 
 
1985
  message1.set_foo_bytes("qux");
 
1986
  message2.MergeFrom(message1);
 
1987
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
1988
  EXPECT_TRUE(message2.has_foo_bytes());
 
1989
  EXPECT_EQ(message2.foo_bytes(), "qux");
 
1990
 
 
1991
  message1.set_foo_enum(unittest::TestOneof2::FOO);
 
1992
  message2.MergeFrom(message1);
 
1993
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
1994
  EXPECT_TRUE(message2.has_foo_enum());
 
1995
  EXPECT_EQ(message2.foo_enum(), unittest::TestOneof2::FOO);
 
1996
 
 
1997
  message1.mutable_foo_message()->set_qux_int(234);
 
1998
  message2.MergeFrom(message1);
 
1999
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
2000
  EXPECT_TRUE(message2.has_foo_message());
 
2001
  EXPECT_EQ(message2.foo_message().qux_int(), 234);
 
2002
 
 
2003
  message1.mutable_foogroup()->set_a(345);
 
2004
  message2.MergeFrom(message1);
 
2005
  TestUtil::ExpectAtMostOneFieldSetInOneof(message2);
 
2006
  EXPECT_TRUE(message2.has_foogroup());
 
2007
  EXPECT_EQ(message2.foogroup().a(), 345);
 
2008
 
 
2009
}
 
2010
 
1291
2011
}  // namespace cpp_unittest
1292
2012
}  // namespace cpp
1293
2013
}  // namespace compiler