zhaobu
/
zhujimajiang_redis
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
诸暨麻将添加redis
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
19 Commits
2 Branches
57 MiB
 
 
 
 
 
 
Tree: b4b92574b0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b4b92574b0'
${ noResults }
zhujimajiang_redis/俱乐部/Source/Protobuf/google/protobuf/test_util.h

1264 lines
63 KiB
Raw Blame History 

  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. #ifndef GOOGLE_PROTOBUF_TEST_UTIL_H__

  36. #define GOOGLE_PROTOBUF_TEST_UTIL_H__

  37. 

  38. #include <google/protobuf/unittest.pb.h>

  39. 

  40. #define UNITTEST ::protobuf_unittest

  41. #define UNITTEST_IMPORT ::protobuf_unittest_import

  42. // Must be included when the preprocessor symbols above are defined.

  43. #include <google/protobuf/test_util.inc>

  44. #undef UNITTEST

  45. #undef UNITTEST_IMPORT

  46. 

  47. #include <google/protobuf/port_def.inc>

  48. 

  49. namespace google {

  50. namespace protobuf {

  51. // This file doesn't use these declarations, but some .cc files do.

  52. namespace unittest = ::protobuf_unittest;

  53. namespace unittest_import = ::protobuf_unittest_import;

  54. 

  55. namespace TestUtil {

  56. 

  57. class ReflectionTester {

  58.  public:

  59.   // base_descriptor must be a descriptor for TestAllTypes or

  60.   // TestAllExtensions.  In the former case, ReflectionTester fetches from

  61.   // it the FieldDescriptors needed to use the reflection interface.  In

  62.   // the latter case, ReflectionTester searches for extension fields in

  63.   // its file.

  64.   explicit ReflectionTester(const Descriptor* base_descriptor);

  65. 

  66.   void SetAllFieldsViaReflection(Message* message);

  67.   void ModifyRepeatedFieldsViaReflection(Message* message);

  68.   void ExpectAllFieldsSetViaReflection(const Message& message);

  69.   void ExpectClearViaReflection(const Message& message);

  70. 

  71.   void SetPackedFieldsViaReflection(Message* message);

  72.   void ExpectPackedFieldsSetViaReflection(const Message& message);

  73. 

  74.   void RemoveLastRepeatedsViaReflection(Message* message);

  75.   void ReleaseLastRepeatedsViaReflection(Message* message,

  76.                                          bool expect_extensions_notnull);

  77.   void SwapRepeatedsViaReflection(Message* message);

  78.   void SetAllocatedOptionalMessageFieldsToNullViaReflection(Message* message);

  79.   static void SetAllocatedOptionalMessageFieldsToMessageViaReflection(

  80.       Message* from_message, Message* to_message);

  81. 

  82.   enum MessageReleaseState {

  83.     IS_NULL,

  84.     CAN_BE_NULL,

  85.     NOT_NULL,

  86.   };

  87.   void ExpectMessagesReleasedViaReflection(

  88.       Message* message, MessageReleaseState expected_release_state);

  89. 

  90.   // Set and check functions for TestOneof2 messages. No need to construct

  91.   // the ReflectionTester by TestAllTypes nor TestAllExtensions.

  92.   static void SetOneofViaReflection(Message* message);

  93.   static void ExpectOneofSetViaReflection(const Message& message);

  94. 

  95.  private:

  96.   const FieldDescriptor* F(const std::string& name);

  97. 

  98.   const Descriptor* base_descriptor_;

  99. 

  100.   const FieldDescriptor* group_a_;

  101.   const FieldDescriptor* repeated_group_a_;

  102.   const FieldDescriptor* nested_b_;

  103.   const FieldDescriptor* foreign_c_;

  104.   const FieldDescriptor* import_d_;

  105.   const FieldDescriptor* import_e_;

  106. 

  107.   const EnumValueDescriptor* nested_foo_;

  108.   const EnumValueDescriptor* nested_bar_;

  109.   const EnumValueDescriptor* nested_baz_;

  110.   const EnumValueDescriptor* foreign_foo_;

  111.   const EnumValueDescriptor* foreign_bar_;

  112.   const EnumValueDescriptor* foreign_baz_;

  113.   const EnumValueDescriptor* import_foo_;

  114.   const EnumValueDescriptor* import_bar_;

  115.   const EnumValueDescriptor* import_baz_;

  116. 

  117.   // We have to split this into three function otherwise it creates a stack

  118.   // frame so large that it triggers a warning.

  119.   void ExpectAllFieldsSetViaReflection1(const Message& message);

  120.   void ExpectAllFieldsSetViaReflection2(const Message& message);

  121.   void ExpectAllFieldsSetViaReflection3(const Message& message);

  122. 

  123.   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReflectionTester);

  124. };

  125. 

  126. inline TestUtil::ReflectionTester::ReflectionTester(

  127.     const Descriptor* base_descriptor)

  128.     : base_descriptor_(base_descriptor) {

  129.   const DescriptorPool* pool = base_descriptor->file()->pool();

  130.   std::string package = base_descriptor->file()->package();

  131.   const FieldDescriptor* import_descriptor =

  132.       pool->FindFieldByName(package + ".TestAllTypes.optional_import_message");

  133.   std::string import_package =

  134.       import_descriptor->message_type()->file()->package();

  135. 

  136.   nested_b_ = pool->FindFieldByName(package + ".TestAllTypes.NestedMessage.bb");

  137.   foreign_c_ = pool->FindFieldByName(package + ".ForeignMessage.c");

  138.   import_d_ = pool->FindFieldByName(import_package + ".ImportMessage.d");

  139.   import_e_ = pool->FindFieldByName(import_package + ".PublicImportMessage.e");

  140.   nested_foo_ = pool->FindEnumValueByName(package + ".TestAllTypes.FOO");

  141.   nested_bar_ = pool->FindEnumValueByName(package + ".TestAllTypes.BAR");

  142.   nested_baz_ = pool->FindEnumValueByName(package + ".TestAllTypes.BAZ");

  143.   foreign_foo_ = pool->FindEnumValueByName(package + ".FOREIGN_FOO");

  144.   foreign_bar_ = pool->FindEnumValueByName(package + ".FOREIGN_BAR");

  145.   foreign_baz_ = pool->FindEnumValueByName(package + ".FOREIGN_BAZ");

  146.   import_foo_ = pool->FindEnumValueByName(import_package + ".IMPORT_FOO");

  147.   import_bar_ = pool->FindEnumValueByName(import_package + ".IMPORT_BAR");

  148.   import_baz_ = pool->FindEnumValueByName(import_package + ".IMPORT_BAZ");

  149. 

  150.   if (base_descriptor_->name() == "TestAllExtensions") {

  151.     group_a_ = pool->FindFieldByName(package + ".OptionalGroup_extension.a");

  152.     repeated_group_a_ =

  153.         pool->FindFieldByName(package + ".RepeatedGroup_extension.a");

  154.   } else {

  155.     group_a_ = pool->FindFieldByName(package + ".TestAllTypes.OptionalGroup.a");

  156.     repeated_group_a_ =

  157.         pool->FindFieldByName(package + ".TestAllTypes.RepeatedGroup.a");

  158.   }

  159. 

  160.   EXPECT_TRUE(group_a_ != nullptr);

  161.   EXPECT_TRUE(repeated_group_a_ != nullptr);

  162.   EXPECT_TRUE(nested_b_ != nullptr);

  163.   EXPECT_TRUE(foreign_c_ != nullptr);

  164.   EXPECT_TRUE(import_d_ != nullptr);

  165.   EXPECT_TRUE(import_e_ != nullptr);

  166.   EXPECT_TRUE(nested_foo_ != nullptr);

  167.   EXPECT_TRUE(nested_bar_ != nullptr);

  168.   EXPECT_TRUE(nested_baz_ != nullptr);

  169.   EXPECT_TRUE(foreign_foo_ != nullptr);

  170.   EXPECT_TRUE(foreign_bar_ != nullptr);

  171.   EXPECT_TRUE(foreign_baz_ != nullptr);

  172.   EXPECT_TRUE(import_foo_ != nullptr);

  173.   EXPECT_TRUE(import_bar_ != nullptr);

  174.   EXPECT_TRUE(import_baz_ != nullptr);

  175. }

  176. 

  177. // Shorthand to get a FieldDescriptor for a field of TestAllTypes.

  178. inline const FieldDescriptor* TestUtil::ReflectionTester::F(

  179.     const std::string& name) {

  180.   const FieldDescriptor* result = nullptr;

  181.   if (base_descriptor_->name() == "TestAllExtensions" ||

  182.       base_descriptor_->name() == "TestPackedExtensions") {

  183.     result = base_descriptor_->file()->FindExtensionByName(name + "_extension");

  184.   } else {

  185.     result = base_descriptor_->FindFieldByName(name);

  186.   }

  187.   GOOGLE_CHECK(result != nullptr);

  188.   return result;

  189. }

  190. 

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

  192. 

  193. inline void TestUtil::ReflectionTester::SetAllFieldsViaReflection(

  194.     Message* message) {

  195.   const Reflection* reflection = message->GetReflection();

  196.   Message* sub_message;

  197. 

  198.   reflection->SetInt32(message, F("optional_int32"), 101);

  199.   reflection->SetInt64(message, F("optional_int64"), 102);

  200.   reflection->SetUInt32(message, F("optional_uint32"), 103);

  201.   reflection->SetUInt64(message, F("optional_uint64"), 104);

  202.   reflection->SetInt32(message, F("optional_sint32"), 105);

  203.   reflection->SetInt64(message, F("optional_sint64"), 106);

  204.   reflection->SetUInt32(message, F("optional_fixed32"), 107);

  205.   reflection->SetUInt64(message, F("optional_fixed64"), 108);

  206.   reflection->SetInt32(message, F("optional_sfixed32"), 109);

  207.   reflection->SetInt64(message, F("optional_sfixed64"), 110);

  208.   reflection->SetFloat(message, F("optional_float"), 111);

  209.   reflection->SetDouble(message, F("optional_double"), 112);

  210.   reflection->SetBool(message, F("optional_bool"), true);

  211.   reflection->SetString(message, F("optional_string"), "115");

  212.   reflection->SetString(message, F("optional_bytes"), "116");

  213. 

  214.   sub_message = reflection->MutableMessage(message, F("optionalgroup"));

  215.   sub_message->GetReflection()->SetInt32(sub_message, group_a_, 117);

  216.   sub_message =

  217.       reflection->MutableMessage(message, F("optional_nested_message"));

  218.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 118);

  219.   sub_message =

  220.       reflection->MutableMessage(message, F("optional_foreign_message"));

  221.   sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 119);

  222.   sub_message =

  223.       reflection->MutableMessage(message, F("optional_import_message"));

  224.   sub_message->GetReflection()->SetInt32(sub_message, import_d_, 120);

  225. 

  226.   reflection->SetEnum(message, F("optional_nested_enum"), nested_baz_);

  227.   reflection->SetEnum(message, F("optional_foreign_enum"), foreign_baz_);

  228.   reflection->SetEnum(message, F("optional_import_enum"), import_baz_);

  229. 

  230.   reflection->SetString(message, F("optional_string_piece"), "124");

  231.   reflection->SetString(message, F("optional_cord"), "125");

  232. 

  233.   sub_message =

  234.       reflection->MutableMessage(message, F("optional_public_import_message"));

  235.   sub_message->GetReflection()->SetInt32(sub_message, import_e_, 126);

  236. 

  237.   sub_message = reflection->MutableMessage(message, F("optional_lazy_message"));

  238.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 127);

  239. 

  240.   // -----------------------------------------------------------------

  241. 

  242.   reflection->AddInt32(message, F("repeated_int32"), 201);

  243.   reflection->AddInt64(message, F("repeated_int64"), 202);

  244.   reflection->AddUInt32(message, F("repeated_uint32"), 203);

  245.   reflection->AddUInt64(message, F("repeated_uint64"), 204);

  246.   reflection->AddInt32(message, F("repeated_sint32"), 205);

  247.   reflection->AddInt64(message, F("repeated_sint64"), 206);

  248.   reflection->AddUInt32(message, F("repeated_fixed32"), 207);

  249.   reflection->AddUInt64(message, F("repeated_fixed64"), 208);

  250.   reflection->AddInt32(message, F("repeated_sfixed32"), 209);

  251.   reflection->AddInt64(message, F("repeated_sfixed64"), 210);

  252.   reflection->AddFloat(message, F("repeated_float"), 211);

  253.   reflection->AddDouble(message, F("repeated_double"), 212);

  254.   reflection->AddBool(message, F("repeated_bool"), true);

  255.   reflection->AddString(message, F("repeated_string"), "215");

  256.   reflection->AddString(message, F("repeated_bytes"), "216");

  257. 

  258.   sub_message = reflection->AddMessage(message, F("repeatedgroup"));

  259.   sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 217);

  260.   sub_message = reflection->AddMessage(message, F("repeated_nested_message"));

  261.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 218);

  262.   sub_message = reflection->AddMessage(message, F("repeated_foreign_message"));

  263.   sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 219);

  264.   sub_message = reflection->AddMessage(message, F("repeated_import_message"));

  265.   sub_message->GetReflection()->SetInt32(sub_message, import_d_, 220);

  266.   sub_message = reflection->AddMessage(message, F("repeated_lazy_message"));

  267.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 227);

  268. 

  269.   reflection->AddEnum(message, F("repeated_nested_enum"), nested_bar_);

  270.   reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_bar_);

  271.   reflection->AddEnum(message, F("repeated_import_enum"), import_bar_);

  272. 

  273.   reflection->AddString(message, F("repeated_string_piece"), "224");

  274.   reflection->AddString(message, F("repeated_cord"), "225");

  275. 

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

  277.   reflection->AddInt32(message, F("repeated_int32"), 301);

  278.   reflection->AddInt64(message, F("repeated_int64"), 302);

  279.   reflection->AddUInt32(message, F("repeated_uint32"), 303);

  280.   reflection->AddUInt64(message, F("repeated_uint64"), 304);

  281.   reflection->AddInt32(message, F("repeated_sint32"), 305);

  282.   reflection->AddInt64(message, F("repeated_sint64"), 306);

  283.   reflection->AddUInt32(message, F("repeated_fixed32"), 307);

  284.   reflection->AddUInt64(message, F("repeated_fixed64"), 308);

  285.   reflection->AddInt32(message, F("repeated_sfixed32"), 309);

  286.   reflection->AddInt64(message, F("repeated_sfixed64"), 310);

  287.   reflection->AddFloat(message, F("repeated_float"), 311);

  288.   reflection->AddDouble(message, F("repeated_double"), 312);

  289.   reflection->AddBool(message, F("repeated_bool"), false);

  290.   reflection->AddString(message, F("repeated_string"), "315");

  291.   reflection->AddString(message, F("repeated_bytes"), "316");

  292. 

  293.   sub_message = reflection->AddMessage(message, F("repeatedgroup"));

  294.   sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 317);

  295.   sub_message = reflection->AddMessage(message, F("repeated_nested_message"));

  296.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 318);

  297.   sub_message = reflection->AddMessage(message, F("repeated_foreign_message"));

  298.   sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 319);

  299.   sub_message = reflection->AddMessage(message, F("repeated_import_message"));

  300.   sub_message->GetReflection()->SetInt32(sub_message, import_d_, 320);

  301.   sub_message = reflection->AddMessage(message, F("repeated_lazy_message"));

  302.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 327);

  303. 

  304.   reflection->AddEnum(message, F("repeated_nested_enum"), nested_baz_);

  305.   reflection->AddEnum(message, F("repeated_foreign_enum"), foreign_baz_);

  306.   reflection->AddEnum(message, F("repeated_import_enum"), import_baz_);

  307. 

  308.   reflection->AddString(message, F("repeated_string_piece"), "324");

  309.   reflection->AddString(message, F("repeated_cord"), "325");

  310. 

  311.   // -----------------------------------------------------------------

  312. 

  313.   reflection->SetInt32(message, F("default_int32"), 401);

  314.   reflection->SetInt64(message, F("default_int64"), 402);

  315.   reflection->SetUInt32(message, F("default_uint32"), 403);

  316.   reflection->SetUInt64(message, F("default_uint64"), 404);

  317.   reflection->SetInt32(message, F("default_sint32"), 405);

  318.   reflection->SetInt64(message, F("default_sint64"), 406);

  319.   reflection->SetUInt32(message, F("default_fixed32"), 407);

  320.   reflection->SetUInt64(message, F("default_fixed64"), 408);

  321.   reflection->SetInt32(message, F("default_sfixed32"), 409);

  322.   reflection->SetInt64(message, F("default_sfixed64"), 410);

  323.   reflection->SetFloat(message, F("default_float"), 411);

  324.   reflection->SetDouble(message, F("default_double"), 412);

  325.   reflection->SetBool(message, F("default_bool"), false);

  326.   reflection->SetString(message, F("default_string"), "415");

  327.   reflection->SetString(message, F("default_bytes"), "416");

  328. 

  329.   reflection->SetEnum(message, F("default_nested_enum"), nested_foo_);

  330.   reflection->SetEnum(message, F("default_foreign_enum"), foreign_foo_);

  331.   reflection->SetEnum(message, F("default_import_enum"), import_foo_);

  332. 

  333.   reflection->SetString(message, F("default_string_piece"), "424");

  334.   reflection->SetString(message, F("default_cord"), "425");

  335. 

  336.   reflection->SetUInt32(message, F("oneof_uint32"), 601);

  337.   sub_message = reflection->MutableMessage(message, F("oneof_nested_message"));

  338.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 602);

  339.   reflection->SetString(message, F("oneof_string"), "603");

  340.   reflection->SetString(message, F("oneof_bytes"), "604");

  341. }

  342. 

  343. inline void TestUtil::ReflectionTester::SetOneofViaReflection(

  344.     Message* message) {

  345.   const Descriptor* descriptor = message->GetDescriptor();

  346.   const Reflection* reflection = message->GetReflection();

  347.   Message* sub_message = reflection->MutableMessage(

  348.       message, descriptor->FindFieldByName("foo_lazy_message"));

  349.   sub_message->GetReflection()->SetInt64(

  350.       sub_message, sub_message->GetDescriptor()->FindFieldByName("qux_int"),

  351.       100);

  352. 

  353.   reflection->SetString(message, descriptor->FindFieldByName("bar_cord"),

  354.                         "101");

  355.   reflection->SetInt32(message, descriptor->FindFieldByName("baz_int"), 102);

  356.   reflection->SetString(message, descriptor->FindFieldByName("baz_string"),

  357.                         "103");

  358. }

  359. 

  360. inline void TestUtil::ReflectionTester::ExpectOneofSetViaReflection(

  361.     const Message& message) {

  362.   const Descriptor* descriptor = message.GetDescriptor();

  363.   const Reflection* reflection = message.GetReflection();

  364.   std::string scratch;

  365.   EXPECT_TRUE(reflection->HasField(

  366.       message, descriptor->FindFieldByName("foo_lazy_message")));

  367.   EXPECT_TRUE(

  368.       reflection->HasField(message, descriptor->FindFieldByName("bar_cord")));

  369.   EXPECT_TRUE(

  370.       reflection->HasField(message, descriptor->FindFieldByName("baz_int")));

  371.   EXPECT_TRUE(

  372.       reflection->HasField(message, descriptor->FindFieldByName("baz_string")));

  373. 

  374.   const Message* sub_message = &reflection->GetMessage(

  375.       message, descriptor->FindFieldByName("foo_lazy_message"));

  376.   EXPECT_EQ(100, sub_message->GetReflection()->GetInt64(

  377.                      *sub_message,

  378.                      sub_message->GetDescriptor()->FindFieldByName("qux_int")));

  379. 

  380.   EXPECT_EQ("101", reflection->GetString(

  381.                        message, descriptor->FindFieldByName("bar_cord")));

  382.   EXPECT_EQ("101",

  383.             reflection->GetStringReference(

  384.                 message, descriptor->FindFieldByName("bar_cord"), &scratch));

  385. 

  386.   EXPECT_EQ(102, reflection->GetInt32(message,

  387.                                       descriptor->FindFieldByName("baz_int")));

  388. 

  389.   EXPECT_EQ("103", reflection->GetString(

  390.                        message, descriptor->FindFieldByName("baz_string")));

  391.   EXPECT_EQ("103",

  392.             reflection->GetStringReference(

  393.                 message, descriptor->FindFieldByName("baz_string"), &scratch));

  394. }

  395. 

  396. inline void TestUtil::ReflectionTester::SetPackedFieldsViaReflection(

  397.     Message* message) {

  398.   const Reflection* reflection = message->GetReflection();

  399.   reflection->AddInt32(message, F("packed_int32"), 601);

  400.   reflection->AddInt64(message, F("packed_int64"), 602);

  401.   reflection->AddUInt32(message, F("packed_uint32"), 603);

  402.   reflection->AddUInt64(message, F("packed_uint64"), 604);

  403.   reflection->AddInt32(message, F("packed_sint32"), 605);

  404.   reflection->AddInt64(message, F("packed_sint64"), 606);

  405.   reflection->AddUInt32(message, F("packed_fixed32"), 607);

  406.   reflection->AddUInt64(message, F("packed_fixed64"), 608);

  407.   reflection->AddInt32(message, F("packed_sfixed32"), 609);

  408.   reflection->AddInt64(message, F("packed_sfixed64"), 610);

  409.   reflection->AddFloat(message, F("packed_float"), 611);

  410.   reflection->AddDouble(message, F("packed_double"), 612);

  411.   reflection->AddBool(message, F("packed_bool"), true);

  412.   reflection->AddEnum(message, F("packed_enum"), foreign_bar_);

  413. 

  414.   reflection->AddInt32(message, F("packed_int32"), 701);

  415.   reflection->AddInt64(message, F("packed_int64"), 702);

  416.   reflection->AddUInt32(message, F("packed_uint32"), 703);

  417.   reflection->AddUInt64(message, F("packed_uint64"), 704);

  418.   reflection->AddInt32(message, F("packed_sint32"), 705);

  419.   reflection->AddInt64(message, F("packed_sint64"), 706);

  420.   reflection->AddUInt32(message, F("packed_fixed32"), 707);

  421.   reflection->AddUInt64(message, F("packed_fixed64"), 708);

  422.   reflection->AddInt32(message, F("packed_sfixed32"), 709);

  423.   reflection->AddInt64(message, F("packed_sfixed64"), 710);

  424.   reflection->AddFloat(message, F("packed_float"), 711);

  425.   reflection->AddDouble(message, F("packed_double"), 712);

  426.   reflection->AddBool(message, F("packed_bool"), false);

  427.   reflection->AddEnum(message, F("packed_enum"), foreign_baz_);

  428. }

  429. 

  430. // -------------------------------------------------------------------

  431. 

  432. inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection(

  433.     const Message& message) {

  434.   // We have to split this into three function otherwise it creates a stack

  435.   // frame so large that it triggers a warning.

  436.   ExpectAllFieldsSetViaReflection1(message);

  437.   ExpectAllFieldsSetViaReflection2(message);

  438.   ExpectAllFieldsSetViaReflection3(message);

  439. }

  440. 

  441. inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection1(

  442.     const Message& message) {

  443.   const Reflection* reflection = message.GetReflection();

  444.   std::string scratch;

  445.   const Message* sub_message;

  446. 

  447.   EXPECT_TRUE(reflection->HasField(message, F("optional_int32")));

  448.   EXPECT_TRUE(reflection->HasField(message, F("optional_int64")));

  449.   EXPECT_TRUE(reflection->HasField(message, F("optional_uint32")));

  450.   EXPECT_TRUE(reflection->HasField(message, F("optional_uint64")));

  451.   EXPECT_TRUE(reflection->HasField(message, F("optional_sint32")));

  452.   EXPECT_TRUE(reflection->HasField(message, F("optional_sint64")));

  453.   EXPECT_TRUE(reflection->HasField(message, F("optional_fixed32")));

  454.   EXPECT_TRUE(reflection->HasField(message, F("optional_fixed64")));

  455.   EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed32")));

  456.   EXPECT_TRUE(reflection->HasField(message, F("optional_sfixed64")));

  457.   EXPECT_TRUE(reflection->HasField(message, F("optional_float")));

  458.   EXPECT_TRUE(reflection->HasField(message, F("optional_double")));

  459.   EXPECT_TRUE(reflection->HasField(message, F("optional_bool")));

  460.   EXPECT_TRUE(reflection->HasField(message, F("optional_string")));

  461.   EXPECT_TRUE(reflection->HasField(message, F("optional_bytes")));

  462. 

  463.   EXPECT_TRUE(reflection->HasField(message, F("optionalgroup")));

  464.   EXPECT_TRUE(reflection->HasField(message, F("optional_nested_message")));

  465.   EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_message")));

  466.   EXPECT_TRUE(reflection->HasField(message, F("optional_import_message")));

  467.   EXPECT_TRUE(

  468.       reflection->HasField(message, F("optional_public_import_message")));

  469.   EXPECT_TRUE(reflection->HasField(message, F("optional_lazy_message")));

  470. 

  471.   sub_message = &reflection->GetMessage(message, F("optionalgroup"));

  472.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, group_a_));

  473.   sub_message = &reflection->GetMessage(message, F("optional_nested_message"));

  474.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_));

  475.   sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));

  476.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, foreign_c_));

  477.   sub_message = &reflection->GetMessage(message, F("optional_import_message"));

  478.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_d_));

  479.   sub_message =

  480.       &reflection->GetMessage(message, F("optional_public_import_message"));

  481.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, import_e_));

  482.   sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));

  483.   EXPECT_TRUE(sub_message->GetReflection()->HasField(*sub_message, nested_b_));

  484. 

  485.   EXPECT_TRUE(reflection->HasField(message, F("optional_nested_enum")));

  486.   EXPECT_TRUE(reflection->HasField(message, F("optional_foreign_enum")));

  487.   EXPECT_TRUE(reflection->HasField(message, F("optional_import_enum")));

  488. 

  489.   EXPECT_TRUE(reflection->HasField(message, F("optional_string_piece")));

  490.   EXPECT_TRUE(reflection->HasField(message, F("optional_cord")));

  491. 

  492.   EXPECT_EQ(101, reflection->GetInt32(message, F("optional_int32")));

  493.   EXPECT_EQ(102, reflection->GetInt64(message, F("optional_int64")));

  494.   EXPECT_EQ(103, reflection->GetUInt32(message, F("optional_uint32")));

  495.   EXPECT_EQ(104, reflection->GetUInt64(message, F("optional_uint64")));

  496.   EXPECT_EQ(105, reflection->GetInt32(message, F("optional_sint32")));

  497.   EXPECT_EQ(106, reflection->GetInt64(message, F("optional_sint64")));

  498.   EXPECT_EQ(107, reflection->GetUInt32(message, F("optional_fixed32")));

  499.   EXPECT_EQ(108, reflection->GetUInt64(message, F("optional_fixed64")));

  500.   EXPECT_EQ(109, reflection->GetInt32(message, F("optional_sfixed32")));

  501.   EXPECT_EQ(110, reflection->GetInt64(message, F("optional_sfixed64")));

  502.   EXPECT_EQ(111, reflection->GetFloat(message, F("optional_float")));

  503.   EXPECT_EQ(112, reflection->GetDouble(message, F("optional_double")));

  504.   EXPECT_TRUE(reflection->GetBool(message, F("optional_bool")));

  505.   EXPECT_EQ("115", reflection->GetString(message, F("optional_string")));

  506.   EXPECT_EQ("116", reflection->GetString(message, F("optional_bytes")));

  507. 

  508.   EXPECT_EQ("115", reflection->GetStringReference(message, F("optional_string"),

  509.                                                   &scratch));

  510.   EXPECT_EQ("116", reflection->GetStringReference(message, F("optional_bytes"),

  511.                                                   &scratch));

  512. 

  513.   sub_message = &reflection->GetMessage(message, F("optionalgroup"));

  514.   EXPECT_EQ(117,

  515.             sub_message->GetReflection()->GetInt32(*sub_message, group_a_));

  516.   sub_message = &reflection->GetMessage(message, F("optional_nested_message"));

  517.   EXPECT_EQ(118,

  518.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  519.   sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));

  520.   EXPECT_EQ(119,

  521.             sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_));

  522.   sub_message = &reflection->GetMessage(message, F("optional_import_message"));

  523.   EXPECT_EQ(120,

  524.             sub_message->GetReflection()->GetInt32(*sub_message, import_d_));

  525.   sub_message =

  526.       &reflection->GetMessage(message, F("optional_public_import_message"));

  527.   EXPECT_EQ(126,

  528.             sub_message->GetReflection()->GetInt32(*sub_message, import_e_));

  529.   sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));

  530.   EXPECT_EQ(127,

  531.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  532. 

  533.   EXPECT_EQ(nested_baz_,

  534.             reflection->GetEnum(message, F("optional_nested_enum")));

  535.   EXPECT_EQ(foreign_baz_,

  536.             reflection->GetEnum(message, F("optional_foreign_enum")));

  537.   EXPECT_EQ(import_baz_,

  538.             reflection->GetEnum(message, F("optional_import_enum")));

  539. 

  540.   EXPECT_EQ("124", reflection->GetString(message, F("optional_string_piece")));

  541.   EXPECT_EQ("124", reflection->GetStringReference(

  542.                        message, F("optional_string_piece"), &scratch));

  543. 

  544.   EXPECT_EQ("125", reflection->GetString(message, F("optional_cord")));

  545.   EXPECT_EQ("125", reflection->GetStringReference(message, F("optional_cord"),

  546.                                                   &scratch));

  547. 

  548.   EXPECT_TRUE(reflection->HasField(message, F("oneof_bytes")));

  549.   EXPECT_EQ("604", reflection->GetString(message, F("oneof_bytes")));

  550. 

  551.   if (base_descriptor_->name() == "TestAllTypes") {

  552.     EXPECT_FALSE(reflection->HasField(message, F("oneof_uint32")));

  553.     EXPECT_FALSE(reflection->HasField(message, F("oneof_string")));

  554.   } else {

  555.     EXPECT_TRUE(reflection->HasField(message, F("oneof_uint32")));

  556.     EXPECT_TRUE(reflection->HasField(message, F("oneof_string")));

  557.     EXPECT_EQ(601, reflection->GetUInt32(message, F("oneof_uint32")));

  558.     EXPECT_EQ("603", reflection->GetString(message, F("oneof_string")));

  559.     sub_message = &reflection->GetMessage(message, F("oneof_nested_message"));

  560.     EXPECT_EQ(602,

  561.               sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  562.   }

  563. }

  564. 

  565. inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection2(

  566.     const Message& message) {

  567.   const Reflection* reflection = message.GetReflection();

  568.   std::string scratch;

  569.   const Message* sub_message;

  570. 

  571.   // -----------------------------------------------------------------

  572. 

  573.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int32")));

  574.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_int64")));

  575.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint32")));

  576.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_uint64")));

  577.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint32")));

  578.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sint64")));

  579.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed32")));

  580.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_fixed64")));

  581.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed32")));

  582.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_sfixed64")));

  583.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_float")));

  584.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_double")));

  585.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bool")));

  586.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string")));

  587.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_bytes")));

  588. 

  589.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeatedgroup")));

  590.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_message")));

  591.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_message")));

  592.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_message")));

  593.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_lazy_message")));

  594.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_nested_enum")));

  595.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_foreign_enum")));

  596.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_import_enum")));

  597. 

  598.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_string_piece")));

  599.   ASSERT_EQ(2, reflection->FieldSize(message, F("repeated_cord")));

  600. 

  601.   EXPECT_EQ(201, reflection->GetRepeatedInt32(message, F("repeated_int32"), 0));

  602.   EXPECT_EQ(202, reflection->GetRepeatedInt64(message, F("repeated_int64"), 0));

  603.   EXPECT_EQ(203,

  604.             reflection->GetRepeatedUInt32(message, F("repeated_uint32"), 0));

  605.   EXPECT_EQ(204,

  606.             reflection->GetRepeatedUInt64(message, F("repeated_uint64"), 0));

  607.   EXPECT_EQ(205,

  608.             reflection->GetRepeatedInt32(message, F("repeated_sint32"), 0));

  609.   EXPECT_EQ(206,

  610.             reflection->GetRepeatedInt64(message, F("repeated_sint64"), 0));

  611.   EXPECT_EQ(207,

  612.             reflection->GetRepeatedUInt32(message, F("repeated_fixed32"), 0));

  613.   EXPECT_EQ(208,

  614.             reflection->GetRepeatedUInt64(message, F("repeated_fixed64"), 0));

  615.   EXPECT_EQ(209,

  616.             reflection->GetRepeatedInt32(message, F("repeated_sfixed32"), 0));

  617.   EXPECT_EQ(210,

  618.             reflection->GetRepeatedInt64(message, F("repeated_sfixed64"), 0));

  619.   EXPECT_EQ(211, reflection->GetRepeatedFloat(message, F("repeated_float"), 0));

  620.   EXPECT_EQ(212,

  621.             reflection->GetRepeatedDouble(message, F("repeated_double"), 0));

  622.   EXPECT_TRUE(reflection->GetRepeatedBool(message, F("repeated_bool"), 0));

  623.   EXPECT_EQ("215",

  624.             reflection->GetRepeatedString(message, F("repeated_string"), 0));

  625.   EXPECT_EQ("216",

  626.             reflection->GetRepeatedString(message, F("repeated_bytes"), 0));

  627. 

  628.   EXPECT_EQ("215", reflection->GetRepeatedStringReference(

  629.                        message, F("repeated_string"), 0, &scratch));

  630.   EXPECT_EQ("216", reflection->GetRepeatedStringReference(

  631.                        message, F("repeated_bytes"), 0, &scratch));

  632. 

  633.   sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 0);

  634.   EXPECT_EQ(217, sub_message->GetReflection()->GetInt32(*sub_message,

  635.                                                         repeated_group_a_));

  636.   sub_message =

  637.       &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 0);

  638.   EXPECT_EQ(218,

  639.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  640.   sub_message = &reflection->GetRepeatedMessage(

  641.       message, F("repeated_foreign_message"), 0);

  642.   EXPECT_EQ(219,

  643.             sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_));

  644.   sub_message =

  645.       &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 0);

  646.   EXPECT_EQ(220,

  647.             sub_message->GetReflection()->GetInt32(*sub_message, import_d_));

  648.   sub_message =

  649.       &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 0);

  650.   EXPECT_EQ(227,

  651.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  652. 

  653.   EXPECT_EQ(nested_bar_,

  654.             reflection->GetRepeatedEnum(message, F("repeated_nested_enum"), 0));

  655.   EXPECT_EQ(foreign_bar_, reflection->GetRepeatedEnum(

  656.                               message, F("repeated_foreign_enum"), 0));

  657.   EXPECT_EQ(import_bar_,

  658.             reflection->GetRepeatedEnum(message, F("repeated_import_enum"), 0));

  659. 

  660.   EXPECT_EQ("224", reflection->GetRepeatedString(

  661.                        message, F("repeated_string_piece"), 0));

  662.   EXPECT_EQ("224", reflection->GetRepeatedStringReference(

  663.                        message, F("repeated_string_piece"), 0, &scratch));

  664. 

  665.   EXPECT_EQ("225",

  666.             reflection->GetRepeatedString(message, F("repeated_cord"), 0));

  667.   EXPECT_EQ("225", reflection->GetRepeatedStringReference(

  668.                        message, F("repeated_cord"), 0, &scratch));

  669. 

  670.   EXPECT_EQ(301, reflection->GetRepeatedInt32(message, F("repeated_int32"), 1));

  671.   EXPECT_EQ(302, reflection->GetRepeatedInt64(message, F("repeated_int64"), 1));

  672.   EXPECT_EQ(303,

  673.             reflection->GetRepeatedUInt32(message, F("repeated_uint32"), 1));

  674.   EXPECT_EQ(304,

  675.             reflection->GetRepeatedUInt64(message, F("repeated_uint64"), 1));

  676.   EXPECT_EQ(305,

  677.             reflection->GetRepeatedInt32(message, F("repeated_sint32"), 1));

  678.   EXPECT_EQ(306,

  679.             reflection->GetRepeatedInt64(message, F("repeated_sint64"), 1));

  680.   EXPECT_EQ(307,

  681.             reflection->GetRepeatedUInt32(message, F("repeated_fixed32"), 1));

  682.   EXPECT_EQ(308,

  683.             reflection->GetRepeatedUInt64(message, F("repeated_fixed64"), 1));

  684.   EXPECT_EQ(309,

  685.             reflection->GetRepeatedInt32(message, F("repeated_sfixed32"), 1));

  686.   EXPECT_EQ(310,

  687.             reflection->GetRepeatedInt64(message, F("repeated_sfixed64"), 1));

  688.   EXPECT_EQ(311, reflection->GetRepeatedFloat(message, F("repeated_float"), 1));

  689.   EXPECT_EQ(312,

  690.             reflection->GetRepeatedDouble(message, F("repeated_double"), 1));

  691.   EXPECT_FALSE(reflection->GetRepeatedBool(message, F("repeated_bool"), 1));

  692.   EXPECT_EQ("315",

  693.             reflection->GetRepeatedString(message, F("repeated_string"), 1));

  694.   EXPECT_EQ("316",

  695.             reflection->GetRepeatedString(message, F("repeated_bytes"), 1));

  696. 

  697.   EXPECT_EQ("315", reflection->GetRepeatedStringReference(

  698.                        message, F("repeated_string"), 1, &scratch));

  699.   EXPECT_EQ("316", reflection->GetRepeatedStringReference(

  700.                        message, F("repeated_bytes"), 1, &scratch));

  701. 

  702.   sub_message = &reflection->GetRepeatedMessage(message, F("repeatedgroup"), 1);

  703.   EXPECT_EQ(317, sub_message->GetReflection()->GetInt32(*sub_message,

  704.                                                         repeated_group_a_));

  705.   sub_message =

  706.       &reflection->GetRepeatedMessage(message, F("repeated_nested_message"), 1);

  707.   EXPECT_EQ(318,

  708.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  709.   sub_message = &reflection->GetRepeatedMessage(

  710.       message, F("repeated_foreign_message"), 1);

  711.   EXPECT_EQ(319,

  712.             sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_));

  713.   sub_message =

  714.       &reflection->GetRepeatedMessage(message, F("repeated_import_message"), 1);

  715.   EXPECT_EQ(320,

  716.             sub_message->GetReflection()->GetInt32(*sub_message, import_d_));

  717.   sub_message =

  718.       &reflection->GetRepeatedMessage(message, F("repeated_lazy_message"), 1);

  719.   EXPECT_EQ(327,

  720.             sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  721. 

  722.   EXPECT_EQ(nested_baz_,

  723.             reflection->GetRepeatedEnum(message, F("repeated_nested_enum"), 1));

  724.   EXPECT_EQ(foreign_baz_, reflection->GetRepeatedEnum(

  725.                               message, F("repeated_foreign_enum"), 1));

  726.   EXPECT_EQ(import_baz_,

  727.             reflection->GetRepeatedEnum(message, F("repeated_import_enum"), 1));

  728. 

  729.   EXPECT_EQ("324", reflection->GetRepeatedString(

  730.                        message, F("repeated_string_piece"), 1));

  731.   EXPECT_EQ("324", reflection->GetRepeatedStringReference(

  732.                        message, F("repeated_string_piece"), 1, &scratch));

  733. 

  734.   EXPECT_EQ("325",

  735.             reflection->GetRepeatedString(message, F("repeated_cord"), 1));

  736.   EXPECT_EQ("325", reflection->GetRepeatedStringReference(

  737.                        message, F("repeated_cord"), 1, &scratch));

  738. }

  739. 

  740. inline void TestUtil::ReflectionTester::ExpectAllFieldsSetViaReflection3(

  741.     const Message& message) {

  742.   const Reflection* reflection = message.GetReflection();

  743.   std::string scratch;

  744. 

  745.   // -----------------------------------------------------------------

  746. 

  747.   EXPECT_TRUE(reflection->HasField(message, F("default_int32")));

  748.   EXPECT_TRUE(reflection->HasField(message, F("default_int64")));

  749.   EXPECT_TRUE(reflection->HasField(message, F("default_uint32")));

  750.   EXPECT_TRUE(reflection->HasField(message, F("default_uint64")));

  751.   EXPECT_TRUE(reflection->HasField(message, F("default_sint32")));

  752.   EXPECT_TRUE(reflection->HasField(message, F("default_sint64")));

  753.   EXPECT_TRUE(reflection->HasField(message, F("default_fixed32")));

  754.   EXPECT_TRUE(reflection->HasField(message, F("default_fixed64")));

  755.   EXPECT_TRUE(reflection->HasField(message, F("default_sfixed32")));

  756.   EXPECT_TRUE(reflection->HasField(message, F("default_sfixed64")));

  757.   EXPECT_TRUE(reflection->HasField(message, F("default_float")));

  758.   EXPECT_TRUE(reflection->HasField(message, F("default_double")));

  759.   EXPECT_TRUE(reflection->HasField(message, F("default_bool")));

  760.   EXPECT_TRUE(reflection->HasField(message, F("default_string")));

  761.   EXPECT_TRUE(reflection->HasField(message, F("default_bytes")));

  762. 

  763.   EXPECT_TRUE(reflection->HasField(message, F("default_nested_enum")));

  764.   EXPECT_TRUE(reflection->HasField(message, F("default_foreign_enum")));

  765.   EXPECT_TRUE(reflection->HasField(message, F("default_import_enum")));

  766. 

  767.   EXPECT_TRUE(reflection->HasField(message, F("default_string_piece")));

  768.   EXPECT_TRUE(reflection->HasField(message, F("default_cord")));

  769. 

  770.   EXPECT_EQ(401, reflection->GetInt32(message, F("default_int32")));

  771.   EXPECT_EQ(402, reflection->GetInt64(message, F("default_int64")));

  772.   EXPECT_EQ(403, reflection->GetUInt32(message, F("default_uint32")));

  773.   EXPECT_EQ(404, reflection->GetUInt64(message, F("default_uint64")));

  774.   EXPECT_EQ(405, reflection->GetInt32(message, F("default_sint32")));

  775.   EXPECT_EQ(406, reflection->GetInt64(message, F("default_sint64")));

  776.   EXPECT_EQ(407, reflection->GetUInt32(message, F("default_fixed32")));

  777.   EXPECT_EQ(408, reflection->GetUInt64(message, F("default_fixed64")));

  778.   EXPECT_EQ(409, reflection->GetInt32(message, F("default_sfixed32")));

  779.   EXPECT_EQ(410, reflection->GetInt64(message, F("default_sfixed64")));

  780.   EXPECT_EQ(411, reflection->GetFloat(message, F("default_float")));

  781.   EXPECT_EQ(412, reflection->GetDouble(message, F("default_double")));

  782.   EXPECT_FALSE(reflection->GetBool(message, F("default_bool")));

  783.   EXPECT_EQ("415", reflection->GetString(message, F("default_string")));

  784.   EXPECT_EQ("416", reflection->GetString(message, F("default_bytes")));

  785. 

  786.   EXPECT_EQ("415", reflection->GetStringReference(message, F("default_string"),

  787.                                                   &scratch));

  788.   EXPECT_EQ("416", reflection->GetStringReference(message, F("default_bytes"),

  789.                                                   &scratch));

  790. 

  791.   EXPECT_EQ(nested_foo_,

  792.             reflection->GetEnum(message, F("default_nested_enum")));

  793.   EXPECT_EQ(foreign_foo_,

  794.             reflection->GetEnum(message, F("default_foreign_enum")));

  795.   EXPECT_EQ(import_foo_,

  796.             reflection->GetEnum(message, F("default_import_enum")));

  797. 

  798.   EXPECT_EQ("424", reflection->GetString(message, F("default_string_piece")));

  799.   EXPECT_EQ("424", reflection->GetStringReference(

  800.                        message, F("default_string_piece"), &scratch));

  801. 

  802.   EXPECT_EQ("425", reflection->GetString(message, F("default_cord")));

  803.   EXPECT_EQ("425", reflection->GetStringReference(message, F("default_cord"),

  804.                                                   &scratch));

  805. }

  806. 

  807. inline void TestUtil::ReflectionTester::ExpectPackedFieldsSetViaReflection(

  808.     const Message& message) {

  809.   const Reflection* reflection = message.GetReflection();

  810. 

  811.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int32")));

  812.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_int64")));

  813.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint32")));

  814.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_uint64")));

  815.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint32")));

  816.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sint64")));

  817.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed32")));

  818.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_fixed64")));

  819.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed32")));

  820.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_sfixed64")));

  821.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_float")));

  822.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_double")));

  823.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_bool")));

  824.   ASSERT_EQ(2, reflection->FieldSize(message, F("packed_enum")));

  825. 

  826.   EXPECT_EQ(601, reflection->GetRepeatedInt32(message, F("packed_int32"), 0));

  827.   EXPECT_EQ(602, reflection->GetRepeatedInt64(message, F("packed_int64"), 0));

  828.   EXPECT_EQ(603, reflection->GetRepeatedUInt32(message, F("packed_uint32"), 0));

  829.   EXPECT_EQ(604, reflection->GetRepeatedUInt64(message, F("packed_uint64"), 0));

  830.   EXPECT_EQ(605, reflection->GetRepeatedInt32(message, F("packed_sint32"), 0));

  831.   EXPECT_EQ(606, reflection->GetRepeatedInt64(message, F("packed_sint64"), 0));

  832.   EXPECT_EQ(607,

  833.             reflection->GetRepeatedUInt32(message, F("packed_fixed32"), 0));

  834.   EXPECT_EQ(608,

  835.             reflection->GetRepeatedUInt64(message, F("packed_fixed64"), 0));

  836.   EXPECT_EQ(609,

  837.             reflection->GetRepeatedInt32(message, F("packed_sfixed32"), 0));

  838.   EXPECT_EQ(610,

  839.             reflection->GetRepeatedInt64(message, F("packed_sfixed64"), 0));

  840.   EXPECT_EQ(611, reflection->GetRepeatedFloat(message, F("packed_float"), 0));

  841.   EXPECT_EQ(612, reflection->GetRepeatedDouble(message, F("packed_double"), 0));

  842.   EXPECT_TRUE(reflection->GetRepeatedBool(message, F("packed_bool"), 0));

  843.   EXPECT_EQ(foreign_bar_,

  844.             reflection->GetRepeatedEnum(message, F("packed_enum"), 0));

  845. 

  846.   EXPECT_EQ(701, reflection->GetRepeatedInt32(message, F("packed_int32"), 1));

  847.   EXPECT_EQ(702, reflection->GetRepeatedInt64(message, F("packed_int64"), 1));

  848.   EXPECT_EQ(703, reflection->GetRepeatedUInt32(message, F("packed_uint32"), 1));

  849.   EXPECT_EQ(704, reflection->GetRepeatedUInt64(message, F("packed_uint64"), 1));

  850.   EXPECT_EQ(705, reflection->GetRepeatedInt32(message, F("packed_sint32"), 1));

  851.   EXPECT_EQ(706, reflection->GetRepeatedInt64(message, F("packed_sint64"), 1));

  852.   EXPECT_EQ(707,

  853.             reflection->GetRepeatedUInt32(message, F("packed_fixed32"), 1));

  854.   EXPECT_EQ(708,

  855.             reflection->GetRepeatedUInt64(message, F("packed_fixed64"), 1));

  856.   EXPECT_EQ(709,

  857.             reflection->GetRepeatedInt32(message, F("packed_sfixed32"), 1));

  858.   EXPECT_EQ(710,

  859.             reflection->GetRepeatedInt64(message, F("packed_sfixed64"), 1));

  860.   EXPECT_EQ(711, reflection->GetRepeatedFloat(message, F("packed_float"), 1));

  861.   EXPECT_EQ(712, reflection->GetRepeatedDouble(message, F("packed_double"), 1));

  862.   EXPECT_FALSE(reflection->GetRepeatedBool(message, F("packed_bool"), 1));

  863.   EXPECT_EQ(foreign_baz_,

  864.             reflection->GetRepeatedEnum(message, F("packed_enum"), 1));

  865. }

  866. 

  867. // -------------------------------------------------------------------

  868. 

  869. inline void TestUtil::ReflectionTester::ExpectClearViaReflection(

  870.     const Message& message) {

  871.   const Reflection* reflection = message.GetReflection();

  872.   std::string scratch;

  873.   const Message* sub_message;

  874. 

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

  876.   EXPECT_FALSE(reflection->HasField(message, F("optional_int32")));

  877.   EXPECT_FALSE(reflection->HasField(message, F("optional_int64")));

  878.   EXPECT_FALSE(reflection->HasField(message, F("optional_uint32")));

  879.   EXPECT_FALSE(reflection->HasField(message, F("optional_uint64")));

  880.   EXPECT_FALSE(reflection->HasField(message, F("optional_sint32")));

  881.   EXPECT_FALSE(reflection->HasField(message, F("optional_sint64")));

  882.   EXPECT_FALSE(reflection->HasField(message, F("optional_fixed32")));

  883.   EXPECT_FALSE(reflection->HasField(message, F("optional_fixed64")));

  884.   EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed32")));

  885.   EXPECT_FALSE(reflection->HasField(message, F("optional_sfixed64")));

  886.   EXPECT_FALSE(reflection->HasField(message, F("optional_float")));

  887.   EXPECT_FALSE(reflection->HasField(message, F("optional_double")));

  888.   EXPECT_FALSE(reflection->HasField(message, F("optional_bool")));

  889.   EXPECT_FALSE(reflection->HasField(message, F("optional_string")));

  890.   EXPECT_FALSE(reflection->HasField(message, F("optional_bytes")));

  891. 

  892.   EXPECT_FALSE(reflection->HasField(message, F("optionalgroup")));

  893.   EXPECT_FALSE(reflection->HasField(message, F("optional_nested_message")));

  894.   EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_message")));

  895.   EXPECT_FALSE(reflection->HasField(message, F("optional_import_message")));

  896.   EXPECT_FALSE(

  897.       reflection->HasField(message, F("optional_public_import_message")));

  898.   EXPECT_FALSE(reflection->HasField(message, F("optional_lazy_message")));

  899. 

  900.   EXPECT_FALSE(reflection->HasField(message, F("optional_nested_enum")));

  901.   EXPECT_FALSE(reflection->HasField(message, F("optional_foreign_enum")));

  902.   EXPECT_FALSE(reflection->HasField(message, F("optional_import_enum")));

  903. 

  904.   EXPECT_FALSE(reflection->HasField(message, F("optional_string_piece")));

  905.   EXPECT_FALSE(reflection->HasField(message, F("optional_cord")));

  906. 

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

  908.   EXPECT_EQ(0, reflection->GetInt32(message, F("optional_int32")));

  909.   EXPECT_EQ(0, reflection->GetInt64(message, F("optional_int64")));

  910.   EXPECT_EQ(0, reflection->GetUInt32(message, F("optional_uint32")));

  911.   EXPECT_EQ(0, reflection->GetUInt64(message, F("optional_uint64")));

  912.   EXPECT_EQ(0, reflection->GetInt32(message, F("optional_sint32")));

  913.   EXPECT_EQ(0, reflection->GetInt64(message, F("optional_sint64")));

  914.   EXPECT_EQ(0, reflection->GetUInt32(message, F("optional_fixed32")));

  915.   EXPECT_EQ(0, reflection->GetUInt64(message, F("optional_fixed64")));

  916.   EXPECT_EQ(0, reflection->GetInt32(message, F("optional_sfixed32")));

  917.   EXPECT_EQ(0, reflection->GetInt64(message, F("optional_sfixed64")));

  918.   EXPECT_EQ(0, reflection->GetFloat(message, F("optional_float")));

  919.   EXPECT_EQ(0, reflection->GetDouble(message, F("optional_double")));

  920.   EXPECT_FALSE(reflection->GetBool(message, F("optional_bool")));

  921.   EXPECT_EQ("", reflection->GetString(message, F("optional_string")));

  922.   EXPECT_EQ("", reflection->GetString(message, F("optional_bytes")));

  923. 

  924.   EXPECT_EQ("", reflection->GetStringReference(message, F("optional_string"),

  925.                                                &scratch));

  926.   EXPECT_EQ("", reflection->GetStringReference(message, F("optional_bytes"),

  927.                                                &scratch));

  928. 

  929.   // Embedded messages should also be clear.

  930.   sub_message = &reflection->GetMessage(message, F("optionalgroup"));

  931.   EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, group_a_));

  932.   EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, group_a_));

  933.   sub_message = &reflection->GetMessage(message, F("optional_nested_message"));

  934.   EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_));

  935.   EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  936.   sub_message = &reflection->GetMessage(message, F("optional_foreign_message"));

  937.   EXPECT_FALSE(

  938.       sub_message->GetReflection()->HasField(*sub_message, foreign_c_));

  939.   EXPECT_EQ(0,

  940.             sub_message->GetReflection()->GetInt32(*sub_message, foreign_c_));

  941.   sub_message = &reflection->GetMessage(message, F("optional_import_message"));

  942.   EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_d_));

  943.   EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_d_));

  944.   sub_message =

  945.       &reflection->GetMessage(message, F("optional_public_import_message"));

  946.   EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, import_e_));

  947.   EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, import_e_));

  948.   sub_message = &reflection->GetMessage(message, F("optional_lazy_message"));

  949.   EXPECT_FALSE(sub_message->GetReflection()->HasField(*sub_message, nested_b_));

  950.   EXPECT_EQ(0, sub_message->GetReflection()->GetInt32(*sub_message, nested_b_));

  951. 

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

  953.   EXPECT_EQ(nested_foo_,

  954.             reflection->GetEnum(message, F("optional_nested_enum")));

  955.   EXPECT_EQ(foreign_foo_,

  956.             reflection->GetEnum(message, F("optional_foreign_enum")));

  957.   EXPECT_EQ(import_foo_,

  958.             reflection->GetEnum(message, F("optional_import_enum")));

  959. 

  960.   EXPECT_EQ("", reflection->GetString(message, F("optional_string_piece")));

  961.   EXPECT_EQ("", reflection->GetStringReference(

  962.                     message, F("optional_string_piece"), &scratch));

  963. 

  964.   EXPECT_EQ("", reflection->GetString(message, F("optional_cord")));

  965.   EXPECT_EQ("", reflection->GetStringReference(message, F("optional_cord"),

  966.                                                &scratch));

  967. 

  968.   // Repeated fields are empty.

  969.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int32")));

  970.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_int64")));

  971.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint32")));

  972.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_uint64")));

  973.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint32")));

  974.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sint64")));

  975.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed32")));

  976.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_fixed64")));

  977.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed32")));

  978.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_sfixed64")));

  979.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_float")));

  980.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_double")));

  981.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bool")));

  982.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string")));

  983.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_bytes")));

  984. 

  985.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeatedgroup")));

  986.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_message")));

  987.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_message")));

  988.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_message")));

  989.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_lazy_message")));

  990.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_nested_enum")));

  991.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_foreign_enum")));

  992.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_import_enum")));

  993. 

  994.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_string_piece")));

  995.   EXPECT_EQ(0, reflection->FieldSize(message, F("repeated_cord")));

  996. 

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

  998.   EXPECT_FALSE(reflection->HasField(message, F("default_int32")));

  999.   EXPECT_FALSE(reflection->HasField(message, F("default_int64")));

  1000.   EXPECT_FALSE(reflection->HasField(message, F("default_uint32")));

  1001.   EXPECT_FALSE(reflection->HasField(message, F("default_uint64")));

  1002.   EXPECT_FALSE(reflection->HasField(message, F("default_sint32")));

  1003.   EXPECT_FALSE(reflection->HasField(message, F("default_sint64")));

  1004.   EXPECT_FALSE(reflection->HasField(message, F("default_fixed32")));

  1005.   EXPECT_FALSE(reflection->HasField(message, F("default_fixed64")));

  1006.   EXPECT_FALSE(reflection->HasField(message, F("default_sfixed32")));

  1007.   EXPECT_FALSE(reflection->HasField(message, F("default_sfixed64")));

  1008.   EXPECT_FALSE(reflection->HasField(message, F("default_float")));

  1009.   EXPECT_FALSE(reflection->HasField(message, F("default_double")));

  1010.   EXPECT_FALSE(reflection->HasField(message, F("default_bool")));

  1011.   EXPECT_FALSE(reflection->HasField(message, F("default_string")));

  1012.   EXPECT_FALSE(reflection->HasField(message, F("default_bytes")));

  1013. 

  1014.   EXPECT_FALSE(reflection->HasField(message, F("default_nested_enum")));

  1015.   EXPECT_FALSE(reflection->HasField(message, F("default_foreign_enum")));

  1016.   EXPECT_FALSE(reflection->HasField(message, F("default_import_enum")));

  1017. 

  1018.   EXPECT_FALSE(reflection->HasField(message, F("default_string_piece")));

  1019.   EXPECT_FALSE(reflection->HasField(message, F("default_cord")));

  1020. 

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

  1022.   EXPECT_EQ(41, reflection->GetInt32(message, F("default_int32")));

  1023.   EXPECT_EQ(42, reflection->GetInt64(message, F("default_int64")));

  1024.   EXPECT_EQ(43, reflection->GetUInt32(message, F("default_uint32")));

  1025.   EXPECT_EQ(44, reflection->GetUInt64(message, F("default_uint64")));

  1026.   EXPECT_EQ(-45, reflection->GetInt32(message, F("default_sint32")));

  1027.   EXPECT_EQ(46, reflection->GetInt64(message, F("default_sint64")));

  1028.   EXPECT_EQ(47, reflection->GetUInt32(message, F("default_fixed32")));

  1029.   EXPECT_EQ(48, reflection->GetUInt64(message, F("default_fixed64")));

  1030.   EXPECT_EQ(49, reflection->GetInt32(message, F("default_sfixed32")));

  1031.   EXPECT_EQ(-50, reflection->GetInt64(message, F("default_sfixed64")));

  1032.   EXPECT_EQ(51.5, reflection->GetFloat(message, F("default_float")));

  1033.   EXPECT_EQ(52e3, reflection->GetDouble(message, F("default_double")));

  1034.   EXPECT_TRUE(reflection->GetBool(message, F("default_bool")));

  1035.   EXPECT_EQ("hello", reflection->GetString(message, F("default_string")));

  1036.   EXPECT_EQ("world", reflection->GetString(message, F("default_bytes")));

  1037. 

  1038.   EXPECT_EQ("hello", reflection->GetStringReference(

  1039.                          message, F("default_string"), &scratch));

  1040.   EXPECT_EQ("world", reflection->GetStringReference(message, F("default_bytes"),

  1041.                                                     &scratch));

  1042. 

  1043.   EXPECT_EQ(nested_bar_,

  1044.             reflection->GetEnum(message, F("default_nested_enum")));

  1045.   EXPECT_EQ(foreign_bar_,

  1046.             reflection->GetEnum(message, F("default_foreign_enum")));

  1047.   EXPECT_EQ(import_bar_,

  1048.             reflection->GetEnum(message, F("default_import_enum")));

  1049. 

  1050.   EXPECT_EQ("abc", reflection->GetString(message, F("default_string_piece")));

  1051.   EXPECT_EQ("abc", reflection->GetStringReference(

  1052.                        message, F("default_string_piece"), &scratch));

  1053. 

  1054.   EXPECT_EQ("123", reflection->GetString(message, F("default_cord")));

  1055.   EXPECT_EQ("123", reflection->GetStringReference(message, F("default_cord"),

  1056.                                                   &scratch));

  1057. }

  1058. 

  1059. // -------------------------------------------------------------------

  1060. 

  1061. inline void TestUtil::ReflectionTester::ModifyRepeatedFieldsViaReflection(

  1062.     Message* message) {

  1063.   const Reflection* reflection = message->GetReflection();

  1064.   Message* sub_message;

  1065. 

  1066.   reflection->SetRepeatedInt32(message, F("repeated_int32"), 1, 501);

  1067.   reflection->SetRepeatedInt64(message, F("repeated_int64"), 1, 502);

  1068.   reflection->SetRepeatedUInt32(message, F("repeated_uint32"), 1, 503);

  1069.   reflection->SetRepeatedUInt64(message, F("repeated_uint64"), 1, 504);

  1070.   reflection->SetRepeatedInt32(message, F("repeated_sint32"), 1, 505);

  1071.   reflection->SetRepeatedInt64(message, F("repeated_sint64"), 1, 506);

  1072.   reflection->SetRepeatedUInt32(message, F("repeated_fixed32"), 1, 507);

  1073.   reflection->SetRepeatedUInt64(message, F("repeated_fixed64"), 1, 508);

  1074.   reflection->SetRepeatedInt32(message, F("repeated_sfixed32"), 1, 509);

  1075.   reflection->SetRepeatedInt64(message, F("repeated_sfixed64"), 1, 510);

  1076.   reflection->SetRepeatedFloat(message, F("repeated_float"), 1, 511);

  1077.   reflection->SetRepeatedDouble(message, F("repeated_double"), 1, 512);

  1078.   reflection->SetRepeatedBool(message, F("repeated_bool"), 1, true);

  1079.   reflection->SetRepeatedString(message, F("repeated_string"), 1, "515");

  1080.   reflection->SetRepeatedString(message, F("repeated_bytes"), 1, "516");

  1081. 

  1082.   sub_message =

  1083.       reflection->MutableRepeatedMessage(message, F("repeatedgroup"), 1);

  1084.   sub_message->GetReflection()->SetInt32(sub_message, repeated_group_a_, 517);

  1085.   sub_message = reflection->MutableRepeatedMessage(

  1086.       message, F("repeated_nested_message"), 1);

  1087.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 518);

  1088.   sub_message = reflection->MutableRepeatedMessage(

  1089.       message, F("repeated_foreign_message"), 1);

  1090.   sub_message->GetReflection()->SetInt32(sub_message, foreign_c_, 519);

  1091.   sub_message = reflection->MutableRepeatedMessage(

  1092.       message, F("repeated_import_message"), 1);

  1093.   sub_message->GetReflection()->SetInt32(sub_message, import_d_, 520);

  1094.   sub_message = reflection->MutableRepeatedMessage(

  1095.       message, F("repeated_lazy_message"), 1);

  1096.   sub_message->GetReflection()->SetInt32(sub_message, nested_b_, 527);

  1097. 

  1098.   reflection->SetRepeatedEnum(message, F("repeated_nested_enum"), 1,

  1099.                               nested_foo_);

  1100.   reflection->SetRepeatedEnum(message, F("repeated_foreign_enum"), 1,

  1101.                               foreign_foo_);

  1102.   reflection->SetRepeatedEnum(message, F("repeated_import_enum"), 1,

  1103.                               import_foo_);

  1104. 

  1105.   reflection->SetRepeatedString(message, F("repeated_string_piece"), 1, "524");

  1106.   reflection->SetRepeatedString(message, F("repeated_cord"), 1, "525");

  1107. }

  1108. 

  1109. inline void TestUtil::ReflectionTester::RemoveLastRepeatedsViaReflection(

  1110.     Message* message) {

  1111.   const Reflection* reflection = message->GetReflection();

  1112. 

  1113.   std::vector<const FieldDescriptor*> output;

  1114.   reflection->ListFields(*message, &output);

  1115.   for (int i = 0; i < output.size(); ++i) {

  1116.     const FieldDescriptor* field = output[i];

  1117.     if (!field->is_repeated()) continue;

  1118. 

  1119.     reflection->RemoveLast(message, field);

  1120.   }

  1121. }

  1122. 

  1123. inline void TestUtil::ReflectionTester::ReleaseLastRepeatedsViaReflection(

  1124.     Message* message, bool expect_extensions_notnull) {

  1125.   const Reflection* reflection = message->GetReflection();

  1126. 

  1127.   std::vector<const FieldDescriptor*> output;

  1128.   reflection->ListFields(*message, &output);

  1129.   for (int i = 0; i < output.size(); ++i) {

  1130.     const FieldDescriptor* field = output[i];

  1131.     if (!field->is_repeated()) continue;

  1132.     if (field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) continue;

  1133. 

  1134.     Message* released = reflection->ReleaseLast(message, field);

  1135.     if (!field->is_extension() || expect_extensions_notnull) {

  1136.       ASSERT_TRUE(released != nullptr)

  1137.           << "ReleaseLast returned nullptr for: " << field->name();

  1138.     }

  1139.     delete released;

  1140.   }

  1141. }

  1142. 

  1143. inline void TestUtil::ReflectionTester::SwapRepeatedsViaReflection(

  1144.     Message* message) {

  1145.   const Reflection* reflection = message->GetReflection();

  1146. 

  1147.   std::vector<const FieldDescriptor*> output;

  1148.   reflection->ListFields(*message, &output);

  1149.   for (int i = 0; i < output.size(); ++i) {

  1150.     const FieldDescriptor* field = output[i];

  1151.     if (!field->is_repeated()) continue;

  1152. 

  1153.     reflection->SwapElements(message, field, 0, 1);

  1154.   }

  1155. }

  1156. 

  1157. inline void TestUtil::ReflectionTester::

  1158.     SetAllocatedOptionalMessageFieldsToNullViaReflection(Message* message) {

  1159.   const Reflection* reflection = message->GetReflection();

  1160. 

  1161.   std::vector<const FieldDescriptor*> fields;

  1162.   reflection->ListFields(*message, &fields);

  1163. 

  1164.   for (int i = 0; i < fields.size(); ++i) {

  1165.     const FieldDescriptor* field = fields[i];

  1166.     if (!field->is_optional() ||

  1167.         field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE)

  1168.       continue;

  1169. 

  1170.     reflection->SetAllocatedMessage(message, nullptr, field);

  1171.   }

  1172. }

  1173. 

  1174. inline void TestUtil::ReflectionTester::

  1175.     SetAllocatedOptionalMessageFieldsToMessageViaReflection(

  1176.         Message* from_message, Message* to_message) {

  1177.   EXPECT_EQ(from_message->GetDescriptor(), to_message->GetDescriptor());

  1178.   const Reflection* from_reflection = from_message->GetReflection();

  1179.   const Reflection* to_reflection = to_message->GetReflection();

  1180. 

  1181.   std::vector<const FieldDescriptor*> fields;

  1182.   from_reflection->ListFields(*from_message, &fields);

  1183. 

  1184.   for (int i = 0; i < fields.size(); ++i) {

  1185.     const FieldDescriptor* field = fields[i];

  1186.     if (!field->is_optional() ||

  1187.         field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE)

  1188.       continue;

  1189. 

  1190.     Message* sub_message = from_reflection->ReleaseMessage(from_message, field);

  1191.     to_reflection->SetAllocatedMessage(to_message, sub_message, field);

  1192.   }

  1193. }

  1194. 

  1195. inline void TestUtil::ReflectionTester::ExpectMessagesReleasedViaReflection(

  1196.     Message* message,

  1197.     TestUtil::ReflectionTester::MessageReleaseState expected_release_state) {

  1198.   const Reflection* reflection = message->GetReflection();

  1199. 

  1200.   static const char* fields[] = {

  1201.       "optionalgroup",

  1202.       "optional_nested_message",

  1203.       "optional_foreign_message",

  1204.       "optional_import_message",

  1205.   };

  1206.   for (int i = 0; i < GOOGLE_ARRAYSIZE(fields); i++) {

  1207.     const Message& sub_message = reflection->GetMessage(*message, F(fields[i]));

  1208.     Message* released = reflection->ReleaseMessage(message, F(fields[i]));

  1209.     switch (expected_release_state) {

  1210.       case IS_NULL:

  1211.         EXPECT_TRUE(released == nullptr);

  1212.         break;

  1213.       case NOT_NULL:

  1214.         EXPECT_TRUE(released != nullptr);

  1215.         if (message->GetArena() == nullptr) {

  1216.           // released message must be same as sub_message if source message is

  1217.           // not on arena.

  1218.           EXPECT_EQ(&sub_message, released);

  1219.         }

  1220.         break;

  1221.       case CAN_BE_NULL:

  1222.         break;

  1223.     }

  1224.     delete released;

  1225.     EXPECT_FALSE(reflection->HasField(*message, F(fields[i])));

  1226.   }

  1227. }

  1228. 

  1229. // Check that the passed-in serialization is the canonical serialization we

  1230. // expect for a TestFieldOrderings message filled in by

  1231. // SetAllFieldsAndExtensions().

  1232. inline void ExpectAllFieldsAndExtensionsInOrder(const std::string& serialized) {

  1233.   // We set each field individually, serialize separately, and concatenate all

  1234.   // the strings in canonical order to determine the expected serialization.

  1235.   std::string expected;

  1236.   unittest::TestFieldOrderings message;

  1237.   message.set_my_int(1);  // Field 1.

  1238.   message.AppendToString(&expected);

  1239.   message.Clear();

  1240.   message.SetExtension(unittest::my_extension_int, 23);  // Field 5.

  1241.   message.AppendToString(&expected);

  1242.   message.Clear();

  1243.   message.set_my_string("foo");  // Field 11.

  1244.   message.AppendToString(&expected);

  1245.   message.Clear();

  1246.   message.SetExtension(unittest::my_extension_string, "bar");  // Field 50.

  1247.   message.AppendToString(&expected);

  1248.   message.Clear();

  1249.   message.set_my_float(1.0);  // Field 101.

  1250.   message.AppendToString(&expected);

  1251.   message.Clear();

  1252. 

  1253.   // We don't EXPECT_EQ() since we don't want to print raw bytes to stdout.

  1254.   EXPECT_TRUE(serialized == expected);

  1255. }

  1256. 

  1257. }  // namespace TestUtil

  1258. }  // namespace protobuf

  1259. }  // namespace google

  1260. 

  1261. #include <google/protobuf/port_undef.inc>

  1262. 

  1263. #endif  // GOOGLE_PROTOBUF_TEST_UTIL_H__