← Back to branch summary

~statik/ubuntu/maverick/protobuf/A

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2010-02-11 11:13:19 UTC
  • mfrom: (2.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100211111319-zdn8hmw0gh8s4cf8
Tags: 2.2.0a-0.1ubuntu1
* Merge from Debian testing.
* Remaining Ubuntu changes:
  - Don't use python2.4.
* Ubuntu changes dropped:
  - Disable death tests on Itanium, fixed upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/test_util.cc
33
33
//  Sanjay Ghemawat, Jeff Dean, and others.
34
34
 
35
35
#ifdef _WIN32
36
 
// Verify that #icnluding windows.h does not break anything (e.g. because
 
36
// Verify that #including windows.h does not break anything (e.g. because
37
37
// windows.h #defines GetMessage() as a macro).
38
38
#include <windows.h>
39
39
#endif
86
86
    message,
87
87
    message->GetDescriptor()->FindFieldByName("optional_cord"),
88
88
    "125");
89
 
#endif
 
89
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
90
90
 
91
91
  // -----------------------------------------------------------------
92
92
 
124
124
    message,
125
125
    message->GetDescriptor()->FindFieldByName("repeated_cord"),
126
126
    "225");
127
 
#endif
 
127
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
128
128
 
129
129
  // Add a second one of each field.
130
130
  message->add_repeated_int32   (301);
161
161
    message,
162
162
    message->GetDescriptor()->FindFieldByName("repeated_cord"),
163
163
    "325");
164
 
#endif
 
164
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
165
165
 
166
166
  // -----------------------------------------------------------------
167
167
 
194
194
    message,
195
195
    message->GetDescriptor()->FindFieldByName("default_cord"),
196
196
    "425");
197
 
#endif
 
197
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
198
198
}
199
199
 
200
200
// -------------------------------------------------------------------
234
234
    message,
235
235
    message->GetDescriptor()->FindFieldByName("repeated_cord"),
236
236
    1, "425");
237
 
#endif
 
237
#endif  // !PROTOBUF_TEST_NO_DESCRIPTORS
238
238
}
239
239
 
240
240
// -------------------------------------------------------------------
1644
1644
  EXPECT_TRUE(serialized == expected);
1645
1645
}
1646
1646
 
 
1647
void TestUtil::ExpectLastRepeatedsRemoved(
 
1648
    const unittest::TestAllTypes& message) {
 
1649
  ASSERT_EQ(1, message.repeated_int32_size   ());
 
1650
  ASSERT_EQ(1, message.repeated_int64_size   ());
 
1651
  ASSERT_EQ(1, message.repeated_uint32_size  ());
 
1652
  ASSERT_EQ(1, message.repeated_uint64_size  ());
 
1653
  ASSERT_EQ(1, message.repeated_sint32_size  ());
 
1654
  ASSERT_EQ(1, message.repeated_sint64_size  ());
 
1655
  ASSERT_EQ(1, message.repeated_fixed32_size ());
 
1656
  ASSERT_EQ(1, message.repeated_fixed64_size ());
 
1657
  ASSERT_EQ(1, message.repeated_sfixed32_size());
 
1658
  ASSERT_EQ(1, message.repeated_sfixed64_size());
 
1659
  ASSERT_EQ(1, message.repeated_float_size   ());
 
1660
  ASSERT_EQ(1, message.repeated_double_size  ());
 
1661
  ASSERT_EQ(1, message.repeated_bool_size    ());
 
1662
  ASSERT_EQ(1, message.repeated_string_size  ());
 
1663
  ASSERT_EQ(1, message.repeated_bytes_size   ());
 
1664
 
 
1665
  ASSERT_EQ(1, message.repeatedgroup_size           ());
 
1666
  ASSERT_EQ(1, message.repeated_nested_message_size ());
 
1667
  ASSERT_EQ(1, message.repeated_foreign_message_size());
 
1668
  ASSERT_EQ(1, message.repeated_import_message_size ());
 
1669
  ASSERT_EQ(1, message.repeated_nested_enum_size    ());
 
1670
  ASSERT_EQ(1, message.repeated_foreign_enum_size   ());
 
1671
  ASSERT_EQ(1, message.repeated_import_enum_size    ());
 
1672
 
 
1673
#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
 
1674
  ASSERT_EQ(1, message.repeated_string_piece_size());
 
1675
  ASSERT_EQ(1, message.repeated_cord_size());
 
1676
#endif
 
1677
 
 
1678
  // Test that the remaining element is the correct one.
 
1679
  EXPECT_EQ(201  , message.repeated_int32   (0));
 
1680
  EXPECT_EQ(202  , message.repeated_int64   (0));
 
1681
  EXPECT_EQ(203  , message.repeated_uint32  (0));
 
1682
  EXPECT_EQ(204  , message.repeated_uint64  (0));
 
1683
  EXPECT_EQ(205  , message.repeated_sint32  (0));
 
1684
  EXPECT_EQ(206  , message.repeated_sint64  (0));
 
1685
  EXPECT_EQ(207  , message.repeated_fixed32 (0));
 
1686
  EXPECT_EQ(208  , message.repeated_fixed64 (0));
 
1687
  EXPECT_EQ(209  , message.repeated_sfixed32(0));
 
1688
  EXPECT_EQ(210  , message.repeated_sfixed64(0));
 
1689
  EXPECT_EQ(211  , message.repeated_float   (0));
 
1690
  EXPECT_EQ(212  , message.repeated_double  (0));
 
1691
  EXPECT_EQ(true , message.repeated_bool    (0));
 
1692
  EXPECT_EQ("215", message.repeated_string  (0));
 
1693
  EXPECT_EQ("216", message.repeated_bytes   (0));
 
1694
 
 
1695
  EXPECT_EQ(217, message.repeatedgroup           (0).a());
 
1696
  EXPECT_EQ(218, message.repeated_nested_message (0).bb());
 
1697
  EXPECT_EQ(219, message.repeated_foreign_message(0).c());
 
1698
  EXPECT_EQ(220, message.repeated_import_message (0).d());
 
1699
 
 
1700
  EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (0));
 
1701
  EXPECT_EQ(unittest::FOREIGN_BAR      , message.repeated_foreign_enum(0));
 
1702
  EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (0));
 
1703
}
 
1704
 
 
1705
void TestUtil::ExpectLastRepeatedExtensionsRemoved(
 
1706
    const unittest::TestAllExtensions& message) {
 
1707
 
 
1708
  // Test that one element was removed.
 
1709
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int32_extension   ));
 
1710
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_int64_extension   ));
 
1711
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint32_extension  ));
 
1712
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_uint64_extension  ));
 
1713
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint32_extension  ));
 
1714
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sint64_extension  ));
 
1715
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed32_extension ));
 
1716
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_fixed64_extension ));
 
1717
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed32_extension));
 
1718
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_sfixed64_extension));
 
1719
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_float_extension   ));
 
1720
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_double_extension  ));
 
1721
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bool_extension    ));
 
1722
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_extension  ));
 
1723
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_bytes_extension   ));
 
1724
 
 
1725
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeatedgroup_extension           ));
 
1726
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_message_extension ));
 
1727
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_message_extension));
 
1728
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_message_extension ));
 
1729
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_nested_enum_extension    ));
 
1730
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_foreign_enum_extension   ));
 
1731
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_import_enum_extension    ));
 
1732
 
 
1733
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_piece_extension));
 
1734
  ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_cord_extension));
 
1735
 
 
1736
  // Test that the remaining element is the correct one.
 
1737
  EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension   , 0));
 
1738
  EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension   , 0));
 
1739
  EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension  , 0));
 
1740
  EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension  , 0));
 
1741
  EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension  , 0));
 
1742
  EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension  , 0));
 
1743
  EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension , 0));
 
1744
  EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension , 0));
 
1745
  EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
 
1746
  EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
 
1747
  EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension   , 0));
 
1748
  EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension  , 0));
 
1749
  EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension    , 0));
 
1750
  EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension  , 0));
 
1751
  EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension   , 0));
 
1752
 
 
1753
  EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension           , 0).a());
 
1754
  EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
 
1755
  EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
 
1756
  EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
 
1757
 
 
1758
  EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
 
1759
  EXPECT_EQ(unittest::FOREIGN_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
 
1760
  EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 0));
 
1761
 
 
1762
  EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 0));
 
1763
  EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 0));
 
1764
}
 
1765
 
 
1766
void TestUtil::ExpectRepeatedsSwapped(
 
1767
    const unittest::TestAllTypes& message) {
 
1768
  ASSERT_EQ(2, message.repeated_int32_size   ());
 
1769
  ASSERT_EQ(2, message.repeated_int64_size   ());
 
1770
  ASSERT_EQ(2, message.repeated_uint32_size  ());
 
1771
  ASSERT_EQ(2, message.repeated_uint64_size  ());
 
1772
  ASSERT_EQ(2, message.repeated_sint32_size  ());
 
1773
  ASSERT_EQ(2, message.repeated_sint64_size  ());
 
1774
  ASSERT_EQ(2, message.repeated_fixed32_size ());
 
1775
  ASSERT_EQ(2, message.repeated_fixed64_size ());
 
1776
  ASSERT_EQ(2, message.repeated_sfixed32_size());
 
1777
  ASSERT_EQ(2, message.repeated_sfixed64_size());
 
1778
  ASSERT_EQ(2, message.repeated_float_size   ());
 
1779
  ASSERT_EQ(2, message.repeated_double_size  ());
 
1780
  ASSERT_EQ(2, message.repeated_bool_size    ());
 
1781
  ASSERT_EQ(2, message.repeated_string_size  ());
 
1782
  ASSERT_EQ(2, message.repeated_bytes_size   ());
 
1783
 
 
1784
  ASSERT_EQ(2, message.repeatedgroup_size           ());
 
1785
  ASSERT_EQ(2, message.repeated_nested_message_size ());
 
1786
  ASSERT_EQ(2, message.repeated_foreign_message_size());
 
1787
  ASSERT_EQ(2, message.repeated_import_message_size ());
 
1788
  ASSERT_EQ(2, message.repeated_nested_enum_size    ());
 
1789
  ASSERT_EQ(2, message.repeated_foreign_enum_size   ());
 
1790
  ASSERT_EQ(2, message.repeated_import_enum_size    ());
 
1791
 
 
1792
#ifndef PROTOBUF_TEST_NO_DESCRIPTORS
 
1793
  ASSERT_EQ(2, message.repeated_string_piece_size());
 
1794
  ASSERT_EQ(2, message.repeated_cord_size());
 
1795
#endif
 
1796
 
 
1797
  // Test that the first element and second element are flipped.
 
1798
  EXPECT_EQ(201  , message.repeated_int32   (1));
 
1799
  EXPECT_EQ(202  , message.repeated_int64   (1));
 
1800
  EXPECT_EQ(203  , message.repeated_uint32  (1));
 
1801
  EXPECT_EQ(204  , message.repeated_uint64  (1));
 
1802
  EXPECT_EQ(205  , message.repeated_sint32  (1));
 
1803
  EXPECT_EQ(206  , message.repeated_sint64  (1));
 
1804
  EXPECT_EQ(207  , message.repeated_fixed32 (1));
 
1805
  EXPECT_EQ(208  , message.repeated_fixed64 (1));
 
1806
  EXPECT_EQ(209  , message.repeated_sfixed32(1));
 
1807
  EXPECT_EQ(210  , message.repeated_sfixed64(1));
 
1808
  EXPECT_EQ(211  , message.repeated_float   (1));
 
1809
  EXPECT_EQ(212  , message.repeated_double  (1));
 
1810
  EXPECT_EQ(true , message.repeated_bool    (1));
 
1811
  EXPECT_EQ("215", message.repeated_string  (1));
 
1812
  EXPECT_EQ("216", message.repeated_bytes   (1));
 
1813
 
 
1814
  EXPECT_EQ(217, message.repeatedgroup           (1).a());
 
1815
  EXPECT_EQ(218, message.repeated_nested_message (1).bb());
 
1816
  EXPECT_EQ(219, message.repeated_foreign_message(1).c());
 
1817
  EXPECT_EQ(220, message.repeated_import_message (1).d());
 
1818
 
 
1819
  EXPECT_EQ(unittest::TestAllTypes::BAR, message.repeated_nested_enum (1));
 
1820
  EXPECT_EQ(unittest::FOREIGN_BAR      , message.repeated_foreign_enum(1));
 
1821
  EXPECT_EQ(unittest_import::IMPORT_BAR, message.repeated_import_enum (1));
 
1822
 
 
1823
  EXPECT_EQ(301  , message.repeated_int32   (0));
 
1824
  EXPECT_EQ(302  , message.repeated_int64   (0));
 
1825
  EXPECT_EQ(303  , message.repeated_uint32  (0));
 
1826
  EXPECT_EQ(304  , message.repeated_uint64  (0));
 
1827
  EXPECT_EQ(305  , message.repeated_sint32  (0));
 
1828
  EXPECT_EQ(306  , message.repeated_sint64  (0));
 
1829
  EXPECT_EQ(307  , message.repeated_fixed32 (0));
 
1830
  EXPECT_EQ(308  , message.repeated_fixed64 (0));
 
1831
  EXPECT_EQ(309  , message.repeated_sfixed32(0));
 
1832
  EXPECT_EQ(310  , message.repeated_sfixed64(0));
 
1833
  EXPECT_EQ(311  , message.repeated_float   (0));
 
1834
  EXPECT_EQ(312  , message.repeated_double  (0));
 
1835
  EXPECT_EQ(false, message.repeated_bool    (0));
 
1836
  EXPECT_EQ("315", message.repeated_string  (0));
 
1837
  EXPECT_EQ("316", message.repeated_bytes   (0));
 
1838
 
 
1839
  EXPECT_EQ(317, message.repeatedgroup           (0).a());
 
1840
  EXPECT_EQ(318, message.repeated_nested_message (0).bb());
 
1841
  EXPECT_EQ(319, message.repeated_foreign_message(0).c());
 
1842
  EXPECT_EQ(320, message.repeated_import_message (0).d());
 
1843
 
 
1844
  EXPECT_EQ(unittest::TestAllTypes::BAZ, message.repeated_nested_enum (0));
 
1845
  EXPECT_EQ(unittest::FOREIGN_BAZ      , message.repeated_foreign_enum(0));
 
1846
  EXPECT_EQ(unittest_import::IMPORT_BAZ, message.repeated_import_enum (0));
 
1847
}
 
1848
 
 
1849
void TestUtil::ExpectRepeatedExtensionsSwapped(
 
1850
    const unittest::TestAllExtensions& message) {
 
1851
 
 
1852
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension   ));
 
1853
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension   ));
 
1854
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension  ));
 
1855
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension  ));
 
1856
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension  ));
 
1857
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension  ));
 
1858
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed32_extension ));
 
1859
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_fixed64_extension ));
 
1860
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed32_extension));
 
1861
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sfixed64_extension));
 
1862
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension   ));
 
1863
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension  ));
 
1864
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension    ));
 
1865
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension  ));
 
1866
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension   ));
 
1867
 
 
1868
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension           ));
 
1869
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_message_extension ));
 
1870
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_message_extension));
 
1871
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_message_extension ));
 
1872
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_nested_enum_extension    ));
 
1873
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_foreign_enum_extension   ));
 
1874
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_import_enum_extension    ));
 
1875
 
 
1876
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_piece_extension));
 
1877
  ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_cord_extension));
 
1878
 
 
1879
  EXPECT_EQ(201  , message.GetExtension(unittest::repeated_int32_extension   , 1));
 
1880
  EXPECT_EQ(202  , message.GetExtension(unittest::repeated_int64_extension   , 1));
 
1881
  EXPECT_EQ(203  , message.GetExtension(unittest::repeated_uint32_extension  , 1));
 
1882
  EXPECT_EQ(204  , message.GetExtension(unittest::repeated_uint64_extension  , 1));
 
1883
  EXPECT_EQ(205  , message.GetExtension(unittest::repeated_sint32_extension  , 1));
 
1884
  EXPECT_EQ(206  , message.GetExtension(unittest::repeated_sint64_extension  , 1));
 
1885
  EXPECT_EQ(207  , message.GetExtension(unittest::repeated_fixed32_extension , 1));
 
1886
  EXPECT_EQ(208  , message.GetExtension(unittest::repeated_fixed64_extension , 1));
 
1887
  EXPECT_EQ(209  , message.GetExtension(unittest::repeated_sfixed32_extension, 1));
 
1888
  EXPECT_EQ(210  , message.GetExtension(unittest::repeated_sfixed64_extension, 1));
 
1889
  EXPECT_EQ(211  , message.GetExtension(unittest::repeated_float_extension   , 1));
 
1890
  EXPECT_EQ(212  , message.GetExtension(unittest::repeated_double_extension  , 1));
 
1891
  EXPECT_EQ(true , message.GetExtension(unittest::repeated_bool_extension    , 1));
 
1892
  EXPECT_EQ("215", message.GetExtension(unittest::repeated_string_extension  , 1));
 
1893
  EXPECT_EQ("216", message.GetExtension(unittest::repeated_bytes_extension   , 1));
 
1894
 
 
1895
  EXPECT_EQ(217, message.GetExtension(unittest::repeatedgroup_extension           , 1).a());
 
1896
  EXPECT_EQ(218, message.GetExtension(unittest::repeated_nested_message_extension , 1).bb());
 
1897
  EXPECT_EQ(219, message.GetExtension(unittest::repeated_foreign_message_extension, 1).c());
 
1898
  EXPECT_EQ(220, message.GetExtension(unittest::repeated_import_message_extension , 1).d());
 
1899
 
 
1900
  EXPECT_EQ(unittest::TestAllTypes::BAR, message.GetExtension(unittest::repeated_nested_enum_extension , 1));
 
1901
  EXPECT_EQ(unittest::FOREIGN_BAR      , message.GetExtension(unittest::repeated_foreign_enum_extension, 1));
 
1902
  EXPECT_EQ(unittest_import::IMPORT_BAR, message.GetExtension(unittest::repeated_import_enum_extension , 1));
 
1903
 
 
1904
  EXPECT_EQ("224", message.GetExtension(unittest::repeated_string_piece_extension, 1));
 
1905
  EXPECT_EQ("225", message.GetExtension(unittest::repeated_cord_extension, 1));
 
1906
 
 
1907
  EXPECT_EQ(301  , message.GetExtension(unittest::repeated_int32_extension   , 0));
 
1908
  EXPECT_EQ(302  , message.GetExtension(unittest::repeated_int64_extension   , 0));
 
1909
  EXPECT_EQ(303  , message.GetExtension(unittest::repeated_uint32_extension  , 0));
 
1910
  EXPECT_EQ(304  , message.GetExtension(unittest::repeated_uint64_extension  , 0));
 
1911
  EXPECT_EQ(305  , message.GetExtension(unittest::repeated_sint32_extension  , 0));
 
1912
  EXPECT_EQ(306  , message.GetExtension(unittest::repeated_sint64_extension  , 0));
 
1913
  EXPECT_EQ(307  , message.GetExtension(unittest::repeated_fixed32_extension , 0));
 
1914
  EXPECT_EQ(308  , message.GetExtension(unittest::repeated_fixed64_extension , 0));
 
1915
  EXPECT_EQ(309  , message.GetExtension(unittest::repeated_sfixed32_extension, 0));
 
1916
  EXPECT_EQ(310  , message.GetExtension(unittest::repeated_sfixed64_extension, 0));
 
1917
  EXPECT_EQ(311  , message.GetExtension(unittest::repeated_float_extension   , 0));
 
1918
  EXPECT_EQ(312  , message.GetExtension(unittest::repeated_double_extension  , 0));
 
1919
  EXPECT_EQ(false, message.GetExtension(unittest::repeated_bool_extension    , 0));
 
1920
  EXPECT_EQ("315", message.GetExtension(unittest::repeated_string_extension  , 0));
 
1921
  EXPECT_EQ("316", message.GetExtension(unittest::repeated_bytes_extension   , 0));
 
1922
 
 
1923
  EXPECT_EQ(317, message.GetExtension(unittest::repeatedgroup_extension           , 0).a());
 
1924
  EXPECT_EQ(318, message.GetExtension(unittest::repeated_nested_message_extension , 0).bb());
 
1925
  EXPECT_EQ(319, message.GetExtension(unittest::repeated_foreign_message_extension, 0).c());
 
1926
  EXPECT_EQ(320, message.GetExtension(unittest::repeated_import_message_extension , 0).d());
 
1927
 
 
1928
  EXPECT_EQ(unittest::TestAllTypes::BAZ, message.GetExtension(unittest::repeated_nested_enum_extension , 0));
 
1929
  EXPECT_EQ(unittest::FOREIGN_BAZ      , message.GetExtension(unittest::repeated_foreign_enum_extension, 0));
 
1930
  EXPECT_EQ(unittest_import::IMPORT_BAZ, message.GetExtension(unittest::repeated_import_enum_extension , 0));
 
1931
 
 
1932
  EXPECT_EQ("324", message.GetExtension(unittest::repeated_string_piece_extension, 0));
 
1933
  EXPECT_EQ("325", message.GetExtension(unittest::repeated_cord_extension, 0));
 
1934
}
 
1935
 
1647
1936
// ===================================================================
1648
1937
 
1649
1938
TestUtil::ReflectionTester::ReflectionTester(
2451
2740
  reflection->SetRepeatedEnum  (message, F("packed_enum"    ), 1, foreign_foo_);
2452
2741
}
2453
2742
 
 
2743
void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection(Message* message) {
 
2744
  const Reflection* reflection = message->GetReflection();
 
2745
 
 
2746
  vector<const FieldDescriptor*> output;
 
2747
  reflection->ListFields(*message, &output);
 
2748
  for (int i=0; i<output.size(); ++i) {
 
2749
    const FieldDescriptor* field = output[i];
 
2750
    if (!field->is_repeated()) continue;
 
2751
 
 
2752
    reflection->RemoveLast(message, field);
 
2753
  }
 
2754
}
 
2755
 
 
2756
void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(Message* message) {
 
2757
  const Reflection* reflection = message->GetReflection();
 
2758
 
 
2759
  vector<const FieldDescriptor*> output;
 
2760
  reflection->ListFields(*message, &output);
 
2761
  for (int i=0; i<output.size(); ++i) {
 
2762
    const FieldDescriptor* field = output[i];
 
2763
    if (!field->is_repeated()) continue;
 
2764
 
 
2765
    reflection->SwapElements(message, field, 0, 1);
 
2766
  }
 
2767
}
 
2768
 
2454
2769
}  // namespace protobuf
2455
2770
}  // namespace google