zhaobu
/
zhujimajiang_redis
1
0
複製 0
程式碼 問題 0 合併請求 0 版本發佈 0 Wiki 活動
诸暨麻将添加redis
您不能選擇超過 %s 個話題 話題必須以字母或數字為開頭，可包含連接號 ('-') 且最長為 35 個字
22 提交
2 分支
57 MiB
 
 
 
 
 
 
目錄樹: 2e0886e77f
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 '2e0886e77f'
${ noResults }
zhujimajiang_redis/俱乐部/Source/Protobuf/google/protobuf/test_util_lite.cc

1971 行
92 KiB
原始文件 Blame 歷史記錄 

  1. // Protocol Buffers - Google's data interchange format

  2. // Copyright 2008 Google Inc.  All rights reserved.

  3. // https://developers.google.com/protocol-buffers/

  4. //

  5. // Redistribution and use in source and binary forms, with or without

  6. // modification, are permitted provided that the following conditions are

  7. // met:

  8. //

  9. //     * Redistributions of source code must retain the above copyright

  10. // notice, this list of conditions and the following disclaimer.

  11. //     * Redistributions in binary form must reproduce the above

  12. // copyright notice, this list of conditions and the following disclaimer

  13. // in the documentation and/or other materials provided with the

  14. // distribution.

  15. //     * Neither the name of Google Inc. nor the names of its

  16. // contributors may be used to endorse or promote products derived from

  17. // this software without specific prior written permission.

  18. //

  19. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

  20. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

  21. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

  22. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

  23. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  24. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  25. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

  26. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

  27. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

  28. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  29. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  30. 

  31. // Author: kenton@google.com (Kenton Varda)

  32. //  Based on original Protocol Buffers design by

  33. //  Sanjay Ghemawat, Jeff Dean, and others.

  34. 

  35. #include <google/protobuf/test_util_lite.h>

  36. 

  37. #include <google/protobuf/stubs/logging.h>

  38. #include <google/protobuf/stubs/common.h>

  39. #include <gtest/gtest.h>

  40. #include <google/protobuf/stubs/strutil.h>

  41. 

  42. namespace google {

  43. namespace protobuf {

  44. 

  45. void TestUtilLite::SetAllFields(unittest::TestAllTypesLite* message) {

  46.   message->set_optional_int32(101);

  47.   message->set_optional_int64(102);

  48.   message->set_optional_uint32(103);

  49.   message->set_optional_uint64(104);

  50.   message->set_optional_sint32(105);

  51.   message->set_optional_sint64(106);

  52.   message->set_optional_fixed32(107);

  53.   message->set_optional_fixed64(108);

  54.   message->set_optional_sfixed32(109);

  55.   message->set_optional_sfixed64(110);

  56.   message->set_optional_float(111);

  57.   message->set_optional_double(112);

  58.   message->set_optional_bool(true);

  59.   message->set_optional_string("115");

  60.   message->set_optional_bytes("116");

  61. 

  62.   message->mutable_optionalgroup()->set_a(117);

  63.   message->mutable_optional_nested_message()->set_bb(118);

  64.   message->mutable_optional_foreign_message()->set_c(119);

  65.   message->mutable_optional_import_message()->set_d(120);

  66.   message->mutable_optional_public_import_message()->set_e(126);

  67.   message->mutable_optional_lazy_message()->set_bb(127);

  68. 

  69.   message->set_optional_nested_enum(unittest::TestAllTypesLite::BAZ);

  70.   message->set_optional_foreign_enum(unittest::FOREIGN_LITE_BAZ);

  71.   message->set_optional_import_enum(unittest_import::IMPORT_LITE_BAZ);

  72. 

  73. 

  74.   // -----------------------------------------------------------------

  75. 

  76.   message->add_repeated_int32(201);

  77.   message->add_repeated_int64(202);

  78.   message->add_repeated_uint32(203);

  79.   message->add_repeated_uint64(204);

  80.   message->add_repeated_sint32(205);

  81.   message->add_repeated_sint64(206);

  82.   message->add_repeated_fixed32(207);

  83.   message->add_repeated_fixed64(208);

  84.   message->add_repeated_sfixed32(209);

  85.   message->add_repeated_sfixed64(210);

  86.   message->add_repeated_float(211);

  87.   message->add_repeated_double(212);

  88.   message->add_repeated_bool(true);

  89.   message->add_repeated_string("215");

  90.   message->add_repeated_bytes("216");

  91. 

  92.   message->add_repeatedgroup()->set_a(217);

  93.   message->add_repeated_nested_message()->set_bb(218);

  94.   message->add_repeated_foreign_message()->set_c(219);

  95.   message->add_repeated_import_message()->set_d(220);

  96.   message->add_repeated_lazy_message()->set_bb(227);

  97. 

  98.   message->add_repeated_nested_enum(unittest::TestAllTypesLite::BAR);

  99.   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAR);

  100.   message->add_repeated_import_enum(unittest_import::IMPORT_LITE_BAR);

  101. 

  102. 

  103.   // Add a second one of each field.

  104.   message->add_repeated_int32(301);

  105.   message->add_repeated_int64(302);

  106.   message->add_repeated_uint32(303);

  107.   message->add_repeated_uint64(304);

  108.   message->add_repeated_sint32(305);

  109.   message->add_repeated_sint64(306);

  110.   message->add_repeated_fixed32(307);

  111.   message->add_repeated_fixed64(308);

  112.   message->add_repeated_sfixed32(309);

  113.   message->add_repeated_sfixed64(310);

  114.   message->add_repeated_float(311);

  115.   message->add_repeated_double(312);

  116.   message->add_repeated_bool(false);

  117.   message->add_repeated_string("315");

  118.   message->add_repeated_bytes("316");

  119. 

  120.   message->add_repeatedgroup()->set_a(317);

  121.   message->add_repeated_nested_message()->set_bb(318);

  122.   message->add_repeated_foreign_message()->set_c(319);

  123.   message->add_repeated_import_message()->set_d(320);

  124.   message->add_repeated_lazy_message()->set_bb(327);

  125. 

  126.   message->add_repeated_nested_enum(unittest::TestAllTypesLite::BAZ);

  127.   message->add_repeated_foreign_enum(unittest::FOREIGN_LITE_BAZ);

  128.   message->add_repeated_import_enum(unittest_import::IMPORT_LITE_BAZ);

  129. 

  130. 

  131.   // -----------------------------------------------------------------

  132. 

  133.   message->set_default_int32(401);

  134.   message->set_default_int64(402);

  135.   message->set_default_uint32(403);

  136.   message->set_default_uint64(404);

  137.   message->set_default_sint32(405);

  138.   message->set_default_sint64(406);

  139.   message->set_default_fixed32(407);

  140.   message->set_default_fixed64(408);

  141.   message->set_default_sfixed32(409);

  142.   message->set_default_sfixed64(410);

  143.   message->set_default_float(411);

  144.   message->set_default_double(412);

  145.   message->set_default_bool(false);

  146.   message->set_default_string("415");

  147.   message->set_default_bytes("416");

  148. 

  149.   message->set_default_nested_enum(unittest::TestAllTypesLite::FOO);

  150.   message->set_default_foreign_enum(unittest::FOREIGN_LITE_FOO);

  151.   message->set_default_import_enum(unittest_import::IMPORT_LITE_FOO);

  152. 

  153. 

  154.   message->set_oneof_uint32(601);

  155.   message->mutable_oneof_nested_message()->set_bb(602);

  156.   message->set_oneof_string("603");

  157.   message->set_oneof_bytes("604");

  158. }

  159. 

  160. // -------------------------------------------------------------------

  161. 

  162. void TestUtilLite::ModifyRepeatedFields(unittest::TestAllTypesLite* message) {

  163.   message->set_repeated_int32(1, 501);

  164.   message->set_repeated_int64(1, 502);

  165.   message->set_repeated_uint32(1, 503);

  166.   message->set_repeated_uint64(1, 504);

  167.   message->set_repeated_sint32(1, 505);

  168.   message->set_repeated_sint64(1, 506);

  169.   message->set_repeated_fixed32(1, 507);

  170.   message->set_repeated_fixed64(1, 508);

  171.   message->set_repeated_sfixed32(1, 509);

  172.   message->set_repeated_sfixed64(1, 510);

  173.   message->set_repeated_float(1, 511);

  174.   message->set_repeated_double(1, 512);

  175.   message->set_repeated_bool(1, true);

  176.   message->set_repeated_string(1, "515");

  177.   message->set_repeated_bytes(1, "516");

  178. 

  179.   message->mutable_repeatedgroup(1)->set_a(517);

  180.   message->mutable_repeated_nested_message(1)->set_bb(518);

  181.   message->mutable_repeated_foreign_message(1)->set_c(519);

  182.   message->mutable_repeated_import_message(1)->set_d(520);

  183.   message->mutable_repeated_lazy_message(1)->set_bb(527);

  184. 

  185.   message->set_repeated_nested_enum(1, unittest::TestAllTypesLite::FOO);

  186.   message->set_repeated_foreign_enum(1, unittest::FOREIGN_LITE_FOO);

  187.   message->set_repeated_import_enum(1, unittest_import::IMPORT_LITE_FOO);

  188. 

  189. }

  190. 

  191. // -------------------------------------------------------------------

  192. 

  193. void TestUtilLite::ExpectAllFieldsSet(

  194.     const unittest::TestAllTypesLite& message) {

  195.   EXPECT_TRUE(message.has_optional_int32());

  196.   EXPECT_TRUE(message.has_optional_int64());

  197.   EXPECT_TRUE(message.has_optional_uint32());

  198.   EXPECT_TRUE(message.has_optional_uint64());

  199.   EXPECT_TRUE(message.has_optional_sint32());

  200.   EXPECT_TRUE(message.has_optional_sint64());

  201.   EXPECT_TRUE(message.has_optional_fixed32());

  202.   EXPECT_TRUE(message.has_optional_fixed64());

  203.   EXPECT_TRUE(message.has_optional_sfixed32());

  204.   EXPECT_TRUE(message.has_optional_sfixed64());

  205.   EXPECT_TRUE(message.has_optional_float());

  206.   EXPECT_TRUE(message.has_optional_double());

  207.   EXPECT_TRUE(message.has_optional_bool());

  208.   EXPECT_TRUE(message.has_optional_string());

  209.   EXPECT_TRUE(message.has_optional_bytes());

  210. 

  211.   EXPECT_TRUE(message.has_optionalgroup());

  212.   EXPECT_TRUE(message.has_optional_nested_message());

  213.   EXPECT_TRUE(message.has_optional_foreign_message());

  214.   EXPECT_TRUE(message.has_optional_import_message());

  215.   EXPECT_TRUE(message.has_optional_public_import_message());

  216.   EXPECT_TRUE(message.has_optional_lazy_message());

  217. 

  218.   EXPECT_TRUE(message.optionalgroup().has_a());

  219.   EXPECT_TRUE(message.optional_nested_message().has_bb());

  220.   EXPECT_TRUE(message.optional_foreign_message().has_c());

  221.   EXPECT_TRUE(message.optional_import_message().has_d());

  222.   EXPECT_TRUE(message.optional_public_import_message().has_e());

  223.   EXPECT_TRUE(message.optional_lazy_message().has_bb());

  224. 

  225.   EXPECT_TRUE(message.has_optional_nested_enum());

  226.   EXPECT_TRUE(message.has_optional_foreign_enum());

  227.   EXPECT_TRUE(message.has_optional_import_enum());

  228. 

  229. 

  230.   EXPECT_EQ(101, message.optional_int32());

  231.   EXPECT_EQ(102, message.optional_int64());

  232.   EXPECT_EQ(103, message.optional_uint32());

  233.   EXPECT_EQ(104, message.optional_uint64());

  234.   EXPECT_EQ(105, message.optional_sint32());

  235.   EXPECT_EQ(106, message.optional_sint64());

  236.   EXPECT_EQ(107, message.optional_fixed32());

  237.   EXPECT_EQ(108, message.optional_fixed64());

  238.   EXPECT_EQ(109, message.optional_sfixed32());

  239.   EXPECT_EQ(110, message.optional_sfixed64());

  240.   EXPECT_EQ(111, message.optional_float());

  241.   EXPECT_EQ(112, message.optional_double());

  242.   EXPECT_EQ(true, message.optional_bool());

  243.   EXPECT_EQ("115", message.optional_string());

  244.   EXPECT_EQ("116", message.optional_bytes());

  245. 

  246.   EXPECT_EQ(117, message.optionalgroup().a());

  247.   EXPECT_EQ(118, message.optional_nested_message().bb());

  248.   EXPECT_EQ(119, message.optional_foreign_message().c());

  249.   EXPECT_EQ(120, message.optional_import_message().d());

  250.   EXPECT_EQ(126, message.optional_public_import_message().e());

  251.   EXPECT_EQ(127, message.optional_lazy_message().bb());

  252. 

  253.   EXPECT_EQ(unittest::TestAllTypesLite::BAZ, message.optional_nested_enum());

  254.   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.optional_foreign_enum());

  255.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.optional_import_enum());

  256. 

  257. 

  258.   // -----------------------------------------------------------------

  259. 

  260.   ASSERT_EQ(2, message.repeated_int32_size());

  261.   ASSERT_EQ(2, message.repeated_int64_size());

  262.   ASSERT_EQ(2, message.repeated_uint32_size());

  263.   ASSERT_EQ(2, message.repeated_uint64_size());

  264.   ASSERT_EQ(2, message.repeated_sint32_size());

  265.   ASSERT_EQ(2, message.repeated_sint64_size());

  266.   ASSERT_EQ(2, message.repeated_fixed32_size());

  267.   ASSERT_EQ(2, message.repeated_fixed64_size());

  268.   ASSERT_EQ(2, message.repeated_sfixed32_size());

  269.   ASSERT_EQ(2, message.repeated_sfixed64_size());

  270.   ASSERT_EQ(2, message.repeated_float_size());

  271.   ASSERT_EQ(2, message.repeated_double_size());

  272.   ASSERT_EQ(2, message.repeated_bool_size());

  273.   ASSERT_EQ(2, message.repeated_string_size());

  274.   ASSERT_EQ(2, message.repeated_bytes_size());

  275. 

  276.   ASSERT_EQ(2, message.repeatedgroup_size());

  277.   ASSERT_EQ(2, message.repeated_nested_message_size());

  278.   ASSERT_EQ(2, message.repeated_foreign_message_size());

  279.   ASSERT_EQ(2, message.repeated_import_message_size());

  280.   ASSERT_EQ(2, message.repeated_lazy_message_size());

  281.   ASSERT_EQ(2, message.repeated_nested_enum_size());

  282.   ASSERT_EQ(2, message.repeated_foreign_enum_size());

  283.   ASSERT_EQ(2, message.repeated_import_enum_size());

  284. 

  285. 

  286.   EXPECT_EQ(201, message.repeated_int32(0));

  287.   EXPECT_EQ(202, message.repeated_int64(0));

  288.   EXPECT_EQ(203, message.repeated_uint32(0));

  289.   EXPECT_EQ(204, message.repeated_uint64(0));

  290.   EXPECT_EQ(205, message.repeated_sint32(0));

  291.   EXPECT_EQ(206, message.repeated_sint64(0));

  292.   EXPECT_EQ(207, message.repeated_fixed32(0));

  293.   EXPECT_EQ(208, message.repeated_fixed64(0));

  294.   EXPECT_EQ(209, message.repeated_sfixed32(0));

  295.   EXPECT_EQ(210, message.repeated_sfixed64(0));

  296.   EXPECT_EQ(211, message.repeated_float(0));

  297.   EXPECT_EQ(212, message.repeated_double(0));

  298.   EXPECT_EQ(true, message.repeated_bool(0));

  299.   EXPECT_EQ("215", message.repeated_string(0));

  300.   EXPECT_EQ("216", message.repeated_bytes(0));

  301. 

  302.   EXPECT_EQ(217, message.repeatedgroup(0).a());

  303.   EXPECT_EQ(218, message.repeated_nested_message(0).bb());

  304.   EXPECT_EQ(219, message.repeated_foreign_message(0).c());

  305.   EXPECT_EQ(220, message.repeated_import_message(0).d());

  306.   EXPECT_EQ(227, message.repeated_lazy_message(0).bb());

  307. 

  308. 

  309.   EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.repeated_nested_enum(0));

  310.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.repeated_foreign_enum(0));

  311.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum(0));

  312. 

  313.   EXPECT_EQ(301, message.repeated_int32(1));

  314.   EXPECT_EQ(302, message.repeated_int64(1));

  315.   EXPECT_EQ(303, message.repeated_uint32(1));

  316.   EXPECT_EQ(304, message.repeated_uint64(1));

  317.   EXPECT_EQ(305, message.repeated_sint32(1));

  318.   EXPECT_EQ(306, message.repeated_sint64(1));

  319.   EXPECT_EQ(307, message.repeated_fixed32(1));

  320.   EXPECT_EQ(308, message.repeated_fixed64(1));

  321.   EXPECT_EQ(309, message.repeated_sfixed32(1));

  322.   EXPECT_EQ(310, message.repeated_sfixed64(1));

  323.   EXPECT_EQ(311, message.repeated_float(1));

  324.   EXPECT_EQ(312, message.repeated_double(1));

  325.   EXPECT_EQ(false, message.repeated_bool(1));

  326.   EXPECT_EQ("315", message.repeated_string(1));

  327.   EXPECT_EQ("316", message.repeated_bytes(1));

  328. 

  329.   EXPECT_EQ(317, message.repeatedgroup(1).a());

  330.   EXPECT_EQ(318, message.repeated_nested_message(1).bb());

  331.   EXPECT_EQ(319, message.repeated_foreign_message(1).c());

  332.   EXPECT_EQ(320, message.repeated_import_message(1).d());

  333.   EXPECT_EQ(327, message.repeated_lazy_message(1).bb());

  334. 

  335.   EXPECT_EQ(unittest::TestAllTypesLite::BAZ, message.repeated_nested_enum(1));

  336.   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.repeated_foreign_enum(1));

  337.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAZ, message.repeated_import_enum(1));

  338. 

  339. 

  340.   // -----------------------------------------------------------------

  341. 

  342.   EXPECT_TRUE(message.has_default_int32());

  343.   EXPECT_TRUE(message.has_default_int64());

  344.   EXPECT_TRUE(message.has_default_uint32());

  345.   EXPECT_TRUE(message.has_default_uint64());

  346.   EXPECT_TRUE(message.has_default_sint32());

  347.   EXPECT_TRUE(message.has_default_sint64());

  348.   EXPECT_TRUE(message.has_default_fixed32());

  349.   EXPECT_TRUE(message.has_default_fixed64());

  350.   EXPECT_TRUE(message.has_default_sfixed32());

  351.   EXPECT_TRUE(message.has_default_sfixed64());

  352.   EXPECT_TRUE(message.has_default_float());

  353.   EXPECT_TRUE(message.has_default_double());

  354.   EXPECT_TRUE(message.has_default_bool());

  355.   EXPECT_TRUE(message.has_default_string());

  356.   EXPECT_TRUE(message.has_default_bytes());

  357. 

  358.   EXPECT_TRUE(message.has_default_nested_enum());

  359.   EXPECT_TRUE(message.has_default_foreign_enum());

  360.   EXPECT_TRUE(message.has_default_import_enum());

  361. 

  362. 

  363.   EXPECT_EQ(401, message.default_int32());

  364.   EXPECT_EQ(402, message.default_int64());

  365.   EXPECT_EQ(403, message.default_uint32());

  366.   EXPECT_EQ(404, message.default_uint64());

  367.   EXPECT_EQ(405, message.default_sint32());

  368.   EXPECT_EQ(406, message.default_sint64());

  369.   EXPECT_EQ(407, message.default_fixed32());

  370.   EXPECT_EQ(408, message.default_fixed64());

  371.   EXPECT_EQ(409, message.default_sfixed32());

  372.   EXPECT_EQ(410, message.default_sfixed64());

  373.   EXPECT_EQ(411, message.default_float());

  374.   EXPECT_EQ(412, message.default_double());

  375.   EXPECT_EQ(false, message.default_bool());

  376.   EXPECT_EQ("415", message.default_string());

  377.   EXPECT_EQ("416", message.default_bytes());

  378. 

  379.   EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.default_nested_enum());

  380.   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.default_foreign_enum());

  381.   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.default_import_enum());

  382. 

  383. 

  384.   EXPECT_FALSE(message.has_oneof_uint32());

  385.   EXPECT_FALSE(message.has_oneof_nested_message());

  386.   EXPECT_FALSE(message.has_oneof_string());

  387.   EXPECT_TRUE(message.has_oneof_bytes());

  388. 

  389.   EXPECT_EQ("604", message.oneof_bytes());

  390. }

  391. 

  392. // -------------------------------------------------------------------

  393. 

  394. void TestUtilLite::ExpectClear(const unittest::TestAllTypesLite& message) {

  395.   // has_blah() should initially be false for all optional fields.

  396.   EXPECT_FALSE(message.has_optional_int32());

  397.   EXPECT_FALSE(message.has_optional_int64());

  398.   EXPECT_FALSE(message.has_optional_uint32());

  399.   EXPECT_FALSE(message.has_optional_uint64());

  400.   EXPECT_FALSE(message.has_optional_sint32());

  401.   EXPECT_FALSE(message.has_optional_sint64());

  402.   EXPECT_FALSE(message.has_optional_fixed32());

  403.   EXPECT_FALSE(message.has_optional_fixed64());

  404.   EXPECT_FALSE(message.has_optional_sfixed32());

  405.   EXPECT_FALSE(message.has_optional_sfixed64());

  406.   EXPECT_FALSE(message.has_optional_float());

  407.   EXPECT_FALSE(message.has_optional_double());

  408.   EXPECT_FALSE(message.has_optional_bool());

  409.   EXPECT_FALSE(message.has_optional_string());

  410.   EXPECT_FALSE(message.has_optional_bytes());

  411. 

  412.   EXPECT_FALSE(message.has_optionalgroup());

  413.   EXPECT_FALSE(message.has_optional_nested_message());

  414.   EXPECT_FALSE(message.has_optional_foreign_message());

  415.   EXPECT_FALSE(message.has_optional_import_message());

  416.   EXPECT_FALSE(message.has_optional_public_import_message());

  417.   EXPECT_FALSE(message.has_optional_lazy_message());

  418. 

  419.   EXPECT_FALSE(message.has_optional_nested_enum());

  420.   EXPECT_FALSE(message.has_optional_foreign_enum());

  421.   EXPECT_FALSE(message.has_optional_import_enum());

  422. 

  423. 

  424.   // Optional fields without defaults are set to zero or something like it.

  425.   EXPECT_EQ(0, message.optional_int32());

  426.   EXPECT_EQ(0, message.optional_int64());

  427.   EXPECT_EQ(0, message.optional_uint32());

  428.   EXPECT_EQ(0, message.optional_uint64());

  429.   EXPECT_EQ(0, message.optional_sint32());

  430.   EXPECT_EQ(0, message.optional_sint64());

  431.   EXPECT_EQ(0, message.optional_fixed32());

  432.   EXPECT_EQ(0, message.optional_fixed64());

  433.   EXPECT_EQ(0, message.optional_sfixed32());

  434.   EXPECT_EQ(0, message.optional_sfixed64());

  435.   EXPECT_EQ(0, message.optional_float());

  436.   EXPECT_EQ(0, message.optional_double());

  437.   EXPECT_EQ(false, message.optional_bool());

  438.   EXPECT_EQ("", message.optional_string());

  439.   EXPECT_EQ("", message.optional_bytes());

  440. 

  441.   // Embedded messages should also be clear.

  442.   EXPECT_FALSE(message.optionalgroup().has_a());

  443.   EXPECT_FALSE(message.optional_nested_message().has_bb());

  444.   EXPECT_FALSE(message.optional_foreign_message().has_c());

  445.   EXPECT_FALSE(message.optional_import_message().has_d());

  446.   EXPECT_FALSE(message.optional_public_import_message().has_e());

  447.   EXPECT_FALSE(message.optional_lazy_message().has_bb());

  448. 

  449.   EXPECT_EQ(0, message.optionalgroup().a());

  450.   EXPECT_EQ(0, message.optional_nested_message().bb());

  451.   EXPECT_EQ(0, message.optional_foreign_message().c());

  452.   EXPECT_EQ(0, message.optional_import_message().d());

  453. 

  454.   // Enums without defaults are set to the first value in the enum.

  455.   EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.optional_nested_enum());

  456.   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.optional_foreign_enum());

  457.   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.optional_import_enum());

  458. 

  459. 

  460.   // Repeated fields are empty.

  461.   EXPECT_EQ(0, message.repeated_int32_size());

  462.   EXPECT_EQ(0, message.repeated_int64_size());

  463.   EXPECT_EQ(0, message.repeated_uint32_size());

  464.   EXPECT_EQ(0, message.repeated_uint64_size());

  465.   EXPECT_EQ(0, message.repeated_sint32_size());

  466.   EXPECT_EQ(0, message.repeated_sint64_size());

  467.   EXPECT_EQ(0, message.repeated_fixed32_size());

  468.   EXPECT_EQ(0, message.repeated_fixed64_size());

  469.   EXPECT_EQ(0, message.repeated_sfixed32_size());

  470.   EXPECT_EQ(0, message.repeated_sfixed64_size());

  471.   EXPECT_EQ(0, message.repeated_float_size());

  472.   EXPECT_EQ(0, message.repeated_double_size());

  473.   EXPECT_EQ(0, message.repeated_bool_size());

  474.   EXPECT_EQ(0, message.repeated_string_size());

  475.   EXPECT_EQ(0, message.repeated_bytes_size());

  476. 

  477.   EXPECT_EQ(0, message.repeatedgroup_size());

  478.   EXPECT_EQ(0, message.repeated_nested_message_size());

  479.   EXPECT_EQ(0, message.repeated_foreign_message_size());

  480.   EXPECT_EQ(0, message.repeated_import_message_size());

  481.   EXPECT_EQ(0, message.repeated_lazy_message_size());

  482.   EXPECT_EQ(0, message.repeated_nested_enum_size());

  483.   EXPECT_EQ(0, message.repeated_foreign_enum_size());

  484.   EXPECT_EQ(0, message.repeated_import_enum_size());

  485. 

  486. 

  487.   // has_blah() should also be false for all default fields.

  488.   EXPECT_FALSE(message.has_default_int32());

  489.   EXPECT_FALSE(message.has_default_int64());

  490.   EXPECT_FALSE(message.has_default_uint32());

  491.   EXPECT_FALSE(message.has_default_uint64());

  492.   EXPECT_FALSE(message.has_default_sint32());

  493.   EXPECT_FALSE(message.has_default_sint64());

  494.   EXPECT_FALSE(message.has_default_fixed32());

  495.   EXPECT_FALSE(message.has_default_fixed64());

  496.   EXPECT_FALSE(message.has_default_sfixed32());

  497.   EXPECT_FALSE(message.has_default_sfixed64());

  498.   EXPECT_FALSE(message.has_default_float());

  499.   EXPECT_FALSE(message.has_default_double());

  500.   EXPECT_FALSE(message.has_default_bool());

  501.   EXPECT_FALSE(message.has_default_string());

  502.   EXPECT_FALSE(message.has_default_bytes());

  503. 

  504.   EXPECT_FALSE(message.has_default_nested_enum());

  505.   EXPECT_FALSE(message.has_default_foreign_enum());

  506.   EXPECT_FALSE(message.has_default_import_enum());

  507. 

  508. 

  509.   // Fields with defaults have their default values (duh).

  510.   EXPECT_EQ(41, message.default_int32());

  511.   EXPECT_EQ(42, message.default_int64());

  512.   EXPECT_EQ(43, message.default_uint32());

  513.   EXPECT_EQ(44, message.default_uint64());

  514.   EXPECT_EQ(-45, message.default_sint32());

  515.   EXPECT_EQ(46, message.default_sint64());

  516.   EXPECT_EQ(47, message.default_fixed32());

  517.   EXPECT_EQ(48, message.default_fixed64());

  518.   EXPECT_EQ(49, message.default_sfixed32());

  519.   EXPECT_EQ(-50, message.default_sfixed64());

  520.   EXPECT_EQ(51.5, message.default_float());

  521.   EXPECT_EQ(52e3, message.default_double());

  522.   EXPECT_EQ(true, message.default_bool());

  523.   EXPECT_EQ("hello", message.default_string());

  524.   EXPECT_EQ("world", message.default_bytes());

  525. 

  526.   EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.default_nested_enum());

  527.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.default_foreign_enum());

  528.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.default_import_enum());

  529. 

  530. 

  531.   EXPECT_FALSE(message.has_oneof_uint32());

  532.   EXPECT_FALSE(message.has_oneof_nested_message());

  533.   EXPECT_FALSE(message.has_oneof_string());

  534.   EXPECT_FALSE(message.has_oneof_bytes());

  535. }

  536. 

  537. // -------------------------------------------------------------------

  538. 

  539. void TestUtilLite::ExpectRepeatedFieldsModified(

  540.     const unittest::TestAllTypesLite& message) {

  541.   // ModifyRepeatedFields only sets the second repeated element of each

  542.   // field.  In addition to verifying this, we also verify that the first

  543.   // element and size were *not* modified.

  544.   ASSERT_EQ(2, message.repeated_int32_size());

  545.   ASSERT_EQ(2, message.repeated_int64_size());

  546.   ASSERT_EQ(2, message.repeated_uint32_size());

  547.   ASSERT_EQ(2, message.repeated_uint64_size());

  548.   ASSERT_EQ(2, message.repeated_sint32_size());

  549.   ASSERT_EQ(2, message.repeated_sint64_size());

  550.   ASSERT_EQ(2, message.repeated_fixed32_size());

  551.   ASSERT_EQ(2, message.repeated_fixed64_size());

  552.   ASSERT_EQ(2, message.repeated_sfixed32_size());

  553.   ASSERT_EQ(2, message.repeated_sfixed64_size());

  554.   ASSERT_EQ(2, message.repeated_float_size());

  555.   ASSERT_EQ(2, message.repeated_double_size());

  556.   ASSERT_EQ(2, message.repeated_bool_size());

  557.   ASSERT_EQ(2, message.repeated_string_size());

  558.   ASSERT_EQ(2, message.repeated_bytes_size());

  559. 

  560.   ASSERT_EQ(2, message.repeatedgroup_size());

  561.   ASSERT_EQ(2, message.repeated_nested_message_size());

  562.   ASSERT_EQ(2, message.repeated_foreign_message_size());

  563.   ASSERT_EQ(2, message.repeated_import_message_size());

  564.   ASSERT_EQ(2, message.repeated_lazy_message_size());

  565.   ASSERT_EQ(2, message.repeated_nested_enum_size());

  566.   ASSERT_EQ(2, message.repeated_foreign_enum_size());

  567.   ASSERT_EQ(2, message.repeated_import_enum_size());

  568. 

  569. 

  570.   EXPECT_EQ(201, message.repeated_int32(0));

  571.   EXPECT_EQ(202, message.repeated_int64(0));

  572.   EXPECT_EQ(203, message.repeated_uint32(0));

  573.   EXPECT_EQ(204, message.repeated_uint64(0));

  574.   EXPECT_EQ(205, message.repeated_sint32(0));

  575.   EXPECT_EQ(206, message.repeated_sint64(0));

  576.   EXPECT_EQ(207, message.repeated_fixed32(0));

  577.   EXPECT_EQ(208, message.repeated_fixed64(0));

  578.   EXPECT_EQ(209, message.repeated_sfixed32(0));

  579.   EXPECT_EQ(210, message.repeated_sfixed64(0));

  580.   EXPECT_EQ(211, message.repeated_float(0));

  581.   EXPECT_EQ(212, message.repeated_double(0));

  582.   EXPECT_EQ(true, message.repeated_bool(0));

  583.   EXPECT_EQ("215", message.repeated_string(0));

  584.   EXPECT_EQ("216", message.repeated_bytes(0));

  585. 

  586.   EXPECT_EQ(217, message.repeatedgroup(0).a());

  587.   EXPECT_EQ(218, message.repeated_nested_message(0).bb());

  588.   EXPECT_EQ(219, message.repeated_foreign_message(0).c());

  589.   EXPECT_EQ(220, message.repeated_import_message(0).d());

  590.   EXPECT_EQ(227, message.repeated_lazy_message(0).bb());

  591. 

  592.   EXPECT_EQ(unittest::TestAllTypesLite::BAR, message.repeated_nested_enum(0));

  593.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.repeated_foreign_enum(0));

  594.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR, message.repeated_import_enum(0));

  595. 

  596. 

  597.   // Actually verify the second (modified) elements now.

  598.   EXPECT_EQ(501, message.repeated_int32(1));

  599.   EXPECT_EQ(502, message.repeated_int64(1));

  600.   EXPECT_EQ(503, message.repeated_uint32(1));

  601.   EXPECT_EQ(504, message.repeated_uint64(1));

  602.   EXPECT_EQ(505, message.repeated_sint32(1));

  603.   EXPECT_EQ(506, message.repeated_sint64(1));

  604.   EXPECT_EQ(507, message.repeated_fixed32(1));

  605.   EXPECT_EQ(508, message.repeated_fixed64(1));

  606.   EXPECT_EQ(509, message.repeated_sfixed32(1));

  607.   EXPECT_EQ(510, message.repeated_sfixed64(1));

  608.   EXPECT_EQ(511, message.repeated_float(1));

  609.   EXPECT_EQ(512, message.repeated_double(1));

  610.   EXPECT_EQ(true, message.repeated_bool(1));

  611.   EXPECT_EQ("515", message.repeated_string(1));

  612.   EXPECT_EQ("516", message.repeated_bytes(1));

  613. 

  614.   EXPECT_EQ(517, message.repeatedgroup(1).a());

  615.   EXPECT_EQ(518, message.repeated_nested_message(1).bb());

  616.   EXPECT_EQ(519, message.repeated_foreign_message(1).c());

  617.   EXPECT_EQ(520, message.repeated_import_message(1).d());

  618.   EXPECT_EQ(527, message.repeated_lazy_message(1).bb());

  619. 

  620.   EXPECT_EQ(unittest::TestAllTypesLite::FOO, message.repeated_nested_enum(1));

  621.   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.repeated_foreign_enum(1));

  622.   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO, message.repeated_import_enum(1));

  623. 

  624. }

  625. 

  626. // -------------------------------------------------------------------

  627. 

  628. void TestUtilLite::SetPackedFields(unittest::TestPackedTypesLite* message) {

  629.   message->add_packed_int32(601);

  630.   message->add_packed_int64(602);

  631.   message->add_packed_uint32(603);

  632.   message->add_packed_uint64(604);

  633.   message->add_packed_sint32(605);

  634.   message->add_packed_sint64(606);

  635.   message->add_packed_fixed32(607);

  636.   message->add_packed_fixed64(608);

  637.   message->add_packed_sfixed32(609);

  638.   message->add_packed_sfixed64(610);

  639.   message->add_packed_float(611);

  640.   message->add_packed_double(612);

  641.   message->add_packed_bool(true);

  642.   message->add_packed_enum(unittest::FOREIGN_LITE_BAR);

  643.   // add a second one of each field

  644.   message->add_packed_int32(701);

  645.   message->add_packed_int64(702);

  646.   message->add_packed_uint32(703);

  647.   message->add_packed_uint64(704);

  648.   message->add_packed_sint32(705);

  649.   message->add_packed_sint64(706);

  650.   message->add_packed_fixed32(707);

  651.   message->add_packed_fixed64(708);

  652.   message->add_packed_sfixed32(709);

  653.   message->add_packed_sfixed64(710);

  654.   message->add_packed_float(711);

  655.   message->add_packed_double(712);

  656.   message->add_packed_bool(false);

  657.   message->add_packed_enum(unittest::FOREIGN_LITE_BAZ);

  658. }

  659. 

  660. // -------------------------------------------------------------------

  661. 

  662. void TestUtilLite::ModifyPackedFields(unittest::TestPackedTypesLite* message) {

  663.   message->set_packed_int32(1, 801);

  664.   message->set_packed_int64(1, 802);

  665.   message->set_packed_uint32(1, 803);

  666.   message->set_packed_uint64(1, 804);

  667.   message->set_packed_sint32(1, 805);

  668.   message->set_packed_sint64(1, 806);

  669.   message->set_packed_fixed32(1, 807);

  670.   message->set_packed_fixed64(1, 808);

  671.   message->set_packed_sfixed32(1, 809);

  672.   message->set_packed_sfixed64(1, 810);

  673.   message->set_packed_float(1, 811);

  674.   message->set_packed_double(1, 812);

  675.   message->set_packed_bool(1, true);

  676.   message->set_packed_enum(1, unittest::FOREIGN_LITE_FOO);

  677. }

  678. 

  679. // -------------------------------------------------------------------

  680. 

  681. void TestUtilLite::ExpectPackedFieldsSet(

  682.     const unittest::TestPackedTypesLite& message) {

  683.   ASSERT_EQ(2, message.packed_int32_size());

  684.   ASSERT_EQ(2, message.packed_int64_size());

  685.   ASSERT_EQ(2, message.packed_uint32_size());

  686.   ASSERT_EQ(2, message.packed_uint64_size());

  687.   ASSERT_EQ(2, message.packed_sint32_size());

  688.   ASSERT_EQ(2, message.packed_sint64_size());

  689.   ASSERT_EQ(2, message.packed_fixed32_size());

  690.   ASSERT_EQ(2, message.packed_fixed64_size());

  691.   ASSERT_EQ(2, message.packed_sfixed32_size());

  692.   ASSERT_EQ(2, message.packed_sfixed64_size());

  693.   ASSERT_EQ(2, message.packed_float_size());

  694.   ASSERT_EQ(2, message.packed_double_size());

  695.   ASSERT_EQ(2, message.packed_bool_size());

  696.   ASSERT_EQ(2, message.packed_enum_size());

  697. 

  698.   EXPECT_EQ(601, message.packed_int32(0));

  699.   EXPECT_EQ(602, message.packed_int64(0));

  700.   EXPECT_EQ(603, message.packed_uint32(0));

  701.   EXPECT_EQ(604, message.packed_uint64(0));

  702.   EXPECT_EQ(605, message.packed_sint32(0));

  703.   EXPECT_EQ(606, message.packed_sint64(0));

  704.   EXPECT_EQ(607, message.packed_fixed32(0));

  705.   EXPECT_EQ(608, message.packed_fixed64(0));

  706.   EXPECT_EQ(609, message.packed_sfixed32(0));

  707.   EXPECT_EQ(610, message.packed_sfixed64(0));

  708.   EXPECT_EQ(611, message.packed_float(0));

  709.   EXPECT_EQ(612, message.packed_double(0));

  710.   EXPECT_EQ(true, message.packed_bool(0));

  711.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));

  712. 

  713.   EXPECT_EQ(701, message.packed_int32(1));

  714.   EXPECT_EQ(702, message.packed_int64(1));

  715.   EXPECT_EQ(703, message.packed_uint32(1));

  716.   EXPECT_EQ(704, message.packed_uint64(1));

  717.   EXPECT_EQ(705, message.packed_sint32(1));

  718.   EXPECT_EQ(706, message.packed_sint64(1));

  719.   EXPECT_EQ(707, message.packed_fixed32(1));

  720.   EXPECT_EQ(708, message.packed_fixed64(1));

  721.   EXPECT_EQ(709, message.packed_sfixed32(1));

  722.   EXPECT_EQ(710, message.packed_sfixed64(1));

  723.   EXPECT_EQ(711, message.packed_float(1));

  724.   EXPECT_EQ(712, message.packed_double(1));

  725.   EXPECT_EQ(false, message.packed_bool(1));

  726.   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ, message.packed_enum(1));

  727. }

  728. 

  729. // -------------------------------------------------------------------

  730. 

  731. void TestUtilLite::ExpectPackedClear(

  732.     const unittest::TestPackedTypesLite& message) {

  733.   // Packed repeated fields are empty.

  734.   EXPECT_EQ(0, message.packed_int32_size());

  735.   EXPECT_EQ(0, message.packed_int64_size());

  736.   EXPECT_EQ(0, message.packed_uint32_size());

  737.   EXPECT_EQ(0, message.packed_uint64_size());

  738.   EXPECT_EQ(0, message.packed_sint32_size());

  739.   EXPECT_EQ(0, message.packed_sint64_size());

  740.   EXPECT_EQ(0, message.packed_fixed32_size());

  741.   EXPECT_EQ(0, message.packed_fixed64_size());

  742.   EXPECT_EQ(0, message.packed_sfixed32_size());

  743.   EXPECT_EQ(0, message.packed_sfixed64_size());

  744.   EXPECT_EQ(0, message.packed_float_size());

  745.   EXPECT_EQ(0, message.packed_double_size());

  746.   EXPECT_EQ(0, message.packed_bool_size());

  747.   EXPECT_EQ(0, message.packed_enum_size());

  748. }

  749. 

  750. // -------------------------------------------------------------------

  751. 

  752. void TestUtilLite::ExpectPackedFieldsModified(

  753.     const unittest::TestPackedTypesLite& message) {

  754.   // Do the same for packed repeated fields.

  755.   ASSERT_EQ(2, message.packed_int32_size());

  756.   ASSERT_EQ(2, message.packed_int64_size());

  757.   ASSERT_EQ(2, message.packed_uint32_size());

  758.   ASSERT_EQ(2, message.packed_uint64_size());

  759.   ASSERT_EQ(2, message.packed_sint32_size());

  760.   ASSERT_EQ(2, message.packed_sint64_size());

  761.   ASSERT_EQ(2, message.packed_fixed32_size());

  762.   ASSERT_EQ(2, message.packed_fixed64_size());

  763.   ASSERT_EQ(2, message.packed_sfixed32_size());

  764.   ASSERT_EQ(2, message.packed_sfixed64_size());

  765.   ASSERT_EQ(2, message.packed_float_size());

  766.   ASSERT_EQ(2, message.packed_double_size());

  767.   ASSERT_EQ(2, message.packed_bool_size());

  768.   ASSERT_EQ(2, message.packed_enum_size());

  769. 

  770.   EXPECT_EQ(601, message.packed_int32(0));

  771.   EXPECT_EQ(602, message.packed_int64(0));

  772.   EXPECT_EQ(603, message.packed_uint32(0));

  773.   EXPECT_EQ(604, message.packed_uint64(0));

  774.   EXPECT_EQ(605, message.packed_sint32(0));

  775.   EXPECT_EQ(606, message.packed_sint64(0));

  776.   EXPECT_EQ(607, message.packed_fixed32(0));

  777.   EXPECT_EQ(608, message.packed_fixed64(0));

  778.   EXPECT_EQ(609, message.packed_sfixed32(0));

  779.   EXPECT_EQ(610, message.packed_sfixed64(0));

  780.   EXPECT_EQ(611, message.packed_float(0));

  781.   EXPECT_EQ(612, message.packed_double(0));

  782.   EXPECT_EQ(true, message.packed_bool(0));

  783.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR, message.packed_enum(0));

  784.   // Actually verify the second (modified) elements now.

  785.   EXPECT_EQ(801, message.packed_int32(1));

  786.   EXPECT_EQ(802, message.packed_int64(1));

  787.   EXPECT_EQ(803, message.packed_uint32(1));

  788.   EXPECT_EQ(804, message.packed_uint64(1));

  789.   EXPECT_EQ(805, message.packed_sint32(1));

  790.   EXPECT_EQ(806, message.packed_sint64(1));

  791.   EXPECT_EQ(807, message.packed_fixed32(1));

  792.   EXPECT_EQ(808, message.packed_fixed64(1));

  793.   EXPECT_EQ(809, message.packed_sfixed32(1));

  794.   EXPECT_EQ(810, message.packed_sfixed64(1));

  795.   EXPECT_EQ(811, message.packed_float(1));

  796.   EXPECT_EQ(812, message.packed_double(1));

  797.   EXPECT_EQ(true, message.packed_bool(1));

  798.   EXPECT_EQ(unittest::FOREIGN_LITE_FOO, message.packed_enum(1));

  799. }

  800. 

  801. // ===================================================================

  802. // Extensions

  803. //

  804. // All this code is exactly equivalent to the above code except that it's

  805. // manipulating extension fields instead of normal ones.

  806. //

  807. // I gave up on the 80-char limit here.  Sorry.

  808. 

  809. void TestUtilLite::SetAllExtensions(unittest::TestAllExtensionsLite* message) {

  810.   message->SetExtension(unittest::optional_int32_extension_lite, 101);

  811.   message->SetExtension(unittest::optional_int64_extension_lite, 102);

  812.   message->SetExtension(unittest::optional_uint32_extension_lite, 103);

  813.   message->SetExtension(unittest::optional_uint64_extension_lite, 104);

  814.   message->SetExtension(unittest::optional_sint32_extension_lite, 105);

  815.   message->SetExtension(unittest::optional_sint64_extension_lite, 106);

  816.   message->SetExtension(unittest::optional_fixed32_extension_lite, 107);

  817.   message->SetExtension(unittest::optional_fixed64_extension_lite, 108);

  818.   message->SetExtension(unittest::optional_sfixed32_extension_lite, 109);

  819.   message->SetExtension(unittest::optional_sfixed64_extension_lite, 110);

  820.   message->SetExtension(unittest::optional_float_extension_lite, 111);

  821.   message->SetExtension(unittest::optional_double_extension_lite, 112);

  822.   message->SetExtension(unittest::optional_bool_extension_lite, true);

  823.   message->SetExtension(unittest::optional_string_extension_lite, "115");

  824.   message->SetExtension(unittest::optional_bytes_extension_lite, "116");

  825. 

  826.   message->MutableExtension(unittest::optionalgroup_extension_lite)->set_a(117);

  827.   message->MutableExtension(unittest::optional_nested_message_extension_lite)

  828.       ->set_bb(118);

  829.   message->MutableExtension(unittest::optional_foreign_message_extension_lite)

  830.       ->set_c(119);

  831.   message->MutableExtension(unittest::optional_import_message_extension_lite)

  832.       ->set_d(120);

  833.   message

  834.       ->MutableExtension(

  835.           unittest::optional_public_import_message_extension_lite)

  836.       ->set_e(126);

  837.   message->MutableExtension(unittest::optional_lazy_message_extension_lite)

  838.       ->set_bb(127);

  839. 

  840.   message->SetExtension(unittest::optional_nested_enum_extension_lite,

  841.                         unittest::TestAllTypesLite::BAZ);

  842.   message->SetExtension(unittest::optional_foreign_enum_extension_lite,

  843.                         unittest::FOREIGN_LITE_BAZ);

  844.   message->SetExtension(unittest::optional_import_enum_extension_lite,

  845.                         unittest_import::IMPORT_LITE_BAZ);

  846. 

  847. 

  848.   // -----------------------------------------------------------------

  849. 

  850.   message->AddExtension(unittest::repeated_int32_extension_lite, 201);

  851.   message->AddExtension(unittest::repeated_int64_extension_lite, 202);

  852.   message->AddExtension(unittest::repeated_uint32_extension_lite, 203);

  853.   message->AddExtension(unittest::repeated_uint64_extension_lite, 204);

  854.   message->AddExtension(unittest::repeated_sint32_extension_lite, 205);

  855.   message->AddExtension(unittest::repeated_sint64_extension_lite, 206);

  856.   message->AddExtension(unittest::repeated_fixed32_extension_lite, 207);

  857.   message->AddExtension(unittest::repeated_fixed64_extension_lite, 208);

  858.   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 209);

  859.   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 210);

  860.   message->AddExtension(unittest::repeated_float_extension_lite, 211);

  861.   message->AddExtension(unittest::repeated_double_extension_lite, 212);

  862.   message->AddExtension(unittest::repeated_bool_extension_lite, true);

  863.   message->AddExtension(unittest::repeated_string_extension_lite, "215");

  864.   message->AddExtension(unittest::repeated_bytes_extension_lite, "216");

  865. 

  866.   message->AddExtension(unittest::repeatedgroup_extension_lite)->set_a(217);

  867.   message->AddExtension(unittest::repeated_nested_message_extension_lite)

  868.       ->set_bb(218);

  869.   message->AddExtension(unittest::repeated_foreign_message_extension_lite)

  870.       ->set_c(219);

  871.   message->AddExtension(unittest::repeated_import_message_extension_lite)

  872.       ->set_d(220);

  873.   message->AddExtension(unittest::repeated_lazy_message_extension_lite)

  874.       ->set_bb(227);

  875. 

  876.   message->AddExtension(unittest::repeated_nested_enum_extension_lite,

  877.                         unittest::TestAllTypesLite::BAR);

  878.   message->AddExtension(unittest::repeated_foreign_enum_extension_lite,

  879.                         unittest::FOREIGN_LITE_BAR);

  880.   message->AddExtension(unittest::repeated_import_enum_extension_lite,

  881.                         unittest_import::IMPORT_LITE_BAR);

  882. 

  883. 

  884.   // Add a second one of each field.

  885.   message->AddExtension(unittest::repeated_int32_extension_lite, 301);

  886.   message->AddExtension(unittest::repeated_int64_extension_lite, 302);

  887.   message->AddExtension(unittest::repeated_uint32_extension_lite, 303);

  888.   message->AddExtension(unittest::repeated_uint64_extension_lite, 304);

  889.   message->AddExtension(unittest::repeated_sint32_extension_lite, 305);

  890.   message->AddExtension(unittest::repeated_sint64_extension_lite, 306);

  891.   message->AddExtension(unittest::repeated_fixed32_extension_lite, 307);

  892.   message->AddExtension(unittest::repeated_fixed64_extension_lite, 308);

  893.   message->AddExtension(unittest::repeated_sfixed32_extension_lite, 309);

  894.   message->AddExtension(unittest::repeated_sfixed64_extension_lite, 310);

  895.   message->AddExtension(unittest::repeated_float_extension_lite, 311);

  896.   message->AddExtension(unittest::repeated_double_extension_lite, 312);

  897.   message->AddExtension(unittest::repeated_bool_extension_lite, false);

  898.   message->AddExtension(unittest::repeated_string_extension_lite, "315");

  899.   message->AddExtension(unittest::repeated_bytes_extension_lite, "316");

  900. 

  901.   message->AddExtension(unittest::repeatedgroup_extension_lite)->set_a(317);

  902.   message->AddExtension(unittest::repeated_nested_message_extension_lite)

  903.       ->set_bb(318);

  904.   message->AddExtension(unittest::repeated_foreign_message_extension_lite)

  905.       ->set_c(319);

  906.   message->AddExtension(unittest::repeated_import_message_extension_lite)

  907.       ->set_d(320);

  908.   message->AddExtension(unittest::repeated_lazy_message_extension_lite)

  909.       ->set_bb(327);

  910. 

  911.   message->AddExtension(unittest::repeated_nested_enum_extension_lite,

  912.                         unittest::TestAllTypesLite::BAZ);

  913.   message->AddExtension(unittest::repeated_foreign_enum_extension_lite,

  914.                         unittest::FOREIGN_LITE_BAZ);

  915.   message->AddExtension(unittest::repeated_import_enum_extension_lite,

  916.                         unittest_import::IMPORT_LITE_BAZ);

  917. 

  918. 

  919.   // -----------------------------------------------------------------

  920. 

  921.   message->SetExtension(unittest::default_int32_extension_lite, 401);

  922.   message->SetExtension(unittest::default_int64_extension_lite, 402);

  923.   message->SetExtension(unittest::default_uint32_extension_lite, 403);

  924.   message->SetExtension(unittest::default_uint64_extension_lite, 404);

  925.   message->SetExtension(unittest::default_sint32_extension_lite, 405);

  926.   message->SetExtension(unittest::default_sint64_extension_lite, 406);

  927.   message->SetExtension(unittest::default_fixed32_extension_lite, 407);

  928.   message->SetExtension(unittest::default_fixed64_extension_lite, 408);

  929.   message->SetExtension(unittest::default_sfixed32_extension_lite, 409);

  930.   message->SetExtension(unittest::default_sfixed64_extension_lite, 410);

  931.   message->SetExtension(unittest::default_float_extension_lite, 411);

  932.   message->SetExtension(unittest::default_double_extension_lite, 412);

  933.   message->SetExtension(unittest::default_bool_extension_lite, false);

  934.   message->SetExtension(unittest::default_string_extension_lite, "415");

  935.   message->SetExtension(unittest::default_bytes_extension_lite, "416");

  936. 

  937.   message->SetExtension(unittest::default_nested_enum_extension_lite,

  938.                         unittest::TestAllTypesLite::FOO);

  939.   message->SetExtension(unittest::default_foreign_enum_extension_lite,

  940.                         unittest::FOREIGN_LITE_FOO);

  941.   message->SetExtension(unittest::default_import_enum_extension_lite,

  942.                         unittest_import::IMPORT_LITE_FOO);

  943. 

  944. 

  945.   message->SetExtension(unittest::oneof_uint32_extension_lite, 601);

  946.   message->MutableExtension(unittest::oneof_nested_message_extension_lite)

  947.       ->set_bb(602);

  948.   ;

  949.   message->SetExtension(unittest::oneof_string_extension_lite, "603");

  950.   message->SetExtension(unittest::oneof_bytes_extension_lite, "604");

  951. }

  952. 

  953. // -------------------------------------------------------------------

  954. 

  955. void TestUtilLite::ModifyRepeatedExtensions(

  956.     unittest::TestAllExtensionsLite* message) {

  957.   message->SetExtension(unittest::repeated_int32_extension_lite, 1, 501);

  958.   message->SetExtension(unittest::repeated_int64_extension_lite, 1, 502);

  959.   message->SetExtension(unittest::repeated_uint32_extension_lite, 1, 503);

  960.   message->SetExtension(unittest::repeated_uint64_extension_lite, 1, 504);

  961.   message->SetExtension(unittest::repeated_sint32_extension_lite, 1, 505);

  962.   message->SetExtension(unittest::repeated_sint64_extension_lite, 1, 506);

  963.   message->SetExtension(unittest::repeated_fixed32_extension_lite, 1, 507);

  964.   message->SetExtension(unittest::repeated_fixed64_extension_lite, 1, 508);

  965.   message->SetExtension(unittest::repeated_sfixed32_extension_lite, 1, 509);

  966.   message->SetExtension(unittest::repeated_sfixed64_extension_lite, 1, 510);

  967.   message->SetExtension(unittest::repeated_float_extension_lite, 1, 511);

  968.   message->SetExtension(unittest::repeated_double_extension_lite, 1, 512);

  969.   message->SetExtension(unittest::repeated_bool_extension_lite, 1, true);

  970.   message->SetExtension(unittest::repeated_string_extension_lite, 1, "515");

  971.   message->SetExtension(unittest::repeated_bytes_extension_lite, 1, "516");

  972. 

  973.   message->MutableExtension(unittest::repeatedgroup_extension_lite, 1)

  974.       ->set_a(517);

  975.   message->MutableExtension(unittest::repeated_nested_message_extension_lite, 1)

  976.       ->set_bb(518);

  977.   message

  978.       ->MutableExtension(unittest::repeated_foreign_message_extension_lite, 1)

  979.       ->set_c(519);

  980.   message->MutableExtension(unittest::repeated_import_message_extension_lite, 1)

  981.       ->set_d(520);

  982.   message->MutableExtension(unittest::repeated_lazy_message_extension_lite, 1)

  983.       ->set_bb(527);

  984. 

  985.   message->SetExtension(unittest::repeated_nested_enum_extension_lite, 1,

  986.                         unittest::TestAllTypesLite::FOO);

  987.   message->SetExtension(unittest::repeated_foreign_enum_extension_lite, 1,

  988.                         unittest::FOREIGN_LITE_FOO);

  989.   message->SetExtension(unittest::repeated_import_enum_extension_lite, 1,

  990.                         unittest_import::IMPORT_LITE_FOO);

  991. 

  992. }

  993. 

  994. // -------------------------------------------------------------------

  995. 

  996. void TestUtilLite::ExpectAllExtensionsSet(

  997.     const unittest::TestAllExtensionsLite& message) {

  998.   EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension_lite));

  999.   EXPECT_TRUE(message.HasExtension(unittest::optional_int64_extension_lite));

  1000.   EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension_lite));

  1001.   EXPECT_TRUE(message.HasExtension(unittest::optional_uint64_extension_lite));

  1002.   EXPECT_TRUE(message.HasExtension(unittest::optional_sint32_extension_lite));

  1003.   EXPECT_TRUE(message.HasExtension(unittest::optional_sint64_extension_lite));

  1004.   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed32_extension_lite));

  1005.   EXPECT_TRUE(message.HasExtension(unittest::optional_fixed64_extension_lite));

  1006.   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed32_extension_lite));

  1007.   EXPECT_TRUE(message.HasExtension(unittest::optional_sfixed64_extension_lite));

  1008.   EXPECT_TRUE(message.HasExtension(unittest::optional_float_extension_lite));

  1009.   EXPECT_TRUE(message.HasExtension(unittest::optional_double_extension_lite));

  1010.   EXPECT_TRUE(message.HasExtension(unittest::optional_bool_extension_lite));

  1011.   EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension_lite));

  1012.   EXPECT_TRUE(message.HasExtension(unittest::optional_bytes_extension_lite));

  1013. 

  1014.   EXPECT_TRUE(message.HasExtension(unittest::optionalgroup_extension_lite));

  1015.   EXPECT_TRUE(

  1016.       message.HasExtension(unittest::optional_nested_message_extension_lite));

  1017.   EXPECT_TRUE(

  1018.       message.HasExtension(unittest::optional_foreign_message_extension_lite));

  1019.   EXPECT_TRUE(

  1020.       message.HasExtension(unittest::optional_import_message_extension_lite));

  1021.   EXPECT_TRUE(message.HasExtension(

  1022.       unittest::optional_public_import_message_extension_lite));

  1023.   EXPECT_TRUE(

  1024.       message.HasExtension(unittest::optional_lazy_message_extension_lite));

  1025. 

  1026.   EXPECT_TRUE(

  1027.       message.GetExtension(unittest::optionalgroup_extension_lite).has_a());

  1028.   EXPECT_TRUE(

  1029.       message.GetExtension(unittest::optional_nested_message_extension_lite)

  1030.           .has_bb());

  1031.   EXPECT_TRUE(

  1032.       message.GetExtension(unittest::optional_foreign_message_extension_lite)

  1033.           .has_c());

  1034.   EXPECT_TRUE(

  1035.       message.GetExtension(unittest::optional_import_message_extension_lite)

  1036.           .has_d());

  1037.   EXPECT_TRUE(

  1038.       message

  1039.           .GetExtension(unittest::optional_public_import_message_extension_lite)

  1040.           .has_e());

  1041.   EXPECT_TRUE(

  1042.       message.GetExtension(unittest::optional_lazy_message_extension_lite)

  1043.           .has_bb());

  1044. 

  1045.   EXPECT_TRUE(

  1046.       message.HasExtension(unittest::optional_nested_enum_extension_lite));

  1047.   EXPECT_TRUE(

  1048.       message.HasExtension(unittest::optional_foreign_enum_extension_lite));

  1049.   EXPECT_TRUE(

  1050.       message.HasExtension(unittest::optional_import_enum_extension_lite));

  1051. 

  1052. 

  1053.   EXPECT_EQ(101, message.GetExtension(unittest::optional_int32_extension_lite));

  1054.   EXPECT_EQ(102, message.GetExtension(unittest::optional_int64_extension_lite));

  1055.   EXPECT_EQ(103,

  1056.             message.GetExtension(unittest::optional_uint32_extension_lite));

  1057.   EXPECT_EQ(104,

  1058.             message.GetExtension(unittest::optional_uint64_extension_lite));

  1059.   EXPECT_EQ(105,

  1060.             message.GetExtension(unittest::optional_sint32_extension_lite));

  1061.   EXPECT_EQ(106,

  1062.             message.GetExtension(unittest::optional_sint64_extension_lite));

  1063.   EXPECT_EQ(107,

  1064.             message.GetExtension(unittest::optional_fixed32_extension_lite));

  1065.   EXPECT_EQ(108,

  1066.             message.GetExtension(unittest::optional_fixed64_extension_lite));

  1067.   EXPECT_EQ(109,

  1068.             message.GetExtension(unittest::optional_sfixed32_extension_lite));

  1069.   EXPECT_EQ(110,

  1070.             message.GetExtension(unittest::optional_sfixed64_extension_lite));

  1071.   EXPECT_EQ(111, message.GetExtension(unittest::optional_float_extension_lite));

  1072.   EXPECT_EQ(112,

  1073.             message.GetExtension(unittest::optional_double_extension_lite));

  1074.   EXPECT_EQ(true, message.GetExtension(unittest::optional_bool_extension_lite));

  1075.   EXPECT_EQ("115",

  1076.             message.GetExtension(unittest::optional_string_extension_lite));

  1077.   EXPECT_EQ("116",

  1078.             message.GetExtension(unittest::optional_bytes_extension_lite));

  1079. 

  1080.   EXPECT_EQ(117,

  1081.             message.GetExtension(unittest::optionalgroup_extension_lite).a());

  1082.   EXPECT_EQ(

  1083.       118,

  1084.       message.GetExtension(unittest::optional_nested_message_extension_lite)

  1085.           .bb());

  1086.   EXPECT_EQ(

  1087.       119,

  1088.       message.GetExtension(unittest::optional_foreign_message_extension_lite)

  1089.           .c());

  1090.   EXPECT_EQ(

  1091.       120,

  1092.       message.GetExtension(unittest::optional_import_message_extension_lite)

  1093.           .d());

  1094.   EXPECT_EQ(

  1095.       126,

  1096.       message

  1097.           .GetExtension(unittest::optional_public_import_message_extension_lite)

  1098.           .e());

  1099.   EXPECT_EQ(127,

  1100.             message.GetExtension(unittest::optional_lazy_message_extension_lite)

  1101.                 .bb());

  1102. 

  1103.   EXPECT_EQ(

  1104.       unittest::TestAllTypesLite::BAZ,

  1105.       message.GetExtension(unittest::optional_nested_enum_extension_lite));

  1106.   EXPECT_EQ(

  1107.       unittest::FOREIGN_LITE_BAZ,

  1108.       message.GetExtension(unittest::optional_foreign_enum_extension_lite));

  1109.   EXPECT_EQ(

  1110.       unittest_import::IMPORT_LITE_BAZ,

  1111.       message.GetExtension(unittest::optional_import_enum_extension_lite));

  1112. 

  1113. 

  1114.   // -----------------------------------------------------------------

  1115. 

  1116.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite));

  1117.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite));

  1118.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite));

  1119.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite));

  1120.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite));

  1121.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite));

  1122.   ASSERT_EQ(2,

  1123.             message.ExtensionSize(unittest::repeated_fixed32_extension_lite));

  1124.   ASSERT_EQ(2,

  1125.             message.ExtensionSize(unittest::repeated_fixed64_extension_lite));

  1126.   ASSERT_EQ(2,

  1127.             message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));

  1128.   ASSERT_EQ(2,

  1129.             message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));

  1130.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite));

  1131.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite));

  1132.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite));

  1133.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite));

  1134.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite));

  1135. 

  1136.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite));

  1137.   ASSERT_EQ(2, message.ExtensionSize(

  1138.                    unittest::repeated_nested_message_extension_lite));

  1139.   ASSERT_EQ(2, message.ExtensionSize(

  1140.                    unittest::repeated_foreign_message_extension_lite));

  1141.   ASSERT_EQ(2, message.ExtensionSize(

  1142.                    unittest::repeated_import_message_extension_lite));

  1143.   ASSERT_EQ(

  1144.       2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));

  1145.   ASSERT_EQ(

  1146.       2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));

  1147.   ASSERT_EQ(

  1148.       2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));

  1149.   ASSERT_EQ(

  1150.       2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));

  1151. 

  1152. 

  1153.   EXPECT_EQ(201,

  1154.             message.GetExtension(unittest::repeated_int32_extension_lite, 0));

  1155.   EXPECT_EQ(202,

  1156.             message.GetExtension(unittest::repeated_int64_extension_lite, 0));

  1157.   EXPECT_EQ(203,

  1158.             message.GetExtension(unittest::repeated_uint32_extension_lite, 0));

  1159.   EXPECT_EQ(204,

  1160.             message.GetExtension(unittest::repeated_uint64_extension_lite, 0));

  1161.   EXPECT_EQ(205,

  1162.             message.GetExtension(unittest::repeated_sint32_extension_lite, 0));

  1163.   EXPECT_EQ(206,

  1164.             message.GetExtension(unittest::repeated_sint64_extension_lite, 0));

  1165.   EXPECT_EQ(207,

  1166.             message.GetExtension(unittest::repeated_fixed32_extension_lite, 0));

  1167.   EXPECT_EQ(208,

  1168.             message.GetExtension(unittest::repeated_fixed64_extension_lite, 0));

  1169.   EXPECT_EQ(

  1170.       209, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));

  1171.   EXPECT_EQ(

  1172.       210, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));

  1173.   EXPECT_EQ(211,

  1174.             message.GetExtension(unittest::repeated_float_extension_lite, 0));

  1175.   EXPECT_EQ(212,

  1176.             message.GetExtension(unittest::repeated_double_extension_lite, 0));

  1177.   EXPECT_EQ(true,

  1178.             message.GetExtension(unittest::repeated_bool_extension_lite, 0));

  1179.   EXPECT_EQ("215",

  1180.             message.GetExtension(unittest::repeated_string_extension_lite, 0));

  1181.   EXPECT_EQ("216",

  1182.             message.GetExtension(unittest::repeated_bytes_extension_lite, 0));

  1183. 

  1184.   EXPECT_EQ(

  1185.       217, message.GetExtension(unittest::repeatedgroup_extension_lite, 0).a());

  1186.   EXPECT_EQ(

  1187.       218,

  1188.       message.GetExtension(unittest::repeated_nested_message_extension_lite, 0)

  1189.           .bb());

  1190.   EXPECT_EQ(

  1191.       219,

  1192.       message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0)

  1193.           .c());

  1194.   EXPECT_EQ(

  1195.       220,

  1196.       message.GetExtension(unittest::repeated_import_message_extension_lite, 0)

  1197.           .d());

  1198.   EXPECT_EQ(

  1199.       227,

  1200.       message.GetExtension(unittest::repeated_lazy_message_extension_lite, 0)

  1201.           .bb());

  1202. 

  1203.   EXPECT_EQ(

  1204.       unittest::TestAllTypesLite::BAR,

  1205.       message.GetExtension(unittest::repeated_nested_enum_extension_lite, 0));

  1206.   EXPECT_EQ(

  1207.       unittest::FOREIGN_LITE_BAR,

  1208.       message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));

  1209.   EXPECT_EQ(

  1210.       unittest_import::IMPORT_LITE_BAR,

  1211.       message.GetExtension(unittest::repeated_import_enum_extension_lite, 0));

  1212. 

  1213. 

  1214.   EXPECT_EQ(301,

  1215.             message.GetExtension(unittest::repeated_int32_extension_lite, 1));

  1216.   EXPECT_EQ(302,

  1217.             message.GetExtension(unittest::repeated_int64_extension_lite, 1));

  1218.   EXPECT_EQ(303,

  1219.             message.GetExtension(unittest::repeated_uint32_extension_lite, 1));

  1220.   EXPECT_EQ(304,

  1221.             message.GetExtension(unittest::repeated_uint64_extension_lite, 1));

  1222.   EXPECT_EQ(305,

  1223.             message.GetExtension(unittest::repeated_sint32_extension_lite, 1));

  1224.   EXPECT_EQ(306,

  1225.             message.GetExtension(unittest::repeated_sint64_extension_lite, 1));

  1226.   EXPECT_EQ(307,

  1227.             message.GetExtension(unittest::repeated_fixed32_extension_lite, 1));

  1228.   EXPECT_EQ(308,

  1229.             message.GetExtension(unittest::repeated_fixed64_extension_lite, 1));

  1230.   EXPECT_EQ(

  1231.       309, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));

  1232.   EXPECT_EQ(

  1233.       310, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));

  1234.   EXPECT_EQ(311,

  1235.             message.GetExtension(unittest::repeated_float_extension_lite, 1));

  1236.   EXPECT_EQ(312,

  1237.             message.GetExtension(unittest::repeated_double_extension_lite, 1));

  1238.   EXPECT_EQ(false,

  1239.             message.GetExtension(unittest::repeated_bool_extension_lite, 1));

  1240.   EXPECT_EQ("315",

  1241.             message.GetExtension(unittest::repeated_string_extension_lite, 1));

  1242.   EXPECT_EQ("316",

  1243.             message.GetExtension(unittest::repeated_bytes_extension_lite, 1));

  1244. 

  1245.   EXPECT_EQ(

  1246.       317, message.GetExtension(unittest::repeatedgroup_extension_lite, 1).a());

  1247.   EXPECT_EQ(

  1248.       318,

  1249.       message.GetExtension(unittest::repeated_nested_message_extension_lite, 1)

  1250.           .bb());

  1251.   EXPECT_EQ(

  1252.       319,

  1253.       message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1)

  1254.           .c());

  1255.   EXPECT_EQ(

  1256.       320,

  1257.       message.GetExtension(unittest::repeated_import_message_extension_lite, 1)

  1258.           .d());

  1259.   EXPECT_EQ(

  1260.       327,

  1261.       message.GetExtension(unittest::repeated_lazy_message_extension_lite, 1)

  1262.           .bb());

  1263. 

  1264.   EXPECT_EQ(

  1265.       unittest::TestAllTypesLite::BAZ,

  1266.       message.GetExtension(unittest::repeated_nested_enum_extension_lite, 1));

  1267.   EXPECT_EQ(

  1268.       unittest::FOREIGN_LITE_BAZ,

  1269.       message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));

  1270.   EXPECT_EQ(

  1271.       unittest_import::IMPORT_LITE_BAZ,

  1272.       message.GetExtension(unittest::repeated_import_enum_extension_lite, 1));

  1273. 

  1274. 

  1275.   // -----------------------------------------------------------------

  1276. 

  1277.   EXPECT_TRUE(message.HasExtension(unittest::default_int32_extension_lite));

  1278.   EXPECT_TRUE(message.HasExtension(unittest::default_int64_extension_lite));

  1279.   EXPECT_TRUE(message.HasExtension(unittest::default_uint32_extension_lite));

  1280.   EXPECT_TRUE(message.HasExtension(unittest::default_uint64_extension_lite));

  1281.   EXPECT_TRUE(message.HasExtension(unittest::default_sint32_extension_lite));

  1282.   EXPECT_TRUE(message.HasExtension(unittest::default_sint64_extension_lite));

  1283.   EXPECT_TRUE(message.HasExtension(unittest::default_fixed32_extension_lite));

  1284.   EXPECT_TRUE(message.HasExtension(unittest::default_fixed64_extension_lite));

  1285.   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed32_extension_lite));

  1286.   EXPECT_TRUE(message.HasExtension(unittest::default_sfixed64_extension_lite));

  1287.   EXPECT_TRUE(message.HasExtension(unittest::default_float_extension_lite));

  1288.   EXPECT_TRUE(message.HasExtension(unittest::default_double_extension_lite));

  1289.   EXPECT_TRUE(message.HasExtension(unittest::default_bool_extension_lite));

  1290.   EXPECT_TRUE(message.HasExtension(unittest::default_string_extension_lite));

  1291.   EXPECT_TRUE(message.HasExtension(unittest::default_bytes_extension_lite));

  1292. 

  1293.   EXPECT_TRUE(

  1294.       message.HasExtension(unittest::default_nested_enum_extension_lite));

  1295.   EXPECT_TRUE(

  1296.       message.HasExtension(unittest::default_foreign_enum_extension_lite));

  1297.   EXPECT_TRUE(

  1298.       message.HasExtension(unittest::default_import_enum_extension_lite));

  1299. 

  1300. 

  1301.   EXPECT_EQ(401, message.GetExtension(unittest::default_int32_extension_lite));

  1302.   EXPECT_EQ(402, message.GetExtension(unittest::default_int64_extension_lite));

  1303.   EXPECT_EQ(403, message.GetExtension(unittest::default_uint32_extension_lite));

  1304.   EXPECT_EQ(404, message.GetExtension(unittest::default_uint64_extension_lite));

  1305.   EXPECT_EQ(405, message.GetExtension(unittest::default_sint32_extension_lite));

  1306.   EXPECT_EQ(406, message.GetExtension(unittest::default_sint64_extension_lite));

  1307.   EXPECT_EQ(407,

  1308.             message.GetExtension(unittest::default_fixed32_extension_lite));

  1309.   EXPECT_EQ(408,

  1310.             message.GetExtension(unittest::default_fixed64_extension_lite));

  1311.   EXPECT_EQ(409,

  1312.             message.GetExtension(unittest::default_sfixed32_extension_lite));

  1313.   EXPECT_EQ(410,

  1314.             message.GetExtension(unittest::default_sfixed64_extension_lite));

  1315.   EXPECT_EQ(411, message.GetExtension(unittest::default_float_extension_lite));

  1316.   EXPECT_EQ(412, message.GetExtension(unittest::default_double_extension_lite));

  1317.   EXPECT_EQ(false, message.GetExtension(unittest::default_bool_extension_lite));

  1318.   EXPECT_EQ("415",

  1319.             message.GetExtension(unittest::default_string_extension_lite));

  1320.   EXPECT_EQ("416",

  1321.             message.GetExtension(unittest::default_bytes_extension_lite));

  1322. 

  1323.   EXPECT_EQ(unittest::TestAllTypesLite::FOO,

  1324.             message.GetExtension(unittest::default_nested_enum_extension_lite));

  1325.   EXPECT_EQ(

  1326.       unittest::FOREIGN_LITE_FOO,

  1327.       message.GetExtension(unittest::default_foreign_enum_extension_lite));

  1328.   EXPECT_EQ(unittest_import::IMPORT_LITE_FOO,

  1329.             message.GetExtension(unittest::default_import_enum_extension_lite));

  1330. 

  1331. 

  1332.   EXPECT_TRUE(message.HasExtension(unittest::oneof_uint32_extension_lite));

  1333.   EXPECT_TRUE(

  1334.       message.GetExtension(unittest::oneof_nested_message_extension_lite)

  1335.           .has_bb());

  1336.   EXPECT_TRUE(message.HasExtension(unittest::oneof_string_extension_lite));

  1337.   EXPECT_TRUE(message.HasExtension(unittest::oneof_bytes_extension_lite));

  1338. 

  1339.   EXPECT_EQ(601, message.GetExtension(unittest::oneof_uint32_extension_lite));

  1340.   EXPECT_EQ(

  1341.       602,

  1342.       message.GetExtension(unittest::oneof_nested_message_extension_lite).bb());

  1343.   EXPECT_EQ("603", message.GetExtension(unittest::oneof_string_extension_lite));

  1344.   EXPECT_EQ("604", message.GetExtension(unittest::oneof_bytes_extension_lite));

  1345. }

  1346. 

  1347. // -------------------------------------------------------------------

  1348. 

  1349. void TestUtilLite::ExpectExtensionsClear(

  1350.     const unittest::TestAllExtensionsLite& message) {

  1351.   std::string serialized;

  1352.   ASSERT_TRUE(message.SerializeToString(&serialized));

  1353.   EXPECT_EQ("", serialized);

  1354.   EXPECT_EQ(0, message.ByteSize());

  1355. 

  1356.   // has_blah() should initially be false for all optional fields.

  1357.   EXPECT_FALSE(message.HasExtension(unittest::optional_int32_extension_lite));

  1358.   EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension_lite));

  1359.   EXPECT_FALSE(message.HasExtension(unittest::optional_uint32_extension_lite));

  1360.   EXPECT_FALSE(message.HasExtension(unittest::optional_uint64_extension_lite));

  1361.   EXPECT_FALSE(message.HasExtension(unittest::optional_sint32_extension_lite));

  1362.   EXPECT_FALSE(message.HasExtension(unittest::optional_sint64_extension_lite));

  1363.   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed32_extension_lite));

  1364.   EXPECT_FALSE(message.HasExtension(unittest::optional_fixed64_extension_lite));

  1365.   EXPECT_FALSE(

  1366.       message.HasExtension(unittest::optional_sfixed32_extension_lite));

  1367.   EXPECT_FALSE(

  1368.       message.HasExtension(unittest::optional_sfixed64_extension_lite));

  1369.   EXPECT_FALSE(message.HasExtension(unittest::optional_float_extension_lite));

  1370.   EXPECT_FALSE(message.HasExtension(unittest::optional_double_extension_lite));

  1371.   EXPECT_FALSE(message.HasExtension(unittest::optional_bool_extension_lite));

  1372.   EXPECT_FALSE(message.HasExtension(unittest::optional_string_extension_lite));

  1373.   EXPECT_FALSE(message.HasExtension(unittest::optional_bytes_extension_lite));

  1374. 

  1375.   EXPECT_FALSE(message.HasExtension(unittest::optionalgroup_extension_lite));

  1376.   EXPECT_FALSE(

  1377.       message.HasExtension(unittest::optional_nested_message_extension_lite));

  1378.   EXPECT_FALSE(

  1379.       message.HasExtension(unittest::optional_foreign_message_extension_lite));

  1380.   EXPECT_FALSE(

  1381.       message.HasExtension(unittest::optional_import_message_extension_lite));

  1382.   EXPECT_FALSE(message.HasExtension(

  1383.       unittest::optional_public_import_message_extension_lite));

  1384.   EXPECT_FALSE(

  1385.       message.HasExtension(unittest::optional_lazy_message_extension_lite));

  1386. 

  1387.   EXPECT_FALSE(

  1388.       message.HasExtension(unittest::optional_nested_enum_extension_lite));

  1389.   EXPECT_FALSE(

  1390.       message.HasExtension(unittest::optional_foreign_enum_extension_lite));

  1391.   EXPECT_FALSE(

  1392.       message.HasExtension(unittest::optional_import_enum_extension_lite));

  1393. 

  1394. 

  1395.   // Optional fields without defaults are set to zero or something like it.

  1396.   EXPECT_EQ(0, message.GetExtension(unittest::optional_int32_extension_lite));

  1397.   EXPECT_EQ(0, message.GetExtension(unittest::optional_int64_extension_lite));

  1398.   EXPECT_EQ(0, message.GetExtension(unittest::optional_uint32_extension_lite));

  1399.   EXPECT_EQ(0, message.GetExtension(unittest::optional_uint64_extension_lite));

  1400.   EXPECT_EQ(0, message.GetExtension(unittest::optional_sint32_extension_lite));

  1401.   EXPECT_EQ(0, message.GetExtension(unittest::optional_sint64_extension_lite));

  1402.   EXPECT_EQ(0, message.GetExtension(unittest::optional_fixed32_extension_lite));

  1403.   EXPECT_EQ(0, message.GetExtension(unittest::optional_fixed64_extension_lite));

  1404.   EXPECT_EQ(0,

  1405.             message.GetExtension(unittest::optional_sfixed32_extension_lite));

  1406.   EXPECT_EQ(0,

  1407.             message.GetExtension(unittest::optional_sfixed64_extension_lite));

  1408.   EXPECT_EQ(0, message.GetExtension(unittest::optional_float_extension_lite));

  1409.   EXPECT_EQ(0, message.GetExtension(unittest::optional_double_extension_lite));

  1410.   EXPECT_EQ(false,

  1411.             message.GetExtension(unittest::optional_bool_extension_lite));

  1412.   EXPECT_EQ("", message.GetExtension(unittest::optional_string_extension_lite));

  1413.   EXPECT_EQ("", message.GetExtension(unittest::optional_bytes_extension_lite));

  1414. 

  1415.   // Embedded messages should also be clear.

  1416.   EXPECT_FALSE(

  1417.       message.GetExtension(unittest::optionalgroup_extension_lite).has_a());

  1418.   EXPECT_FALSE(

  1419.       message.GetExtension(unittest::optional_nested_message_extension_lite)

  1420.           .has_bb());

  1421.   EXPECT_FALSE(

  1422.       message.GetExtension(unittest::optional_foreign_message_extension_lite)

  1423.           .has_c());

  1424.   EXPECT_FALSE(

  1425.       message.GetExtension(unittest::optional_import_message_extension_lite)

  1426.           .has_d());

  1427.   EXPECT_FALSE(

  1428.       message

  1429.           .GetExtension(unittest::optional_public_import_message_extension_lite)

  1430.           .has_e());

  1431.   EXPECT_FALSE(

  1432.       message.GetExtension(unittest::optional_lazy_message_extension_lite)

  1433.           .has_bb());

  1434. 

  1435.   EXPECT_EQ(0,

  1436.             message.GetExtension(unittest::optionalgroup_extension_lite).a());

  1437.   EXPECT_EQ(

  1438.       0, message.GetExtension(unittest::optional_nested_message_extension_lite)

  1439.              .bb());

  1440.   EXPECT_EQ(

  1441.       0, message.GetExtension(unittest::optional_foreign_message_extension_lite)

  1442.              .c());

  1443.   EXPECT_EQ(

  1444.       0, message.GetExtension(unittest::optional_import_message_extension_lite)

  1445.              .d());

  1446.   EXPECT_EQ(0, message

  1447.                    .GetExtension(

  1448.                        unittest::optional_public_import_message_extension_lite)

  1449.                    .e());

  1450.   EXPECT_EQ(0,

  1451.             message.GetExtension(unittest::optional_lazy_message_extension_lite)

  1452.                 .bb());

  1453. 

  1454.   // Enums without defaults are set to the first value in the enum.

  1455.   EXPECT_EQ(

  1456.       unittest::TestAllTypesLite::FOO,

  1457.       message.GetExtension(unittest::optional_nested_enum_extension_lite));

  1458.   EXPECT_EQ(

  1459.       unittest::FOREIGN_LITE_FOO,

  1460.       message.GetExtension(unittest::optional_foreign_enum_extension_lite));

  1461.   EXPECT_EQ(

  1462.       unittest_import::IMPORT_LITE_FOO,

  1463.       message.GetExtension(unittest::optional_import_enum_extension_lite));

  1464. 

  1465. 

  1466.   // Repeated fields are empty.

  1467.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int32_extension_lite));

  1468.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_int64_extension_lite));

  1469.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint32_extension_lite));

  1470.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_uint64_extension_lite));

  1471.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint32_extension_lite));

  1472.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_sint64_extension_lite));

  1473.   EXPECT_EQ(0,

  1474.             message.ExtensionSize(unittest::repeated_fixed32_extension_lite));

  1475.   EXPECT_EQ(0,

  1476.             message.ExtensionSize(unittest::repeated_fixed64_extension_lite));

  1477.   EXPECT_EQ(0,

  1478.             message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));

  1479.   EXPECT_EQ(0,

  1480.             message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));

  1481.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_float_extension_lite));

  1482.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_double_extension_lite));

  1483.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bool_extension_lite));

  1484.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_string_extension_lite));

  1485.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeated_bytes_extension_lite));

  1486. 

  1487.   EXPECT_EQ(0, message.ExtensionSize(unittest::repeatedgroup_extension_lite));

  1488.   EXPECT_EQ(0, message.ExtensionSize(

  1489.                    unittest::repeated_nested_message_extension_lite));

  1490.   EXPECT_EQ(0, message.ExtensionSize(

  1491.                    unittest::repeated_foreign_message_extension_lite));

  1492.   EXPECT_EQ(0, message.ExtensionSize(

  1493.                    unittest::repeated_import_message_extension_lite));

  1494.   EXPECT_EQ(

  1495.       0, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));

  1496.   EXPECT_EQ(

  1497.       0, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));

  1498.   EXPECT_EQ(

  1499.       0, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));

  1500.   EXPECT_EQ(

  1501.       0, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));

  1502. 

  1503. 

  1504.   // has_blah() should also be false for all default fields.

  1505.   EXPECT_FALSE(message.HasExtension(unittest::default_int32_extension_lite));

  1506.   EXPECT_FALSE(message.HasExtension(unittest::default_int64_extension_lite));

  1507.   EXPECT_FALSE(message.HasExtension(unittest::default_uint32_extension_lite));

  1508.   EXPECT_FALSE(message.HasExtension(unittest::default_uint64_extension_lite));

  1509.   EXPECT_FALSE(message.HasExtension(unittest::default_sint32_extension_lite));

  1510.   EXPECT_FALSE(message.HasExtension(unittest::default_sint64_extension_lite));

  1511.   EXPECT_FALSE(message.HasExtension(unittest::default_fixed32_extension_lite));

  1512.   EXPECT_FALSE(message.HasExtension(unittest::default_fixed64_extension_lite));

  1513.   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed32_extension_lite));

  1514.   EXPECT_FALSE(message.HasExtension(unittest::default_sfixed64_extension_lite));

  1515.   EXPECT_FALSE(message.HasExtension(unittest::default_float_extension_lite));

  1516.   EXPECT_FALSE(message.HasExtension(unittest::default_double_extension_lite));

  1517.   EXPECT_FALSE(message.HasExtension(unittest::default_bool_extension_lite));

  1518.   EXPECT_FALSE(message.HasExtension(unittest::default_string_extension_lite));

  1519.   EXPECT_FALSE(message.HasExtension(unittest::default_bytes_extension_lite));

  1520. 

  1521.   EXPECT_FALSE(

  1522.       message.HasExtension(unittest::default_nested_enum_extension_lite));

  1523.   EXPECT_FALSE(

  1524.       message.HasExtension(unittest::default_foreign_enum_extension_lite));

  1525.   EXPECT_FALSE(

  1526.       message.HasExtension(unittest::default_import_enum_extension_lite));

  1527. 

  1528. 

  1529.   // Fields with defaults have their default values (duh).

  1530.   EXPECT_EQ(41, message.GetExtension(unittest::default_int32_extension_lite));

  1531.   EXPECT_EQ(42, message.GetExtension(unittest::default_int64_extension_lite));

  1532.   EXPECT_EQ(43, message.GetExtension(unittest::default_uint32_extension_lite));

  1533.   EXPECT_EQ(44, message.GetExtension(unittest::default_uint64_extension_lite));

  1534.   EXPECT_EQ(-45, message.GetExtension(unittest::default_sint32_extension_lite));

  1535.   EXPECT_EQ(46, message.GetExtension(unittest::default_sint64_extension_lite));

  1536.   EXPECT_EQ(47, message.GetExtension(unittest::default_fixed32_extension_lite));

  1537.   EXPECT_EQ(48, message.GetExtension(unittest::default_fixed64_extension_lite));

  1538.   EXPECT_EQ(49,

  1539.             message.GetExtension(unittest::default_sfixed32_extension_lite));

  1540.   EXPECT_EQ(-50,

  1541.             message.GetExtension(unittest::default_sfixed64_extension_lite));

  1542.   EXPECT_EQ(51.5, message.GetExtension(unittest::default_float_extension_lite));

  1543.   EXPECT_EQ(52e3,

  1544.             message.GetExtension(unittest::default_double_extension_lite));

  1545.   EXPECT_EQ(true, message.GetExtension(unittest::default_bool_extension_lite));

  1546.   EXPECT_EQ("hello",

  1547.             message.GetExtension(unittest::default_string_extension_lite));

  1548.   EXPECT_EQ("world",

  1549.             message.GetExtension(unittest::default_bytes_extension_lite));

  1550. 

  1551.   EXPECT_EQ(unittest::TestAllTypesLite::BAR,

  1552.             message.GetExtension(unittest::default_nested_enum_extension_lite));

  1553.   EXPECT_EQ(

  1554.       unittest::FOREIGN_LITE_BAR,

  1555.       message.GetExtension(unittest::default_foreign_enum_extension_lite));

  1556.   EXPECT_EQ(unittest_import::IMPORT_LITE_BAR,

  1557.             message.GetExtension(unittest::default_import_enum_extension_lite));

  1558. 

  1559. 

  1560.   EXPECT_FALSE(message.HasExtension(unittest::oneof_uint32_extension_lite));

  1561.   EXPECT_FALSE(

  1562.       message.GetExtension(unittest::oneof_nested_message_extension_lite)

  1563.           .has_bb());

  1564.   EXPECT_FALSE(message.HasExtension(unittest::oneof_string_extension_lite));

  1565.   EXPECT_FALSE(message.HasExtension(unittest::oneof_bytes_extension_lite));

  1566. }

  1567. 

  1568. // -------------------------------------------------------------------

  1569. 

  1570. void TestUtilLite::ExpectRepeatedExtensionsModified(

  1571.     const unittest::TestAllExtensionsLite& message) {

  1572.   // ModifyRepeatedFields only sets the second repeated element of each

  1573.   // field.  In addition to verifying this, we also verify that the first

  1574.   // element and size were *not* modified.

  1575.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int32_extension_lite));

  1576.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_int64_extension_lite));

  1577.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint32_extension_lite));

  1578.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_uint64_extension_lite));

  1579.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint32_extension_lite));

  1580.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_sint64_extension_lite));

  1581.   ASSERT_EQ(2,

  1582.             message.ExtensionSize(unittest::repeated_fixed32_extension_lite));

  1583.   ASSERT_EQ(2,

  1584.             message.ExtensionSize(unittest::repeated_fixed64_extension_lite));

  1585.   ASSERT_EQ(2,

  1586.             message.ExtensionSize(unittest::repeated_sfixed32_extension_lite));

  1587.   ASSERT_EQ(2,

  1588.             message.ExtensionSize(unittest::repeated_sfixed64_extension_lite));

  1589.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_float_extension_lite));

  1590.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_double_extension_lite));

  1591.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bool_extension_lite));

  1592.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_string_extension_lite));

  1593.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeated_bytes_extension_lite));

  1594. 

  1595.   ASSERT_EQ(2, message.ExtensionSize(unittest::repeatedgroup_extension_lite));

  1596.   ASSERT_EQ(2, message.ExtensionSize(

  1597.                    unittest::repeated_nested_message_extension_lite));

  1598.   ASSERT_EQ(2, message.ExtensionSize(

  1599.                    unittest::repeated_foreign_message_extension_lite));

  1600.   ASSERT_EQ(2, message.ExtensionSize(

  1601.                    unittest::repeated_import_message_extension_lite));

  1602.   ASSERT_EQ(

  1603.       2, message.ExtensionSize(unittest::repeated_lazy_message_extension_lite));

  1604.   ASSERT_EQ(

  1605.       2, message.ExtensionSize(unittest::repeated_nested_enum_extension_lite));

  1606.   ASSERT_EQ(

  1607.       2, message.ExtensionSize(unittest::repeated_foreign_enum_extension_lite));

  1608.   ASSERT_EQ(

  1609.       2, message.ExtensionSize(unittest::repeated_import_enum_extension_lite));

  1610. 

  1611. 

  1612.   EXPECT_EQ(201,

  1613.             message.GetExtension(unittest::repeated_int32_extension_lite, 0));

  1614.   EXPECT_EQ(202,

  1615.             message.GetExtension(unittest::repeated_int64_extension_lite, 0));

  1616.   EXPECT_EQ(203,

  1617.             message.GetExtension(unittest::repeated_uint32_extension_lite, 0));

  1618.   EXPECT_EQ(204,

  1619.             message.GetExtension(unittest::repeated_uint64_extension_lite, 0));

  1620.   EXPECT_EQ(205,

  1621.             message.GetExtension(unittest::repeated_sint32_extension_lite, 0));

  1622.   EXPECT_EQ(206,

  1623.             message.GetExtension(unittest::repeated_sint64_extension_lite, 0));

  1624.   EXPECT_EQ(207,

  1625.             message.GetExtension(unittest::repeated_fixed32_extension_lite, 0));

  1626.   EXPECT_EQ(208,

  1627.             message.GetExtension(unittest::repeated_fixed64_extension_lite, 0));

  1628.   EXPECT_EQ(

  1629.       209, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 0));

  1630.   EXPECT_EQ(

  1631.       210, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 0));

  1632.   EXPECT_EQ(211,

  1633.             message.GetExtension(unittest::repeated_float_extension_lite, 0));

  1634.   EXPECT_EQ(212,

  1635.             message.GetExtension(unittest::repeated_double_extension_lite, 0));

  1636.   EXPECT_EQ(true,

  1637.             message.GetExtension(unittest::repeated_bool_extension_lite, 0));

  1638.   EXPECT_EQ("215",

  1639.             message.GetExtension(unittest::repeated_string_extension_lite, 0));

  1640.   EXPECT_EQ("216",

  1641.             message.GetExtension(unittest::repeated_bytes_extension_lite, 0));

  1642. 

  1643.   EXPECT_EQ(

  1644.       217, message.GetExtension(unittest::repeatedgroup_extension_lite, 0).a());

  1645.   EXPECT_EQ(

  1646.       218,

  1647.       message.GetExtension(unittest::repeated_nested_message_extension_lite, 0)

  1648.           .bb());

  1649.   EXPECT_EQ(

  1650.       219,

  1651.       message.GetExtension(unittest::repeated_foreign_message_extension_lite, 0)

  1652.           .c());

  1653.   EXPECT_EQ(

  1654.       220,

  1655.       message.GetExtension(unittest::repeated_import_message_extension_lite, 0)

  1656.           .d());

  1657.   EXPECT_EQ(

  1658.       227,

  1659.       message.GetExtension(unittest::repeated_lazy_message_extension_lite, 0)

  1660.           .bb());

  1661. 

  1662.   EXPECT_EQ(

  1663.       unittest::TestAllTypesLite::BAR,

  1664.       message.GetExtension(unittest::repeated_nested_enum_extension_lite, 0));

  1665.   EXPECT_EQ(

  1666.       unittest::FOREIGN_LITE_BAR,

  1667.       message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 0));

  1668.   EXPECT_EQ(

  1669.       unittest_import::IMPORT_LITE_BAR,

  1670.       message.GetExtension(unittest::repeated_import_enum_extension_lite, 0));

  1671. 

  1672. 

  1673.   // Actually verify the second (modified) elements now.

  1674.   EXPECT_EQ(501,

  1675.             message.GetExtension(unittest::repeated_int32_extension_lite, 1));

  1676.   EXPECT_EQ(502,

  1677.             message.GetExtension(unittest::repeated_int64_extension_lite, 1));

  1678.   EXPECT_EQ(503,

  1679.             message.GetExtension(unittest::repeated_uint32_extension_lite, 1));

  1680.   EXPECT_EQ(504,

  1681.             message.GetExtension(unittest::repeated_uint64_extension_lite, 1));

  1682.   EXPECT_EQ(505,

  1683.             message.GetExtension(unittest::repeated_sint32_extension_lite, 1));

  1684.   EXPECT_EQ(506,

  1685.             message.GetExtension(unittest::repeated_sint64_extension_lite, 1));

  1686.   EXPECT_EQ(507,

  1687.             message.GetExtension(unittest::repeated_fixed32_extension_lite, 1));

  1688.   EXPECT_EQ(508,

  1689.             message.GetExtension(unittest::repeated_fixed64_extension_lite, 1));

  1690.   EXPECT_EQ(

  1691.       509, message.GetExtension(unittest::repeated_sfixed32_extension_lite, 1));

  1692.   EXPECT_EQ(

  1693.       510, message.GetExtension(unittest::repeated_sfixed64_extension_lite, 1));

  1694.   EXPECT_EQ(511,

  1695.             message.GetExtension(unittest::repeated_float_extension_lite, 1));

  1696.   EXPECT_EQ(512,

  1697.             message.GetExtension(unittest::repeated_double_extension_lite, 1));

  1698.   EXPECT_EQ(true,

  1699.             message.GetExtension(unittest::repeated_bool_extension_lite, 1));

  1700.   EXPECT_EQ("515",

  1701.             message.GetExtension(unittest::repeated_string_extension_lite, 1));

  1702.   EXPECT_EQ("516",

  1703.             message.GetExtension(unittest::repeated_bytes_extension_lite, 1));

  1704. 

  1705.   EXPECT_EQ(

  1706.       517, message.GetExtension(unittest::repeatedgroup_extension_lite, 1).a());

  1707.   EXPECT_EQ(

  1708.       518,

  1709.       message.GetExtension(unittest::repeated_nested_message_extension_lite, 1)

  1710.           .bb());

  1711.   EXPECT_EQ(

  1712.       519,

  1713.       message.GetExtension(unittest::repeated_foreign_message_extension_lite, 1)

  1714.           .c());

  1715.   EXPECT_EQ(

  1716.       520,

  1717.       message.GetExtension(unittest::repeated_import_message_extension_lite, 1)

  1718.           .d());

  1719.   EXPECT_EQ(

  1720.       527,

  1721.       message.GetExtension(unittest::repeated_lazy_message_extension_lite, 1)

  1722.           .bb());

  1723. 

  1724.   EXPECT_EQ(

  1725.       unittest::TestAllTypesLite::FOO,

  1726.       message.GetExtension(unittest::repeated_nested_enum_extension_lite, 1));

  1727.   EXPECT_EQ(

  1728.       unittest::FOREIGN_LITE_FOO,

  1729.       message.GetExtension(unittest::repeated_foreign_enum_extension_lite, 1));

  1730.   EXPECT_EQ(

  1731.       unittest_import::IMPORT_LITE_FOO,

  1732.       message.GetExtension(unittest::repeated_import_enum_extension_lite, 1));

  1733. 

  1734. }

  1735. 

  1736. // -------------------------------------------------------------------

  1737. 

  1738. void TestUtilLite::SetPackedExtensions(

  1739.     unittest::TestPackedExtensionsLite* message) {

  1740.   message->AddExtension(unittest::packed_int32_extension_lite, 601);

  1741.   message->AddExtension(unittest::packed_int64_extension_lite, 602);

  1742.   message->AddExtension(unittest::packed_uint32_extension_lite, 603);

  1743.   message->AddExtension(unittest::packed_uint64_extension_lite, 604);

  1744.   message->AddExtension(unittest::packed_sint32_extension_lite, 605);

  1745.   message->AddExtension(unittest::packed_sint64_extension_lite, 606);

  1746.   message->AddExtension(unittest::packed_fixed32_extension_lite, 607);

  1747.   message->AddExtension(unittest::packed_fixed64_extension_lite, 608);

  1748.   message->AddExtension(unittest::packed_sfixed32_extension_lite, 609);

  1749.   message->AddExtension(unittest::packed_sfixed64_extension_lite, 610);

  1750.   message->AddExtension(unittest::packed_float_extension_lite, 611);

  1751.   message->AddExtension(unittest::packed_double_extension_lite, 612);

  1752.   message->AddExtension(unittest::packed_bool_extension_lite, true);

  1753.   message->AddExtension(unittest::packed_enum_extension_lite,

  1754.                         unittest::FOREIGN_LITE_BAR);

  1755.   // add a second one of each field

  1756.   message->AddExtension(unittest::packed_int32_extension_lite, 701);

  1757.   message->AddExtension(unittest::packed_int64_extension_lite, 702);

  1758.   message->AddExtension(unittest::packed_uint32_extension_lite, 703);

  1759.   message->AddExtension(unittest::packed_uint64_extension_lite, 704);

  1760.   message->AddExtension(unittest::packed_sint32_extension_lite, 705);

  1761.   message->AddExtension(unittest::packed_sint64_extension_lite, 706);

  1762.   message->AddExtension(unittest::packed_fixed32_extension_lite, 707);

  1763.   message->AddExtension(unittest::packed_fixed64_extension_lite, 708);

  1764.   message->AddExtension(unittest::packed_sfixed32_extension_lite, 709);

  1765.   message->AddExtension(unittest::packed_sfixed64_extension_lite, 710);

  1766.   message->AddExtension(unittest::packed_float_extension_lite, 711);

  1767.   message->AddExtension(unittest::packed_double_extension_lite, 712);

  1768.   message->AddExtension(unittest::packed_bool_extension_lite, false);

  1769.   message->AddExtension(unittest::packed_enum_extension_lite,

  1770.                         unittest::FOREIGN_LITE_BAZ);

  1771. }

  1772. 

  1773. // -------------------------------------------------------------------

  1774. 

  1775. void TestUtilLite::ModifyPackedExtensions(

  1776.     unittest::TestPackedExtensionsLite* message) {

  1777.   message->SetExtension(unittest::packed_int32_extension_lite, 1, 801);

  1778.   message->SetExtension(unittest::packed_int64_extension_lite, 1, 802);

  1779.   message->SetExtension(unittest::packed_uint32_extension_lite, 1, 803);

  1780.   message->SetExtension(unittest::packed_uint64_extension_lite, 1, 804);

  1781.   message->SetExtension(unittest::packed_sint32_extension_lite, 1, 805);

  1782.   message->SetExtension(unittest::packed_sint64_extension_lite, 1, 806);

  1783.   message->SetExtension(unittest::packed_fixed32_extension_lite, 1, 807);

  1784.   message->SetExtension(unittest::packed_fixed64_extension_lite, 1, 808);

  1785.   message->SetExtension(unittest::packed_sfixed32_extension_lite, 1, 809);

  1786.   message->SetExtension(unittest::packed_sfixed64_extension_lite, 1, 810);

  1787.   message->SetExtension(unittest::packed_float_extension_lite, 1, 811);

  1788.   message->SetExtension(unittest::packed_double_extension_lite, 1, 812);

  1789.   message->SetExtension(unittest::packed_bool_extension_lite, 1, true);

  1790.   message->SetExtension(unittest::packed_enum_extension_lite, 1,

  1791.                         unittest::FOREIGN_LITE_FOO);

  1792. }

  1793. 

  1794. // -------------------------------------------------------------------

  1795. 

  1796. void TestUtilLite::ExpectPackedExtensionsSet(

  1797.     const unittest::TestPackedExtensionsLite& message) {

  1798.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite));

  1799.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite));

  1800.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite));

  1801.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite));

  1802.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite));

  1803.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite));

  1804.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite));

  1805.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite));

  1806.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));

  1807.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));

  1808.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite));

  1809.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite));

  1810.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite));

  1811.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite));

  1812. 

  1813.   EXPECT_EQ(601,

  1814.             message.GetExtension(unittest::packed_int32_extension_lite, 0));

  1815.   EXPECT_EQ(602,

  1816.             message.GetExtension(unittest::packed_int64_extension_lite, 0));

  1817.   EXPECT_EQ(603,

  1818.             message.GetExtension(unittest::packed_uint32_extension_lite, 0));

  1819.   EXPECT_EQ(604,

  1820.             message.GetExtension(unittest::packed_uint64_extension_lite, 0));

  1821.   EXPECT_EQ(605,

  1822.             message.GetExtension(unittest::packed_sint32_extension_lite, 0));

  1823.   EXPECT_EQ(606,

  1824.             message.GetExtension(unittest::packed_sint64_extension_lite, 0));

  1825.   EXPECT_EQ(607,

  1826.             message.GetExtension(unittest::packed_fixed32_extension_lite, 0));

  1827.   EXPECT_EQ(608,

  1828.             message.GetExtension(unittest::packed_fixed64_extension_lite, 0));

  1829.   EXPECT_EQ(609,

  1830.             message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));

  1831.   EXPECT_EQ(610,

  1832.             message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));

  1833.   EXPECT_EQ(611,

  1834.             message.GetExtension(unittest::packed_float_extension_lite, 0));

  1835.   EXPECT_EQ(612,

  1836.             message.GetExtension(unittest::packed_double_extension_lite, 0));

  1837.   EXPECT_EQ(true,

  1838.             message.GetExtension(unittest::packed_bool_extension_lite, 0));

  1839.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR,

  1840.             message.GetExtension(unittest::packed_enum_extension_lite, 0));

  1841.   EXPECT_EQ(701,

  1842.             message.GetExtension(unittest::packed_int32_extension_lite, 1));

  1843.   EXPECT_EQ(702,

  1844.             message.GetExtension(unittest::packed_int64_extension_lite, 1));

  1845.   EXPECT_EQ(703,

  1846.             message.GetExtension(unittest::packed_uint32_extension_lite, 1));

  1847.   EXPECT_EQ(704,

  1848.             message.GetExtension(unittest::packed_uint64_extension_lite, 1));

  1849.   EXPECT_EQ(705,

  1850.             message.GetExtension(unittest::packed_sint32_extension_lite, 1));

  1851.   EXPECT_EQ(706,

  1852.             message.GetExtension(unittest::packed_sint64_extension_lite, 1));

  1853.   EXPECT_EQ(707,

  1854.             message.GetExtension(unittest::packed_fixed32_extension_lite, 1));

  1855.   EXPECT_EQ(708,

  1856.             message.GetExtension(unittest::packed_fixed64_extension_lite, 1));

  1857.   EXPECT_EQ(709,

  1858.             message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));

  1859.   EXPECT_EQ(710,

  1860.             message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));

  1861.   EXPECT_EQ(711,

  1862.             message.GetExtension(unittest::packed_float_extension_lite, 1));

  1863.   EXPECT_EQ(712,

  1864.             message.GetExtension(unittest::packed_double_extension_lite, 1));

  1865.   EXPECT_EQ(false,

  1866.             message.GetExtension(unittest::packed_bool_extension_lite, 1));

  1867.   EXPECT_EQ(unittest::FOREIGN_LITE_BAZ,

  1868.             message.GetExtension(unittest::packed_enum_extension_lite, 1));

  1869. }

  1870. 

  1871. // -------------------------------------------------------------------

  1872. 

  1873. void TestUtilLite::ExpectPackedExtensionsClear(

  1874.     const unittest::TestPackedExtensionsLite& message) {

  1875.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int32_extension_lite));

  1876.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_int64_extension_lite));

  1877.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint32_extension_lite));

  1878.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_uint64_extension_lite));

  1879.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint32_extension_lite));

  1880.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sint64_extension_lite));

  1881.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed32_extension_lite));

  1882.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_fixed64_extension_lite));

  1883.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));

  1884.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));

  1885.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_float_extension_lite));

  1886.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_double_extension_lite));

  1887.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_bool_extension_lite));

  1888.   EXPECT_EQ(0, message.ExtensionSize(unittest::packed_enum_extension_lite));

  1889. }

  1890. 

  1891. // -------------------------------------------------------------------

  1892. 

  1893. void TestUtilLite::ExpectPackedExtensionsModified(

  1894.     const unittest::TestPackedExtensionsLite& message) {

  1895.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int32_extension_lite));

  1896.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_int64_extension_lite));

  1897.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint32_extension_lite));

  1898.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_uint64_extension_lite));

  1899.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint32_extension_lite));

  1900.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sint64_extension_lite));

  1901.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed32_extension_lite));

  1902.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_fixed64_extension_lite));

  1903.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed32_extension_lite));

  1904.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_sfixed64_extension_lite));

  1905.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_float_extension_lite));

  1906.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_double_extension_lite));

  1907.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_bool_extension_lite));

  1908.   ASSERT_EQ(2, message.ExtensionSize(unittest::packed_enum_extension_lite));

  1909.   EXPECT_EQ(601,

  1910.             message.GetExtension(unittest::packed_int32_extension_lite, 0));

  1911.   EXPECT_EQ(602,

  1912.             message.GetExtension(unittest::packed_int64_extension_lite, 0));

  1913.   EXPECT_EQ(603,

  1914.             message.GetExtension(unittest::packed_uint32_extension_lite, 0));

  1915.   EXPECT_EQ(604,

  1916.             message.GetExtension(unittest::packed_uint64_extension_lite, 0));

  1917.   EXPECT_EQ(605,

  1918.             message.GetExtension(unittest::packed_sint32_extension_lite, 0));

  1919.   EXPECT_EQ(606,

  1920.             message.GetExtension(unittest::packed_sint64_extension_lite, 0));

  1921.   EXPECT_EQ(607,

  1922.             message.GetExtension(unittest::packed_fixed32_extension_lite, 0));

  1923.   EXPECT_EQ(608,

  1924.             message.GetExtension(unittest::packed_fixed64_extension_lite, 0));

  1925.   EXPECT_EQ(609,

  1926.             message.GetExtension(unittest::packed_sfixed32_extension_lite, 0));

  1927.   EXPECT_EQ(610,

  1928.             message.GetExtension(unittest::packed_sfixed64_extension_lite, 0));

  1929.   EXPECT_EQ(611,

  1930.             message.GetExtension(unittest::packed_float_extension_lite, 0));

  1931.   EXPECT_EQ(612,

  1932.             message.GetExtension(unittest::packed_double_extension_lite, 0));

  1933.   EXPECT_EQ(true,

  1934.             message.GetExtension(unittest::packed_bool_extension_lite, 0));

  1935.   EXPECT_EQ(unittest::FOREIGN_LITE_BAR,

  1936.             message.GetExtension(unittest::packed_enum_extension_lite, 0));

  1937. 

  1938.   // Actually verify the second (modified) elements now.

  1939.   EXPECT_EQ(801,

  1940.             message.GetExtension(unittest::packed_int32_extension_lite, 1));

  1941.   EXPECT_EQ(802,

  1942.             message.GetExtension(unittest::packed_int64_extension_lite, 1));

  1943.   EXPECT_EQ(803,

  1944.             message.GetExtension(unittest::packed_uint32_extension_lite, 1));

  1945.   EXPECT_EQ(804,

  1946.             message.GetExtension(unittest::packed_uint64_extension_lite, 1));

  1947.   EXPECT_EQ(805,

  1948.             message.GetExtension(unittest::packed_sint32_extension_lite, 1));

  1949.   EXPECT_EQ(806,

  1950.             message.GetExtension(unittest::packed_sint64_extension_lite, 1));

  1951.   EXPECT_EQ(807,

  1952.             message.GetExtension(unittest::packed_fixed32_extension_lite, 1));

  1953.   EXPECT_EQ(808,

  1954.             message.GetExtension(unittest::packed_fixed64_extension_lite, 1));

  1955.   EXPECT_EQ(809,

  1956.             message.GetExtension(unittest::packed_sfixed32_extension_lite, 1));

  1957.   EXPECT_EQ(810,

  1958.             message.GetExtension(unittest::packed_sfixed64_extension_lite, 1));

  1959.   EXPECT_EQ(811,

  1960.             message.GetExtension(unittest::packed_float_extension_lite, 1));

  1961.   EXPECT_EQ(812,

  1962.             message.GetExtension(unittest::packed_double_extension_lite, 1));

  1963.   EXPECT_EQ(true,

  1964.             message.GetExtension(unittest::packed_bool_extension_lite, 1));

  1965.   EXPECT_EQ(unittest::FOREIGN_LITE_FOO,

  1966.             message.GetExtension(unittest::packed_enum_extension_lite, 1));

  1967. }

  1968. 

  1969. }  // namespace protobuf

  1970. }  // namespace google