zhaobu
/
zhujimajiang_redis
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
诸暨麻将添加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 Labels
${ item.name }
Maak branch ${ searchTerm }
van 'b4b92574b0'
${ noResults }
zhujimajiang_redis/俱乐部/Source/Protobuf/google/protobuf/map_test_util.h

1515 regels
66 KiB
Ruw Blame Geschiedenis 

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

  32. #define GOOGLE_PROTOBUF_MAP_TEST_UTIL_H__

  33. 

  34. #include <google/protobuf/map_unittest.pb.h>

  35. 

  36. #define UNITTEST ::protobuf_unittest

  37. // Must define UNITTEST before including map_test_util.inc.

  38. #include <google/protobuf/map_test_util.inc>

  39. #undef UNITTEST

  40. 

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

  42. 

  43. namespace google {

  44. namespace protobuf {

  45. 

  46. namespace unittest = ::protobuf_unittest;

  47. 

  48. 

  49. // Like above, but use the reflection interface.

  50. class MapReflectionTester {

  51.  public:

  52.   // base_descriptor must be a descriptor for TestMap, which is used for

  53.   // MapReflectionTester to fetch the FieldDescriptors needed to use the

  54.   // reflection interface.

  55.   explicit MapReflectionTester(const Descriptor* base_descriptor);

  56. 

  57.   void SetMapFieldsViaReflection(Message* message);

  58.   void SetMapFieldsViaMapReflection(Message* message);

  59.   void ClearMapFieldsViaReflection(Message* message);

  60.   void ModifyMapFieldsViaReflection(Message* message);

  61.   void RemoveLastMapsViaReflection(Message* message);

  62.   void ReleaseLastMapsViaReflection(Message* message);

  63.   void SwapMapsViaReflection(Message* message);

  64.   void MutableUnknownFieldsOfMapFieldsViaReflection(Message* message);

  65.   void ExpectMapFieldsSetViaReflection(const Message& message);

  66.   void ExpectMapFieldsSetViaReflectionIterator(Message* message);

  67.   void ExpectClearViaReflection(const Message& message);

  68.   void ExpectClearViaReflectionIterator(Message* message);

  69.   void GetMapValueViaMapReflection(Message* message,

  70.                                    const std::string& field_name,

  71.                                    const MapKey& map_key, MapValueRef* map_val);

  72.   Message* GetMapEntryViaReflection(Message* message,

  73.                                     const std::string& field_name, int index);

  74.   MapIterator MapBegin(Message* message, const std::string& field_name);

  75.   MapIterator MapEnd(Message* message, const std::string& field_name);

  76. 

  77.  private:

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

  79. 

  80.   const Descriptor* base_descriptor_;

  81. 

  82.   const EnumValueDescriptor* map_enum_bar_;

  83.   const EnumValueDescriptor* map_enum_baz_;

  84.   const EnumValueDescriptor* map_enum_foo_;

  85. 

  86.   const FieldDescriptor* foreign_c_;

  87.   const FieldDescriptor* map_int32_int32_key_;

  88.   const FieldDescriptor* map_int32_int32_val_;

  89.   const FieldDescriptor* map_int64_int64_key_;

  90.   const FieldDescriptor* map_int64_int64_val_;

  91.   const FieldDescriptor* map_uint32_uint32_key_;

  92.   const FieldDescriptor* map_uint32_uint32_val_;

  93.   const FieldDescriptor* map_uint64_uint64_key_;

  94.   const FieldDescriptor* map_uint64_uint64_val_;

  95.   const FieldDescriptor* map_sint32_sint32_key_;

  96.   const FieldDescriptor* map_sint32_sint32_val_;

  97.   const FieldDescriptor* map_sint64_sint64_key_;

  98.   const FieldDescriptor* map_sint64_sint64_val_;

  99.   const FieldDescriptor* map_fixed32_fixed32_key_;

  100.   const FieldDescriptor* map_fixed32_fixed32_val_;

  101.   const FieldDescriptor* map_fixed64_fixed64_key_;

  102.   const FieldDescriptor* map_fixed64_fixed64_val_;

  103.   const FieldDescriptor* map_sfixed32_sfixed32_key_;

  104.   const FieldDescriptor* map_sfixed32_sfixed32_val_;

  105.   const FieldDescriptor* map_sfixed64_sfixed64_key_;

  106.   const FieldDescriptor* map_sfixed64_sfixed64_val_;

  107.   const FieldDescriptor* map_int32_float_key_;

  108.   const FieldDescriptor* map_int32_float_val_;

  109.   const FieldDescriptor* map_int32_double_key_;

  110.   const FieldDescriptor* map_int32_double_val_;

  111.   const FieldDescriptor* map_bool_bool_key_;

  112.   const FieldDescriptor* map_bool_bool_val_;

  113.   const FieldDescriptor* map_string_string_key_;

  114.   const FieldDescriptor* map_string_string_val_;

  115.   const FieldDescriptor* map_int32_bytes_key_;

  116.   const FieldDescriptor* map_int32_bytes_val_;

  117.   const FieldDescriptor* map_int32_enum_key_;

  118.   const FieldDescriptor* map_int32_enum_val_;

  119.   const FieldDescriptor* map_int32_foreign_message_key_;

  120.   const FieldDescriptor* map_int32_foreign_message_val_;

  121. };

  122. 

  123. inline MapReflectionTester::MapReflectionTester(

  124.     const Descriptor* base_descriptor)

  125.     : base_descriptor_(base_descriptor) {

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

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

  128. 

  129.   map_enum_foo_ = pool->FindEnumValueByName(package + ".MAP_ENUM_FOO");

  130.   map_enum_bar_ = pool->FindEnumValueByName(package + ".MAP_ENUM_BAR");

  131.   map_enum_baz_ = pool->FindEnumValueByName(package + ".MAP_ENUM_BAZ");

  132. 

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

  134.   map_int32_int32_key_ =

  135.       pool->FindFieldByName(package + ".TestMap.MapInt32Int32Entry.key");

  136.   map_int32_int32_val_ =

  137.       pool->FindFieldByName(package + ".TestMap.MapInt32Int32Entry.value");

  138.   map_int64_int64_key_ =

  139.       pool->FindFieldByName(package + ".TestMap.MapInt64Int64Entry.key");

  140.   map_int64_int64_val_ =

  141.       pool->FindFieldByName(package + ".TestMap.MapInt64Int64Entry.value");

  142.   map_uint32_uint32_key_ =

  143.       pool->FindFieldByName(package + ".TestMap.MapUint32Uint32Entry.key");

  144.   map_uint32_uint32_val_ =

  145.       pool->FindFieldByName(package + ".TestMap.MapUint32Uint32Entry.value");

  146.   map_uint64_uint64_key_ =

  147.       pool->FindFieldByName(package + ".TestMap.MapUint64Uint64Entry.key");

  148.   map_uint64_uint64_val_ =

  149.       pool->FindFieldByName(package + ".TestMap.MapUint64Uint64Entry.value");

  150.   map_sint32_sint32_key_ =

  151.       pool->FindFieldByName(package + ".TestMap.MapSint32Sint32Entry.key");

  152.   map_sint32_sint32_val_ =

  153.       pool->FindFieldByName(package + ".TestMap.MapSint32Sint32Entry.value");

  154.   map_sint64_sint64_key_ =

  155.       pool->FindFieldByName(package + ".TestMap.MapSint64Sint64Entry.key");

  156.   map_sint64_sint64_val_ =

  157.       pool->FindFieldByName(package + ".TestMap.MapSint64Sint64Entry.value");

  158.   map_fixed32_fixed32_key_ =

  159.       pool->FindFieldByName(package + ".TestMap.MapFixed32Fixed32Entry.key");

  160.   map_fixed32_fixed32_val_ =

  161.       pool->FindFieldByName(package + ".TestMap.MapFixed32Fixed32Entry.value");

  162.   map_fixed64_fixed64_key_ =

  163.       pool->FindFieldByName(package + ".TestMap.MapFixed64Fixed64Entry.key");

  164.   map_fixed64_fixed64_val_ =

  165.       pool->FindFieldByName(package + ".TestMap.MapFixed64Fixed64Entry.value");

  166.   map_sfixed32_sfixed32_key_ =

  167.       pool->FindFieldByName(package + ".TestMap.MapSfixed32Sfixed32Entry.key");

  168.   map_sfixed32_sfixed32_val_ = pool->FindFieldByName(

  169.       package + ".TestMap.MapSfixed32Sfixed32Entry.value");

  170.   map_sfixed64_sfixed64_key_ =

  171.       pool->FindFieldByName(package + ".TestMap.MapSfixed64Sfixed64Entry.key");

  172.   map_sfixed64_sfixed64_val_ = pool->FindFieldByName(

  173.       package + ".TestMap.MapSfixed64Sfixed64Entry.value");

  174.   map_int32_float_key_ =

  175.       pool->FindFieldByName(package + ".TestMap.MapInt32FloatEntry.key");

  176.   map_int32_float_val_ =

  177.       pool->FindFieldByName(package + ".TestMap.MapInt32FloatEntry.value");

  178.   map_int32_double_key_ =

  179.       pool->FindFieldByName(package + ".TestMap.MapInt32DoubleEntry.key");

  180.   map_int32_double_val_ =

  181.       pool->FindFieldByName(package + ".TestMap.MapInt32DoubleEntry.value");

  182.   map_bool_bool_key_ =

  183.       pool->FindFieldByName(package + ".TestMap.MapBoolBoolEntry.key");

  184.   map_bool_bool_val_ =

  185.       pool->FindFieldByName(package + ".TestMap.MapBoolBoolEntry.value");

  186.   map_string_string_key_ =

  187.       pool->FindFieldByName(package + ".TestMap.MapStringStringEntry.key");

  188.   map_string_string_val_ =

  189.       pool->FindFieldByName(package + ".TestMap.MapStringStringEntry.value");

  190.   map_int32_bytes_key_ =

  191.       pool->FindFieldByName(package + ".TestMap.MapInt32BytesEntry.key");

  192.   map_int32_bytes_val_ =

  193.       pool->FindFieldByName(package + ".TestMap.MapInt32BytesEntry.value");

  194.   map_int32_enum_key_ =

  195.       pool->FindFieldByName(package + ".TestMap.MapInt32EnumEntry.key");

  196.   map_int32_enum_val_ =

  197.       pool->FindFieldByName(package + ".TestMap.MapInt32EnumEntry.value");

  198.   map_int32_foreign_message_key_ = pool->FindFieldByName(

  199.       package + ".TestMap.MapInt32ForeignMessageEntry.key");

  200.   map_int32_foreign_message_val_ = pool->FindFieldByName(

  201.       package + ".TestMap.MapInt32ForeignMessageEntry.value");

  202. 

  203.   EXPECT_FALSE(map_enum_foo_ == nullptr);

  204.   EXPECT_FALSE(map_enum_bar_ == nullptr);

  205.   EXPECT_FALSE(map_enum_baz_ == nullptr);

  206.   EXPECT_FALSE(map_int32_int32_key_ == nullptr);

  207.   EXPECT_FALSE(map_int32_int32_val_ == nullptr);

  208.   EXPECT_FALSE(map_int64_int64_key_ == nullptr);

  209.   EXPECT_FALSE(map_int64_int64_val_ == nullptr);

  210.   EXPECT_FALSE(map_uint32_uint32_key_ == nullptr);

  211.   EXPECT_FALSE(map_uint32_uint32_val_ == nullptr);

  212.   EXPECT_FALSE(map_uint64_uint64_key_ == nullptr);

  213.   EXPECT_FALSE(map_uint64_uint64_val_ == nullptr);

  214.   EXPECT_FALSE(map_sint32_sint32_key_ == nullptr);

  215.   EXPECT_FALSE(map_sint32_sint32_val_ == nullptr);

  216.   EXPECT_FALSE(map_sint64_sint64_key_ == nullptr);

  217.   EXPECT_FALSE(map_sint64_sint64_val_ == nullptr);

  218.   EXPECT_FALSE(map_fixed32_fixed32_key_ == nullptr);

  219.   EXPECT_FALSE(map_fixed32_fixed32_val_ == nullptr);

  220.   EXPECT_FALSE(map_fixed64_fixed64_key_ == nullptr);

  221.   EXPECT_FALSE(map_fixed64_fixed64_val_ == nullptr);

  222.   EXPECT_FALSE(map_sfixed32_sfixed32_key_ == nullptr);

  223.   EXPECT_FALSE(map_sfixed32_sfixed32_val_ == nullptr);

  224.   EXPECT_FALSE(map_sfixed64_sfixed64_key_ == nullptr);

  225.   EXPECT_FALSE(map_sfixed64_sfixed64_val_ == nullptr);

  226.   EXPECT_FALSE(map_int32_float_key_ == nullptr);

  227.   EXPECT_FALSE(map_int32_float_val_ == nullptr);

  228.   EXPECT_FALSE(map_int32_double_key_ == nullptr);

  229.   EXPECT_FALSE(map_int32_double_val_ == nullptr);

  230.   EXPECT_FALSE(map_bool_bool_key_ == nullptr);

  231.   EXPECT_FALSE(map_bool_bool_val_ == nullptr);

  232.   EXPECT_FALSE(map_string_string_key_ == nullptr);

  233.   EXPECT_FALSE(map_string_string_val_ == nullptr);

  234.   EXPECT_FALSE(map_int32_bytes_key_ == nullptr);

  235.   EXPECT_FALSE(map_int32_bytes_val_ == nullptr);

  236.   EXPECT_FALSE(map_int32_enum_key_ == nullptr);

  237.   EXPECT_FALSE(map_int32_enum_val_ == nullptr);

  238.   EXPECT_FALSE(map_int32_foreign_message_key_ == nullptr);

  239.   EXPECT_FALSE(map_int32_foreign_message_val_ == nullptr);

  240. }

  241. 

  242. // Shorthand to get a FieldDescriptor for a field of unittest::TestMap.

  243. inline const FieldDescriptor* MapReflectionTester::F(const std::string& name) {

  244.   const FieldDescriptor* result = nullptr;

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

  246.   GOOGLE_CHECK(result != nullptr);

  247.   return result;

  248. }

  249. 

  250. inline void MapReflectionTester::SetMapFieldsViaReflection(Message* message) {

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

  252.   Message* sub_message = nullptr;

  253.   Message* sub_foreign_message = nullptr;

  254. 

  255.   // Add first element.

  256.   sub_message = reflection->AddMessage(message, F("map_int32_int32"));

  257.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_key_, 0);

  258.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_val_, 0);

  259. 

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

  261.   sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_key_, 0);

  262.   sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_val_, 0);

  263. 

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

  265.   sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_key_,

  266.                                           0);

  267.   sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_val_,

  268.                                           0);

  269. 

  270.   sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));

  271.   sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_key_,

  272.                                           0);

  273.   sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_val_,

  274.                                           0);

  275. 

  276.   sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));

  277.   sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_key_,

  278.                                          0);

  279.   sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_val_,

  280.                                          0);

  281. 

  282.   sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));

  283.   sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_key_,

  284.                                          0);

  285.   sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_val_,

  286.                                          0);

  287. 

  288.   sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));

  289.   sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_key_,

  290.                                           0);

  291.   sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_val_,

  292.                                           0);

  293. 

  294.   sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));

  295.   sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_key_,

  296.                                           0);

  297.   sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_val_,

  298.                                           0);

  299. 

  300.   sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));

  301.   sub_message->GetReflection()->SetInt32(sub_message,

  302.                                          map_sfixed32_sfixed32_key_, 0);

  303.   sub_message->GetReflection()->SetInt32(sub_message,

  304.                                          map_sfixed32_sfixed32_val_, 0);

  305. 

  306.   sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));

  307.   sub_message->GetReflection()->SetInt64(sub_message,

  308.                                          map_sfixed64_sfixed64_key_, 0);

  309.   sub_message->GetReflection()->SetInt64(sub_message,

  310.                                          map_sfixed64_sfixed64_val_, 0);

  311. 

  312.   sub_message = reflection->AddMessage(message, F("map_int32_float"));

  313.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_float_key_, 0);

  314.   sub_message->GetReflection()->SetFloat(sub_message, map_int32_float_val_,

  315.                                          0.0);

  316. 

  317.   sub_message = reflection->AddMessage(message, F("map_int32_double"));

  318.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_double_key_, 0);

  319.   sub_message->GetReflection()->SetDouble(sub_message, map_int32_double_val_,

  320.                                           0.0);

  321. 

  322.   sub_message = reflection->AddMessage(message, F("map_bool_bool"));

  323.   sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_key_, false);

  324.   sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_val_, false);

  325. 

  326.   sub_message = reflection->AddMessage(message, F("map_string_string"));

  327.   sub_message->GetReflection()->SetString(sub_message, map_string_string_key_,

  328.                                           "0");

  329.   sub_message->GetReflection()->SetString(sub_message, map_string_string_val_,

  330.                                           "0");

  331. 

  332.   sub_message = reflection->AddMessage(message, F("map_int32_bytes"));

  333.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_bytes_key_, 0);

  334.   sub_message->GetReflection()->SetString(sub_message, map_int32_bytes_val_,

  335.                                           "0");

  336. 

  337.   sub_message = reflection->AddMessage(message, F("map_int32_enum"));

  338.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_enum_key_, 0);

  339.   sub_message->GetReflection()->SetEnum(sub_message, map_int32_enum_val_,

  340.                                         map_enum_bar_);

  341. 

  342.   sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));

  343.   sub_message->GetReflection()->SetInt32(sub_message,

  344.                                          map_int32_foreign_message_key_, 0);

  345.   sub_foreign_message = sub_message->GetReflection()->MutableMessage(

  346.       sub_message, map_int32_foreign_message_val_, nullptr);

  347.   sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,

  348.                                                  foreign_c_, 0);

  349. 

  350.   // Add second element

  351.   sub_message = reflection->AddMessage(message, F("map_int32_int32"));

  352.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_key_, 1);

  353.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_int32_val_, 1);

  354. 

  355.   sub_message = reflection->AddMessage(message, F("map_int64_int64"));

  356.   sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_key_, 1);

  357.   sub_message->GetReflection()->SetInt64(sub_message, map_int64_int64_val_, 1);

  358. 

  359.   sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));

  360.   sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_key_,

  361.                                           1);

  362.   sub_message->GetReflection()->SetUInt32(sub_message, map_uint32_uint32_val_,

  363.                                           1);

  364. 

  365.   sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));

  366.   sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_key_,

  367.                                           1);

  368.   sub_message->GetReflection()->SetUInt64(sub_message, map_uint64_uint64_val_,

  369.                                           1);

  370. 

  371.   sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));

  372.   sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_key_,

  373.                                          1);

  374.   sub_message->GetReflection()->SetInt32(sub_message, map_sint32_sint32_val_,

  375.                                          1);

  376. 

  377.   sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));

  378.   sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_key_,

  379.                                          1);

  380.   sub_message->GetReflection()->SetInt64(sub_message, map_sint64_sint64_val_,

  381.                                          1);

  382. 

  383.   sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));

  384.   sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_key_,

  385.                                           1);

  386.   sub_message->GetReflection()->SetUInt32(sub_message, map_fixed32_fixed32_val_,

  387.                                           1);

  388. 

  389.   sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));

  390.   sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_key_,

  391.                                           1);

  392.   sub_message->GetReflection()->SetUInt64(sub_message, map_fixed64_fixed64_val_,

  393.                                           1);

  394. 

  395.   sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));

  396.   sub_message->GetReflection()->SetInt32(sub_message,

  397.                                          map_sfixed32_sfixed32_key_, 1);

  398.   sub_message->GetReflection()->SetInt32(sub_message,

  399.                                          map_sfixed32_sfixed32_val_, 1);

  400. 

  401.   sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));

  402.   sub_message->GetReflection()->SetInt64(sub_message,

  403.                                          map_sfixed64_sfixed64_key_, 1);

  404.   sub_message->GetReflection()->SetInt64(sub_message,

  405.                                          map_sfixed64_sfixed64_val_, 1);

  406. 

  407.   sub_message = reflection->AddMessage(message, F("map_int32_float"));

  408.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_float_key_, 1);

  409.   sub_message->GetReflection()->SetFloat(sub_message, map_int32_float_val_,

  410.                                          1.0);

  411. 

  412.   sub_message = reflection->AddMessage(message, F("map_int32_double"));

  413.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_double_key_, 1);

  414.   sub_message->GetReflection()->SetDouble(sub_message, map_int32_double_val_,

  415.                                           1.0);

  416. 

  417.   sub_message = reflection->AddMessage(message, F("map_bool_bool"));

  418.   sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_key_, true);

  419.   sub_message->GetReflection()->SetBool(sub_message, map_bool_bool_val_, true);

  420. 

  421.   sub_message = reflection->AddMessage(message, F("map_string_string"));

  422.   sub_message->GetReflection()->SetString(sub_message, map_string_string_key_,

  423.                                           "1");

  424.   sub_message->GetReflection()->SetString(sub_message, map_string_string_val_,

  425.                                           "1");

  426. 

  427.   sub_message = reflection->AddMessage(message, F("map_int32_bytes"));

  428.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_bytes_key_, 1);

  429.   sub_message->GetReflection()->SetString(sub_message, map_int32_bytes_val_,

  430.                                           "1");

  431. 

  432.   sub_message = reflection->AddMessage(message, F("map_int32_enum"));

  433.   sub_message->GetReflection()->SetInt32(sub_message, map_int32_enum_key_, 1);

  434.   sub_message->GetReflection()->SetEnum(sub_message, map_int32_enum_val_,

  435.                                         map_enum_baz_);

  436. 

  437.   sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));

  438.   sub_message->GetReflection()->SetInt32(sub_message,

  439.                                          map_int32_foreign_message_key_, 1);

  440.   sub_foreign_message = sub_message->GetReflection()->MutableMessage(

  441.       sub_message, map_int32_foreign_message_val_, nullptr);

  442.   sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,

  443.                                                  foreign_c_, 1);

  444. }

  445. 

  446. inline void MapReflectionTester::SetMapFieldsViaMapReflection(

  447.     Message* message) {

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

  449. 

  450.   Message* sub_foreign_message = nullptr;

  451.   MapValueRef map_val;

  452. 

  453.   // Add first element.

  454.   MapKey map_key;

  455.   map_key.SetInt32Value(0);

  456.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),

  457.                                                  map_key, &map_val));

  458.   map_val.SetInt32Value(0);

  459. 

  460.   map_key.SetInt64Value(0);

  461.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),

  462.                                                  map_key, &map_val));

  463.   map_val.SetInt64Value(0);

  464. 

  465.   map_key.SetUInt32Value(0);

  466.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  467.       message, F("map_uint32_uint32"), map_key, &map_val));

  468.   map_val.SetUInt32Value(0);

  469. 

  470.   map_key.SetUInt64Value(0);

  471.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  472.       message, F("map_uint64_uint64"), map_key, &map_val));

  473.   map_val.SetUInt64Value(0);

  474. 

  475.   map_key.SetInt32Value(0);

  476.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  477.       message, F("map_sint32_sint32"), map_key, &map_val));

  478.   map_val.SetInt32Value(0);

  479. 

  480.   map_key.SetInt64Value(0);

  481.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  482.       message, F("map_sint64_sint64"), map_key, &map_val));

  483.   map_val.SetInt64Value(0);

  484. 

  485.   map_key.SetUInt32Value(0);

  486.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  487.       message, F("map_fixed32_fixed32"), map_key, &map_val));

  488.   map_val.SetUInt32Value(0);

  489. 

  490.   map_key.SetUInt64Value(0);

  491.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  492.       message, F("map_fixed64_fixed64"), map_key, &map_val));

  493.   map_val.SetUInt64Value(0);

  494. 

  495.   map_key.SetInt32Value(0);

  496.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  497.       message, F("map_sfixed32_sfixed32"), map_key, &map_val));

  498.   map_val.SetInt32Value(0);

  499. 

  500.   map_key.SetInt64Value(0);

  501.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  502.       message, F("map_sfixed64_sfixed64"), map_key, &map_val));

  503.   map_val.SetInt64Value(0);

  504. 

  505.   map_key.SetInt32Value(0);

  506.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_float"),

  507.                                                  map_key, &map_val));

  508.   map_val.SetFloatValue(0.0);

  509. 

  510.   map_key.SetInt32Value(0);

  511.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_double"),

  512.                                                  map_key, &map_val));

  513.   map_val.SetDoubleValue(0.0);

  514. 

  515.   map_key.SetBoolValue(false);

  516.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_bool_bool"),

  517.                                                  map_key, &map_val));

  518.   map_val.SetBoolValue(false);

  519. 

  520.   map_key.SetStringValue("0");

  521.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  522.       message, F("map_string_string"), map_key, &map_val));

  523.   map_val.SetStringValue("0");

  524. 

  525.   map_key.SetInt32Value(0);

  526.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"),

  527.                                                  map_key, &map_val));

  528.   map_val.SetStringValue("0");

  529. 

  530.   map_key.SetInt32Value(0);

  531.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_enum"),

  532.                                                  map_key, &map_val));

  533.   map_val.SetEnumValue(map_enum_bar_->number());

  534. 

  535.   map_key.SetInt32Value(0);

  536.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  537.       message, F("map_int32_foreign_message"), map_key, &map_val));

  538.   sub_foreign_message = map_val.MutableMessageValue();

  539.   sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,

  540.                                                  foreign_c_, 0);

  541. 

  542.   // Add second element

  543.   map_key.SetInt32Value(1);

  544.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),

  545.                                                  map_key, &map_val));

  546.   map_val.SetInt32Value(1);

  547.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),

  548.                                                   map_key, &map_val));

  549. 

  550.   map_key.SetInt64Value(1);

  551.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),

  552.                                                  map_key, &map_val));

  553.   map_val.SetInt64Value(1);

  554.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),

  555.                                                   map_key, &map_val));

  556. 

  557.   map_key.SetUInt32Value(1);

  558.   reflection->InsertOrLookupMapValue(message, F("map_uint32_uint32"), map_key,

  559.                                      &map_val);

  560.   map_val.SetUInt32Value(1);

  561. 

  562.   map_key.SetUInt64Value(1);

  563.   reflection->InsertOrLookupMapValue(message, F("map_uint64_uint64"), map_key,

  564.                                      &map_val);

  565.   map_val.SetUInt64Value(1);

  566. 

  567.   map_key.SetInt32Value(1);

  568.   reflection->InsertOrLookupMapValue(message, F("map_sint32_sint32"), map_key,

  569.                                      &map_val);

  570.   map_val.SetInt32Value(1);

  571. 

  572.   map_key.SetInt64Value(1);

  573.   reflection->InsertOrLookupMapValue(message, F("map_sint64_sint64"), map_key,

  574.                                      &map_val);

  575.   map_val.SetInt64Value(1);

  576. 

  577.   map_key.SetUInt32Value(1);

  578.   reflection->InsertOrLookupMapValue(message, F("map_fixed32_fixed32"), map_key,

  579.                                      &map_val);

  580.   map_val.SetUInt32Value(1);

  581. 

  582.   map_key.SetUInt64Value(1);

  583.   reflection->InsertOrLookupMapValue(message, F("map_fixed64_fixed64"), map_key,

  584.                                      &map_val);

  585.   map_val.SetUInt64Value(1);

  586. 

  587.   map_key.SetInt32Value(1);

  588.   reflection->InsertOrLookupMapValue(message, F("map_sfixed32_sfixed32"),

  589.                                      map_key, &map_val);

  590.   map_val.SetInt32Value(1);

  591. 

  592.   map_key.SetInt64Value(1);

  593.   reflection->InsertOrLookupMapValue(message, F("map_sfixed64_sfixed64"),

  594.                                      map_key, &map_val);

  595.   map_val.SetInt64Value(1);

  596. 

  597.   map_key.SetInt32Value(1);

  598.   reflection->InsertOrLookupMapValue(message, F("map_int32_float"), map_key,

  599.                                      &map_val);

  600.   map_val.SetFloatValue(1.0);

  601. 

  602.   map_key.SetInt32Value(1);

  603.   reflection->InsertOrLookupMapValue(message, F("map_int32_double"), map_key,

  604.                                      &map_val);

  605.   map_val.SetDoubleValue(1.0);

  606. 

  607.   map_key.SetBoolValue(true);

  608.   reflection->InsertOrLookupMapValue(message, F("map_bool_bool"), map_key,

  609.                                      &map_val);

  610.   map_val.SetBoolValue(true);

  611. 

  612.   map_key.SetStringValue("1");

  613.   reflection->InsertOrLookupMapValue(message, F("map_string_string"), map_key,

  614.                                      &map_val);

  615.   map_val.SetStringValue("1");

  616. 

  617.   map_key.SetInt32Value(1);

  618.   reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"), map_key,

  619.                                      &map_val);

  620.   map_val.SetStringValue("1");

  621. 

  622.   map_key.SetInt32Value(1);

  623.   reflection->InsertOrLookupMapValue(message, F("map_int32_enum"), map_key,

  624.                                      &map_val);

  625.   map_val.SetEnumValue(map_enum_baz_->number());

  626. 

  627.   map_key.SetInt32Value(1);

  628.   EXPECT_TRUE(reflection->InsertOrLookupMapValue(

  629.       message, F("map_int32_foreign_message"), map_key, &map_val));

  630.   sub_foreign_message = map_val.MutableMessageValue();

  631.   sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,

  632.                                                  foreign_c_, 1);

  633. }

  634. 

  635. inline void MapReflectionTester::GetMapValueViaMapReflection(

  636.     Message* message, const std::string& field_name, const MapKey& map_key,

  637.     MapValueRef* map_val) {

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

  639.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F(field_name),

  640.                                                   map_key, map_val));

  641. }

  642. 

  643. inline Message* MapReflectionTester::GetMapEntryViaReflection(

  644.     Message* message, const std::string& field_name, int index) {

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

  646.   return reflection->MutableRepeatedMessage(message, F(field_name), index);

  647. }

  648. 

  649. inline MapIterator MapReflectionTester::MapBegin(

  650.     Message* message, const std::string& field_name) {

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

  652.   return reflection->MapBegin(message, F(field_name));

  653. }

  654. 

  655. inline MapIterator MapReflectionTester::MapEnd(Message* message,

  656.                                                const std::string& field_name) {

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

  658.   return reflection->MapEnd(message, F(field_name));

  659. }

  660. 

  661. inline void MapReflectionTester::ClearMapFieldsViaReflection(Message* message) {

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

  663. 

  664.   reflection->ClearField(message, F("map_int32_int32"));

  665.   reflection->ClearField(message, F("map_int64_int64"));

  666.   reflection->ClearField(message, F("map_uint32_uint32"));

  667.   reflection->ClearField(message, F("map_uint64_uint64"));

  668.   reflection->ClearField(message, F("map_sint32_sint32"));

  669.   reflection->ClearField(message, F("map_sint64_sint64"));

  670.   reflection->ClearField(message, F("map_fixed32_fixed32"));

  671.   reflection->ClearField(message, F("map_fixed64_fixed64"));

  672.   reflection->ClearField(message, F("map_sfixed32_sfixed32"));

  673.   reflection->ClearField(message, F("map_sfixed64_sfixed64"));

  674.   reflection->ClearField(message, F("map_int32_float"));

  675.   reflection->ClearField(message, F("map_int32_double"));

  676.   reflection->ClearField(message, F("map_bool_bool"));

  677.   reflection->ClearField(message, F("map_string_string"));

  678.   reflection->ClearField(message, F("map_int32_bytes"));

  679.   reflection->ClearField(message, F("map_int32_enum"));

  680.   reflection->ClearField(message, F("map_int32_foreign_message"));

  681. }

  682. 

  683. inline void MapReflectionTester::ModifyMapFieldsViaReflection(

  684.     Message* message) {

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

  686.   MapValueRef map_val;

  687.   Message* sub_foreign_message;

  688. 

  689.   // Modify the second element

  690.   MapKey map_key;

  691.   map_key.SetInt32Value(1);

  692.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int32_int32"),

  693.                                                   map_key, &map_val));

  694.   map_val.SetInt32Value(2);

  695. 

  696.   map_key.SetInt64Value(1);

  697.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(message, F("map_int64_int64"),

  698.                                                   map_key, &map_val));

  699.   map_val.SetInt64Value(2);

  700. 

  701.   map_key.SetUInt32Value(1);

  702.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(

  703.       message, F("map_uint32_uint32"), map_key, &map_val));

  704.   map_val.SetUInt32Value(2);

  705. 

  706.   map_key.SetUInt64Value(1);

  707.   reflection->InsertOrLookupMapValue(message, F("map_uint64_uint64"), map_key,

  708.                                      &map_val);

  709.   map_val.SetUInt64Value(2);

  710. 

  711.   map_key.SetInt32Value(1);

  712.   reflection->InsertOrLookupMapValue(message, F("map_sint32_sint32"), map_key,

  713.                                      &map_val);

  714.   map_val.SetInt32Value(2);

  715. 

  716.   map_key.SetInt64Value(1);

  717.   reflection->InsertOrLookupMapValue(message, F("map_sint64_sint64"), map_key,

  718.                                      &map_val);

  719.   map_val.SetInt64Value(2);

  720. 

  721.   map_key.SetUInt32Value(1);

  722.   reflection->InsertOrLookupMapValue(message, F("map_fixed32_fixed32"), map_key,

  723.                                      &map_val);

  724.   map_val.SetUInt32Value(2);

  725. 

  726.   map_key.SetUInt64Value(1);

  727.   reflection->InsertOrLookupMapValue(message, F("map_fixed64_fixed64"), map_key,

  728.                                      &map_val);

  729.   map_val.SetUInt64Value(2);

  730. 

  731.   map_key.SetInt32Value(1);

  732.   reflection->InsertOrLookupMapValue(message, F("map_sfixed32_sfixed32"),

  733.                                      map_key, &map_val);

  734.   map_val.SetInt32Value(2);

  735. 

  736.   map_key.SetInt64Value(1);

  737.   reflection->InsertOrLookupMapValue(message, F("map_sfixed64_sfixed64"),

  738.                                      map_key, &map_val);

  739.   map_val.SetInt64Value(2);

  740. 

  741.   map_key.SetInt32Value(1);

  742.   reflection->InsertOrLookupMapValue(message, F("map_int32_float"), map_key,

  743.                                      &map_val);

  744.   map_val.SetFloatValue(2.0);

  745. 

  746.   map_key.SetInt32Value(1);

  747.   reflection->InsertOrLookupMapValue(message, F("map_int32_double"), map_key,

  748.                                      &map_val);

  749.   map_val.SetDoubleValue(2.0);

  750. 

  751.   map_key.SetBoolValue(true);

  752.   reflection->InsertOrLookupMapValue(message, F("map_bool_bool"), map_key,

  753.                                      &map_val);

  754.   map_val.SetBoolValue(false);

  755. 

  756.   map_key.SetStringValue("1");

  757.   reflection->InsertOrLookupMapValue(message, F("map_string_string"), map_key,

  758.                                      &map_val);

  759.   map_val.SetStringValue("2");

  760. 

  761.   map_key.SetInt32Value(1);

  762.   reflection->InsertOrLookupMapValue(message, F("map_int32_bytes"), map_key,

  763.                                      &map_val);

  764.   map_val.SetStringValue("2");

  765. 

  766.   map_key.SetInt32Value(1);

  767.   reflection->InsertOrLookupMapValue(message, F("map_int32_enum"), map_key,

  768.                                      &map_val);

  769.   map_val.SetEnumValue(map_enum_foo_->number());

  770. 

  771.   map_key.SetInt32Value(1);

  772.   EXPECT_FALSE(reflection->InsertOrLookupMapValue(

  773.       message, F("map_int32_foreign_message"), map_key, &map_val));

  774.   sub_foreign_message = map_val.MutableMessageValue();

  775.   sub_foreign_message->GetReflection()->SetInt32(sub_foreign_message,

  776.                                                  foreign_c_, 2);

  777. }

  778. 

  779. inline void MapReflectionTester::RemoveLastMapsViaReflection(Message* message) {

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

  781. 

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

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

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

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

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

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

  788.   }

  789. }

  790. 

  791. inline void MapReflectionTester::ReleaseLastMapsViaReflection(

  792.     Message* message) {

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

  794. 

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

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

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

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

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

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

  801. 

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

  803.     ASSERT_TRUE(released != nullptr)

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

  805.     delete released;

  806.   }

  807. }

  808. 

  809. inline void MapReflectionTester::SwapMapsViaReflection(Message* message) {

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

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

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

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

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

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

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

  817.   }

  818. }

  819. 

  820. inline void MapReflectionTester::MutableUnknownFieldsOfMapFieldsViaReflection(

  821.     Message* message) {

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

  823.   Message* sub_message = nullptr;

  824. 

  825.   sub_message = reflection->AddMessage(message, F("map_int32_int32"));

  826.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  827.               nullptr);

  828.   sub_message = reflection->AddMessage(message, F("map_int64_int64"));

  829.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  830.               nullptr);

  831.   sub_message = reflection->AddMessage(message, F("map_uint32_uint32"));

  832.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  833.               nullptr);

  834.   sub_message = reflection->AddMessage(message, F("map_uint64_uint64"));

  835.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  836.               nullptr);

  837.   sub_message = reflection->AddMessage(message, F("map_sint32_sint32"));

  838.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  839.               nullptr);

  840.   sub_message = reflection->AddMessage(message, F("map_sint64_sint64"));

  841.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  842.               nullptr);

  843.   sub_message = reflection->AddMessage(message, F("map_fixed32_fixed32"));

  844.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  845.               nullptr);

  846.   sub_message = reflection->AddMessage(message, F("map_fixed64_fixed64"));

  847.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  848.               nullptr);

  849.   sub_message = reflection->AddMessage(message, F("map_sfixed32_sfixed32"));

  850.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  851.               nullptr);

  852.   sub_message = reflection->AddMessage(message, F("map_sfixed64_sfixed64"));

  853.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  854.               nullptr);

  855.   sub_message = reflection->AddMessage(message, F("map_int32_float"));

  856.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  857.               nullptr);

  858.   sub_message = reflection->AddMessage(message, F("map_int32_double"));

  859.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  860.               nullptr);

  861.   sub_message = reflection->AddMessage(message, F("map_bool_bool"));

  862.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  863.               nullptr);

  864.   sub_message = reflection->AddMessage(message, F("map_string_string"));

  865.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  866.               nullptr);

  867.   sub_message = reflection->AddMessage(message, F("map_int32_bytes"));

  868.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  869.               nullptr);

  870.   sub_message = reflection->AddMessage(message, F("map_int32_enum"));

  871.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  872.               nullptr);

  873.   sub_message = reflection->AddMessage(message, F("map_int32_foreign_message"));

  874.   EXPECT_TRUE(sub_message->GetReflection()->MutableUnknownFields(sub_message) !=

  875.               nullptr);

  876. }

  877. 

  878. inline void MapReflectionTester::ExpectMapFieldsSetViaReflection(

  879.     const Message& message) {

  880.   std::string scratch;

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

  882.   const Message* sub_message;

  883.   MapKey map_key;

  884. 

  885.   // -----------------------------------------------------------------

  886. 

  887.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_int32")));

  888.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int64_int64")));

  889.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint32_uint32")));

  890.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_uint64_uint64")));

  891.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint32_sint32")));

  892.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_sint64_sint64")));

  893.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed32_fixed32")));

  894.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_fixed64_fixed64")));

  895.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed32_sfixed32")));

  896.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_sfixed64_sfixed64")));

  897.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_float")));

  898.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_double")));

  899.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_bool_bool")));

  900.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_string_string")));

  901.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_bytes")));

  902.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_enum")));

  903.   ASSERT_EQ(2, reflection->FieldSize(message, F("map_int32_foreign_message")));

  904. 

  905.   {

  906.     std::map<int32, int32> map;

  907.     map[0] = 0;

  908.     map[1] = 1;

  909.     for (int i = 0; i < 2; i++) {

  910.       // Check with RepeatedField Reflection

  911.       sub_message =

  912.           &reflection->GetRepeatedMessage(message, F("map_int32_int32"), i);

  913.       int32 key = sub_message->GetReflection()->GetInt32(*sub_message,

  914.                                                          map_int32_int32_key_);

  915.       int32 val = sub_message->GetReflection()->GetInt32(*sub_message,

  916.                                                          map_int32_int32_val_);

  917.       EXPECT_EQ(map[key], val);

  918.       // Check with Map Reflection

  919.       map_key.SetInt32Value(key);

  920.       EXPECT_TRUE(

  921.           reflection->ContainsMapKey(message, F("map_int32_int32"), map_key));

  922.     }

  923.   }

  924.   {

  925.     std::map<int64, int64> map;

  926.     map[0] = 0;

  927.     map[1] = 1;

  928.     for (int i = 0; i < 2; i++) {

  929.       // Check with RepeatedField Reflection

  930.       sub_message =

  931.           &reflection->GetRepeatedMessage(message, F("map_int64_int64"), i);

  932.       int64 key = sub_message->GetReflection()->GetInt64(*sub_message,

  933.                                                          map_int64_int64_key_);

  934.       int64 val = sub_message->GetReflection()->GetInt64(*sub_message,

  935.                                                          map_int64_int64_val_);

  936.       EXPECT_EQ(map[key], val);

  937.       // Check with Map Reflection

  938.       map_key.SetInt64Value(key);

  939.       EXPECT_TRUE(

  940.           reflection->ContainsMapKey(message, F("map_int64_int64"), map_key));

  941.     }

  942.   }

  943.   {

  944.     std::map<uint32, uint32> map;

  945.     map[0] = 0;

  946.     map[1] = 1;

  947.     for (int i = 0; i < 2; i++) {

  948.       // Check with RepeatedField Reflection

  949.       sub_message =

  950.           &reflection->GetRepeatedMessage(message, F("map_uint32_uint32"), i);

  951.       uint32 key = sub_message->GetReflection()->GetUInt32(

  952.           *sub_message, map_uint32_uint32_key_);

  953.       uint32 val = sub_message->GetReflection()->GetUInt32(

  954.           *sub_message, map_uint32_uint32_val_);

  955.       EXPECT_EQ(map[key], val);

  956.       // Check with Map Reflection

  957.       map_key.SetUInt32Value(key);

  958.       EXPECT_TRUE(

  959.           reflection->ContainsMapKey(message, F("map_uint32_uint32"), map_key));

  960.     }

  961.   }

  962.   {

  963.     std::map<uint64, uint64> map;

  964.     map[0] = 0;

  965.     map[1] = 1;

  966.     for (int i = 0; i < 2; i++) {

  967.       sub_message =

  968.           &reflection->GetRepeatedMessage(message, F("map_uint64_uint64"), i);

  969.       uint64 key = sub_message->GetReflection()->GetUInt64(

  970.           *sub_message, map_uint64_uint64_key_);

  971.       uint64 val = sub_message->GetReflection()->GetUInt64(

  972.           *sub_message, map_uint64_uint64_val_);

  973.       EXPECT_EQ(map[key], val);

  974.       // Check with Map Reflection

  975.       map_key.SetUInt64Value(key);

  976.       EXPECT_TRUE(

  977.           reflection->ContainsMapKey(message, F("map_uint64_uint64"), map_key));

  978.     }

  979.   }

  980.   {

  981.     std::map<int32, int32> map;

  982.     map[0] = 0;

  983.     map[1] = 1;

  984.     for (int i = 0; i < 2; i++) {

  985.       sub_message =

  986.           &reflection->GetRepeatedMessage(message, F("map_sint32_sint32"), i);

  987.       int32 key = sub_message->GetReflection()->GetInt32(

  988.           *sub_message, map_sint32_sint32_key_);

  989.       int32 val = sub_message->GetReflection()->GetInt32(

  990.           *sub_message, map_sint32_sint32_val_);

  991.       EXPECT_EQ(map[key], val);

  992.       // Check with Map Reflection

  993.       map_key.SetInt32Value(key);

  994.       EXPECT_EQ(true, reflection->ContainsMapKey(

  995.                           message, F("map_sint32_sint32"), map_key));

  996.     }

  997.   }

  998.   {

  999.     std::map<int64, int64> map;

  1000.     map[0] = 0;

  1001.     map[1] = 1;

  1002.     for (int i = 0; i < 2; i++) {

  1003.       sub_message =

  1004.           &reflection->GetRepeatedMessage(message, F("map_sint64_sint64"), i);

  1005.       int64 key = sub_message->GetReflection()->GetInt64(

  1006.           *sub_message, map_sint64_sint64_key_);

  1007.       int64 val = sub_message->GetReflection()->GetInt64(

  1008.           *sub_message, map_sint64_sint64_val_);

  1009.       EXPECT_EQ(map[key], val);

  1010.       // Check with Map Reflection

  1011.       map_key.SetInt64Value(key);

  1012.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1013.                           message, F("map_sint64_sint64"), map_key));

  1014.     }

  1015.   }

  1016.   {

  1017.     std::map<uint32, uint32> map;

  1018.     map[0] = 0;

  1019.     map[1] = 1;

  1020.     for (int i = 0; i < 2; i++) {

  1021.       sub_message =

  1022.           &reflection->GetRepeatedMessage(message, F("map_fixed32_fixed32"), i);

  1023.       uint32 key = sub_message->GetReflection()->GetUInt32(

  1024.           *sub_message, map_fixed32_fixed32_key_);

  1025.       uint32 val = sub_message->GetReflection()->GetUInt32(

  1026.           *sub_message, map_fixed32_fixed32_val_);

  1027.       EXPECT_EQ(map[key], val);

  1028.       // Check with Map Reflection

  1029.       map_key.SetUInt32Value(key);

  1030.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1031.                           message, F("map_fixed32_fixed32"), map_key));

  1032.     }

  1033.   }

  1034.   {

  1035.     std::map<uint64, uint64> map;

  1036.     map[0] = 0;

  1037.     map[1] = 1;

  1038.     for (int i = 0; i < 2; i++) {

  1039.       sub_message =

  1040.           &reflection->GetRepeatedMessage(message, F("map_fixed64_fixed64"), i);

  1041.       uint64 key = sub_message->GetReflection()->GetUInt64(

  1042.           *sub_message, map_fixed64_fixed64_key_);

  1043.       uint64 val = sub_message->GetReflection()->GetUInt64(

  1044.           *sub_message, map_fixed64_fixed64_val_);

  1045.       EXPECT_EQ(map[key], val);

  1046.       // Check with Map Reflection

  1047.       map_key.SetUInt64Value(key);

  1048.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1049.                           message, F("map_fixed64_fixed64"), map_key));

  1050.     }

  1051.   }

  1052.   {

  1053.     std::map<int32, int32> map;

  1054.     map[0] = 0;

  1055.     map[1] = 1;

  1056.     for (int i = 0; i < 2; i++) {

  1057.       sub_message = &reflection->GetRepeatedMessage(

  1058.           message, F("map_sfixed32_sfixed32"), i);

  1059.       int32 key = sub_message->GetReflection()->GetInt32(

  1060.           *sub_message, map_sfixed32_sfixed32_key_);

  1061.       int32 val = sub_message->GetReflection()->GetInt32(

  1062.           *sub_message, map_sfixed32_sfixed32_val_);

  1063.       EXPECT_EQ(map[key], val);

  1064.       // Check with Map Reflection

  1065.       map_key.SetInt32Value(key);

  1066.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1067.                           message, F("map_sfixed32_sfixed32"), map_key));

  1068.     }

  1069.   }

  1070.   {

  1071.     std::map<int64, int64> map;

  1072.     map[0] = 0;

  1073.     map[1] = 1;

  1074.     for (int i = 0; i < 2; i++) {

  1075.       sub_message = &reflection->GetRepeatedMessage(

  1076.           message, F("map_sfixed64_sfixed64"), i);

  1077.       int64 key = sub_message->GetReflection()->GetInt64(

  1078.           *sub_message, map_sfixed64_sfixed64_key_);

  1079.       int64 val = sub_message->GetReflection()->GetInt64(

  1080.           *sub_message, map_sfixed64_sfixed64_val_);

  1081.       EXPECT_EQ(map[key], val);

  1082.       // Check with Map Reflection

  1083.       map_key.SetInt64Value(key);

  1084.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1085.                           message, F("map_sfixed64_sfixed64"), map_key));

  1086.     }

  1087.   }

  1088.   {

  1089.     std::map<int32, float> map;

  1090.     map[0] = 0.0;

  1091.     map[1] = 1.0;

  1092.     for (int i = 0; i < 2; i++) {

  1093.       sub_message =

  1094.           &reflection->GetRepeatedMessage(message, F("map_int32_float"), i);

  1095.       int32 key = sub_message->GetReflection()->GetInt32(*sub_message,

  1096.                                                          map_int32_float_key_);

  1097.       float val = sub_message->GetReflection()->GetFloat(*sub_message,

  1098.                                                          map_int32_float_val_);

  1099.       EXPECT_EQ(map[key], val);

  1100.       // Check with Map Reflection

  1101.       map_key.SetInt32Value(key);

  1102.       EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_float"),

  1103.                                                  map_key));

  1104.     }

  1105.   }

  1106.   {

  1107.     std::map<int32, double> map;

  1108.     map[0] = 0.0;

  1109.     map[1] = 1.0;

  1110.     for (int i = 0; i < 2; i++) {

  1111.       sub_message =

  1112.           &reflection->GetRepeatedMessage(message, F("map_int32_double"), i);

  1113.       int32 key = sub_message->GetReflection()->GetInt32(*sub_message,

  1114.                                                          map_int32_double_key_);

  1115.       double val = sub_message->GetReflection()->GetDouble(

  1116.           *sub_message, map_int32_double_val_);

  1117.       EXPECT_EQ(map[key], val);

  1118.       // Check with Map Reflection

  1119.       map_key.SetInt32Value(key);

  1120.       EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_double"),

  1121.                                                  map_key));

  1122.     }

  1123.   }

  1124.   {

  1125.     std::map<bool, bool> map;

  1126.     map[false] = false;

  1127.     map[true] = true;

  1128.     for (int i = 0; i < 2; i++) {

  1129.       sub_message =

  1130.           &reflection->GetRepeatedMessage(message, F("map_bool_bool"), i);

  1131.       bool key = sub_message->GetReflection()->GetBool(*sub_message,

  1132.                                                        map_bool_bool_key_);

  1133.       bool val = sub_message->GetReflection()->GetBool(*sub_message,

  1134.                                                        map_bool_bool_val_);

  1135.       EXPECT_EQ(map[key], val);

  1136.       // Check with Map Reflection

  1137.       map_key.SetBoolValue(key);

  1138.       EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_bool_bool"),

  1139.                                                  map_key));

  1140.     }

  1141.   }

  1142.   {

  1143.     std::map<std::string, std::string> map;

  1144.     map["0"] = "0";

  1145.     map["1"] = "1";

  1146.     for (int i = 0; i < 2; i++) {

  1147.       sub_message =

  1148.           &reflection->GetRepeatedMessage(message, F("map_string_string"), i);

  1149.       std::string key = sub_message->GetReflection()->GetString(

  1150.           *sub_message, map_string_string_key_);

  1151.       std::string val = sub_message->GetReflection()->GetString(

  1152.           *sub_message, map_string_string_val_);

  1153.       EXPECT_EQ(map[key], val);

  1154.       // Check with Map Reflection

  1155.       map_key.SetStringValue(key);

  1156.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1157.                           message, F("map_string_string"), map_key));

  1158.     }

  1159.   }

  1160.   {

  1161.     std::map<int32, std::string> map;

  1162.     map[0] = "0";

  1163.     map[1] = "1";

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

  1165.       sub_message =

  1166.           &reflection->GetRepeatedMessage(message, F("map_int32_bytes"), i);

  1167.       int32 key = sub_message->GetReflection()->GetInt32(*sub_message,

  1168.                                                          map_int32_bytes_key_);

  1169.       std::string val = sub_message->GetReflection()->GetString(

  1170.           *sub_message, map_int32_bytes_val_);

  1171.       EXPECT_EQ(map[key], val);

  1172.       // Check with Map Reflection

  1173.       map_key.SetInt32Value(key);

  1174.       EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_bytes"),

  1175.                                                  map_key));

  1176.     }

  1177.   }

  1178.   {

  1179.     std::map<int32, const EnumValueDescriptor*> map;

  1180.     map[0] = map_enum_bar_;

  1181.     map[1] = map_enum_baz_;

  1182.     for (int i = 0; i < 2; i++) {

  1183.       sub_message =

  1184.           &reflection->GetRepeatedMessage(message, F("map_int32_enum"), i);

  1185.       int32 key = sub_message->GetReflection()->GetInt32(*sub_message,

  1186.                                                          map_int32_enum_key_);

  1187.       const EnumValueDescriptor* val = sub_message->GetReflection()->GetEnum(

  1188.           *sub_message, map_int32_enum_val_);

  1189.       EXPECT_EQ(map[key], val);

  1190.       // Check with Map Reflection

  1191.       map_key.SetInt32Value(key);

  1192.       EXPECT_EQ(true, reflection->ContainsMapKey(message, F("map_int32_enum"),

  1193.                                                  map_key));

  1194.     }

  1195.   }

  1196.   {

  1197.     std::map<int32, int32> map;

  1198.     map[0] = 0;

  1199.     map[1] = 1;

  1200.     for (int i = 0; i < 2; i++) {

  1201.       sub_message = &reflection->GetRepeatedMessage(

  1202.           message, F("map_int32_foreign_message"), i);

  1203.       int32 key = sub_message->GetReflection()->GetInt32(

  1204.           *sub_message, map_int32_foreign_message_key_);

  1205.       const Message& foreign_message = sub_message->GetReflection()->GetMessage(

  1206.           *sub_message, map_int32_foreign_message_val_);

  1207.       int32 val = foreign_message.GetReflection()->GetInt32(foreign_message,

  1208.                                                             foreign_c_);

  1209.       EXPECT_EQ(map[key], val);

  1210.       // Check with Map Reflection

  1211.       map_key.SetInt32Value(key);

  1212.       EXPECT_EQ(true, reflection->ContainsMapKey(

  1213.                           message, F("map_int32_foreign_message"), map_key));

  1214.     }

  1215.   }

  1216. }

  1217. 

  1218. inline void MapReflectionTester::ExpectMapFieldsSetViaReflectionIterator(

  1219.     Message* message) {

  1220.   std::string scratch;

  1221.   std::string serialized;

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

  1223. 

  1224.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_int32")));

  1225.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int64_int64")));

  1226.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_uint32_uint32")));

  1227.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_uint64_uint64")));

  1228.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sint32_sint32")));

  1229.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sint64_sint64")));

  1230.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_fixed32_fixed32")));

  1231.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_fixed64_fixed64")));

  1232.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sfixed32_sfixed32")));

  1233.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_sfixed64_sfixed64")));

  1234.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_float")));

  1235.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_double")));

  1236.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_bool_bool")));

  1237.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_string_string")));

  1238.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_bytes")));

  1239.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_enum")));

  1240.   ASSERT_EQ(2, reflection->FieldSize(*message, F("map_int32_foreign_message")));

  1241. 

  1242.   {

  1243.     std::map<int32, int32> map;

  1244.     map[0] = 0;

  1245.     map[1] = 1;

  1246.     int size = 0;

  1247.     for (MapIterator iter = reflection->MapBegin(message, F("map_int32_int32"));

  1248.          iter != reflection->MapEnd(message, F("map_int32_int32"));

  1249.          ++iter, ++size) {

  1250.       // Check const methods do not invalidate map.

  1251.       message->DebugString();

  1252.       message->ShortDebugString();

  1253.       message->SerializeToString(&serialized);

  1254.       message->SpaceUsedLong();

  1255.       message->ByteSizeLong();

  1256.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1257.                 iter.GetValueRef().GetInt32Value());

  1258.     }

  1259.     EXPECT_EQ(size, 2);

  1260.   }

  1261.   {

  1262.     std::map<int64, int64> map;

  1263.     map[0] = 0;

  1264.     map[1] = 1;

  1265.     for (MapIterator iter = reflection->MapBegin(message, F("map_int64_int64"));

  1266.          iter != reflection->MapEnd(message, F("map_int64_int64")); ++iter) {

  1267.       EXPECT_EQ(map[iter.GetKey().GetInt64Value()],

  1268.                 iter.GetValueRef().GetInt64Value());

  1269.     }

  1270.   }

  1271.   {

  1272.     std::map<uint32, uint32> map;

  1273.     map[0] = 0;

  1274.     map[1] = 1;

  1275.     for (MapIterator iter =

  1276.              reflection->MapBegin(message, F("map_uint32_uint32"));

  1277.          iter != reflection->MapEnd(message, F("map_uint32_uint32")); ++iter) {

  1278.       EXPECT_EQ(map[iter.GetKey().GetUInt32Value()],

  1279.                 iter.GetValueRef().GetUInt32Value());

  1280.     }

  1281.   }

  1282.   {

  1283.     std::map<uint64, uint64> map;

  1284.     map[0] = 0;

  1285.     map[1] = 1;

  1286.     for (MapIterator iter =

  1287.              reflection->MapBegin(message, F("map_uint64_uint64"));

  1288.          iter != reflection->MapEnd(message, F("map_uint64_uint64")); ++iter) {

  1289.       EXPECT_EQ(map[iter.GetKey().GetUInt64Value()],

  1290.                 iter.GetValueRef().GetUInt64Value());

  1291.     }

  1292.   }

  1293.   {

  1294.     std::map<int32, int32> map;

  1295.     map[0] = 0;

  1296.     map[1] = 1;

  1297.     for (MapIterator iter =

  1298.              reflection->MapBegin(message, F("map_sint32_sint32"));

  1299.          iter != reflection->MapEnd(message, F("map_sint32_sint32")); ++iter) {

  1300.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1301.                 iter.GetValueRef().GetInt32Value());

  1302.     }

  1303.   }

  1304.   {

  1305.     std::map<int64, int64> map;

  1306.     map[0] = 0;

  1307.     map[1] = 1;

  1308.     for (MapIterator iter =

  1309.              reflection->MapBegin(message, F("map_sint64_sint64"));

  1310.          iter != reflection->MapEnd(message, F("map_sint64_sint64")); ++iter) {

  1311.       EXPECT_EQ(map[iter.GetKey().GetInt64Value()],

  1312.                 iter.GetValueRef().GetInt64Value());

  1313.     }

  1314.   }

  1315.   {

  1316.     std::map<uint32, uint32> map;

  1317.     map[0] = 0;

  1318.     map[1] = 1;

  1319.     for (MapIterator iter =

  1320.              reflection->MapBegin(message, F("map_fixed32_fixed32"));

  1321.          iter != reflection->MapEnd(message, F("map_fixed32_fixed32"));

  1322.          ++iter) {

  1323.       EXPECT_EQ(map[iter.GetKey().GetUInt32Value()],

  1324.                 iter.GetValueRef().GetUInt32Value());

  1325.     }

  1326.   }

  1327.   {

  1328.     std::map<uint64, uint64> map;

  1329.     map[0] = 0;

  1330.     map[1] = 1;

  1331.     for (MapIterator iter =

  1332.              reflection->MapBegin(message, F("map_fixed64_fixed64"));

  1333.          iter != reflection->MapEnd(message, F("map_fixed64_fixed64"));

  1334.          ++iter) {

  1335.       EXPECT_EQ(map[iter.GetKey().GetUInt64Value()],

  1336.                 iter.GetValueRef().GetUInt64Value());

  1337.     }

  1338.   }

  1339.   {

  1340.     std::map<int32, int32> map;

  1341.     map[0] = 0;

  1342.     map[1] = 1;

  1343.     for (MapIterator iter =

  1344.              reflection->MapBegin(message, F("map_sfixed32_sfixed32"));

  1345.          iter != reflection->MapEnd(message, F("map_sfixed32_sfixed32"));

  1346.          ++iter) {

  1347.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1348.                 iter.GetValueRef().GetInt32Value());

  1349.     }

  1350.   }

  1351.   {

  1352.     std::map<int32, float> map;

  1353.     map[0] = 0.0;

  1354.     map[1] = 1.0;

  1355.     for (MapIterator iter = reflection->MapBegin(message, F("map_int32_float"));

  1356.          iter != reflection->MapEnd(message, F("map_int32_float")); ++iter) {

  1357.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1358.                 iter.GetValueRef().GetFloatValue());

  1359.     }

  1360.   }

  1361.   {

  1362.     std::map<int32, double> map;

  1363.     map[0] = 0.0;

  1364.     map[1] = 1.0;

  1365.     for (MapIterator iter =

  1366.              reflection->MapBegin(message, F("map_int32_double"));

  1367.          iter != reflection->MapEnd(message, F("map_int32_double")); ++iter) {

  1368.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1369.                 iter.GetValueRef().GetDoubleValue());

  1370.     }

  1371.   }

  1372.   {

  1373.     std::map<bool, bool> map;

  1374.     map[false] = false;

  1375.     map[true] = true;

  1376.     for (MapIterator iter = reflection->MapBegin(message, F("map_bool_bool"));

  1377.          iter != reflection->MapEnd(message, F("map_bool_bool")); ++iter) {

  1378.       EXPECT_EQ(map[iter.GetKey().GetBoolValue()],

  1379.                 iter.GetValueRef().GetBoolValue());

  1380.     }

  1381.   }

  1382.   {

  1383.     std::map<std::string, std::string> map;

  1384.     map["0"] = "0";

  1385.     map["1"] = "1";

  1386.     int size = 0;

  1387.     for (MapIterator iter =

  1388.              reflection->MapBegin(message, F("map_string_string"));

  1389.          iter != reflection->MapEnd(message, F("map_string_string"));

  1390.          ++iter, ++size) {

  1391.       // Check const methods do not invalidate map.

  1392.       message->DebugString();

  1393.       message->ShortDebugString();

  1394.       message->SerializeToString(&serialized);

  1395.       message->SpaceUsedLong();

  1396.       message->ByteSizeLong();

  1397.       EXPECT_EQ(map[iter.GetKey().GetStringValue()],

  1398.                 iter.GetValueRef().GetStringValue());

  1399.     }

  1400.     EXPECT_EQ(size, 2);

  1401.   }

  1402.   {

  1403.     std::map<int32, std::string> map;

  1404.     map[0] = "0";

  1405.     map[1] = "1";

  1406.     for (MapIterator iter = reflection->MapBegin(message, F("map_int32_bytes"));

  1407.          iter != reflection->MapEnd(message, F("map_int32_bytes")); ++iter) {

  1408.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1409.                 iter.GetValueRef().GetStringValue());

  1410.     }

  1411.   }

  1412.   {

  1413.     std::map<int32, const EnumValueDescriptor*> map;

  1414.     map[0] = map_enum_bar_;

  1415.     map[1] = map_enum_baz_;

  1416.     for (MapIterator iter = reflection->MapBegin(message, F("map_int32_enum"));

  1417.          iter != reflection->MapEnd(message, F("map_int32_enum")); ++iter) {

  1418.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()]->number(),

  1419.                 iter.GetValueRef().GetEnumValue());

  1420.     }

  1421.   }

  1422.   {

  1423.     std::map<int32, int32> map;

  1424.     map[0] = 0;

  1425.     map[1] = 1;

  1426.     int size = 0;

  1427.     for (MapIterator iter =

  1428.              reflection->MapBegin(message, F("map_int32_foreign_message"));

  1429.          iter != reflection->MapEnd(message, F("map_int32_foreign_message"));

  1430.          ++iter, ++size) {

  1431.       // Check const methods do not invalidate map.

  1432.       message->DebugString();

  1433.       message->ShortDebugString();

  1434.       message->SerializeToString(&serialized);

  1435.       message->SpaceUsedLong();

  1436.       message->ByteSizeLong();

  1437.       const Message& sub_message = iter.GetValueRef().GetMessageValue();

  1438.       EXPECT_EQ(map[iter.GetKey().GetInt32Value()],

  1439.                 sub_message.GetReflection()->GetInt32(sub_message, foreign_c_));

  1440.     }

  1441.     EXPECT_EQ(size, 2);

  1442.   }

  1443. }

  1444. 

  1445. inline void MapReflectionTester::ExpectClearViaReflection(

  1446.     const Message& message) {

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

  1448.   // Map fields are empty.

  1449.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_int32")));

  1450.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int64_int64")));

  1451.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint32_uint32")));

  1452.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_uint64_uint64")));

  1453.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint32_sint32")));

  1454.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_sint64_sint64")));

  1455.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed32_fixed32")));

  1456.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_fixed64_fixed64")));

  1457.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed32_sfixed32")));

  1458.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_sfixed64_sfixed64")));

  1459.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_float")));

  1460.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_double")));

  1461.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_bool_bool")));

  1462.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_string_string")));

  1463.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_bytes")));

  1464.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_enum")));

  1465.   EXPECT_EQ(0, reflection->FieldSize(message, F("map_int32_foreign_message")));

  1466.   EXPECT_TRUE(reflection->GetMapData(message, F("map_int32_foreign_message"))

  1467.                   ->IsMapValid());

  1468. }

  1469. 

  1470. inline void MapReflectionTester::ExpectClearViaReflectionIterator(

  1471.     Message* message) {

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

  1473.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_int32")) ==

  1474.               reflection->MapEnd(message, F("map_int32_int32")));

  1475.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int64_int64")) ==

  1476.               reflection->MapEnd(message, F("map_int64_int64")));

  1477.   EXPECT_TRUE(reflection->MapBegin(message, F("map_uint32_uint32")) ==

  1478.               reflection->MapEnd(message, F("map_uint32_uint32")));

  1479.   EXPECT_TRUE(reflection->MapBegin(message, F("map_uint64_uint64")) ==

  1480.               reflection->MapEnd(message, F("map_uint64_uint64")));

  1481.   EXPECT_TRUE(reflection->MapBegin(message, F("map_sint32_sint32")) ==

  1482.               reflection->MapEnd(message, F("map_sint32_sint32")));

  1483.   EXPECT_TRUE(reflection->MapBegin(message, F("map_sint64_sint64")) ==

  1484.               reflection->MapEnd(message, F("map_sint64_sint64")));

  1485.   EXPECT_TRUE(reflection->MapBegin(message, F("map_fixed32_fixed32")) ==

  1486.               reflection->MapEnd(message, F("map_fixed32_fixed32")));

  1487.   EXPECT_TRUE(reflection->MapBegin(message, F("map_fixed64_fixed64")) ==

  1488.               reflection->MapEnd(message, F("map_fixed64_fixed64")));

  1489.   EXPECT_TRUE(reflection->MapBegin(message, F("map_sfixed32_sfixed32")) ==

  1490.               reflection->MapEnd(message, F("map_sfixed32_sfixed32")));

  1491.   EXPECT_TRUE(reflection->MapBegin(message, F("map_sfixed64_sfixed64")) ==

  1492.               reflection->MapEnd(message, F("map_sfixed64_sfixed64")));

  1493.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_float")) ==

  1494.               reflection->MapEnd(message, F("map_int32_float")));

  1495.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_double")) ==

  1496.               reflection->MapEnd(message, F("map_int32_double")));

  1497.   EXPECT_TRUE(reflection->MapBegin(message, F("map_bool_bool")) ==

  1498.               reflection->MapEnd(message, F("map_bool_bool")));

  1499.   EXPECT_TRUE(reflection->MapBegin(message, F("map_string_string")) ==

  1500.               reflection->MapEnd(message, F("map_string_string")));

  1501.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_bytes")) ==

  1502.               reflection->MapEnd(message, F("map_int32_bytes")));

  1503.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_enum")) ==

  1504.               reflection->MapEnd(message, F("map_int32_enum")));

  1505.   EXPECT_TRUE(reflection->MapBegin(message, F("map_int32_foreign_message")) ==

  1506.               reflection->MapEnd(message, F("map_int32_foreign_message")));

  1507. }

  1508. 

  1509. }  // namespace protobuf

  1510. }  // namespace google

  1511. 

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

  1513. 

  1514. #endif  // GOOGLE_PROTOBUF_MAP_TEST_UTIL_H__