ruby_memprofiler_pprof 0.0.1

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/msg_test.cc

@@ -0,0 +1,491 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "google/protobuf/test_messages_proto3.upb.h"
+#include "upb/def.hpp"
+#include "upb/json_decode.h"
+#include "upb/json_encode.h"
+#include "upb/msg_test.upb.h"
+#include "upb/msg_test.upbdefs.h"
+#include "upb/upb.hpp"
+
+void VerifyMessage(const upb_test_TestExtensions* ext_msg) {
+  EXPECT_TRUE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg));
+  // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg));
+  EXPECT_TRUE(upb_test_has_optional_msg_ext(ext_msg));
+
+  EXPECT_EQ(123, upb_test_TestExtensions_optional_int32_ext(ext_msg));
+  const protobuf_test_messages_proto3_TestAllTypesProto3* ext_submsg =
+      upb_test_optional_msg_ext(ext_msg);
+  EXPECT_TRUE(ext_submsg != nullptr);
+  EXPECT_EQ(456,
+            protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32(
+                ext_submsg));
+}
+
+TEST(MessageTest, Extensions) {
+  upb::Arena arena;
+  upb_test_TestExtensions* ext_msg = upb_test_TestExtensions_new(arena.ptr());
+
+  EXPECT_FALSE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg));
+  // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg));
+  EXPECT_FALSE(upb_test_has_optional_msg_ext(ext_msg));
+
+  upb::SymbolTable symtab;
+  upb::MessageDefPtr m(upb_test_TestExtensions_getmsgdef(symtab.ptr()));
+  EXPECT_TRUE(m.ptr() != nullptr);
+
+  std::string json = R"json(
+  {
+      "[upb_test.TestExtensions.optional_int32_ext]": 123,
+      "[upb_test.TestExtensions.Nested.repeated_int32_ext]": [2, 4, 6],
+      "[upb_test.optional_msg_ext]": {"optional_int32": 456}
+  }
+  )json";
+  upb::Status status;
+  EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), ext_msg, m.ptr(),
+                             symtab.ptr(), 0, arena.ptr(), status.ptr()))
+      << status.error_message();
+
+  VerifyMessage(ext_msg);
+
+  // Test round-trip through binary format.
+  size_t size;
+  char* serialized =
+      upb_test_TestExtensions_serialize(ext_msg, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  ASSERT_GE(size, 0);
+
+  upb_test_TestExtensions* ext_msg2 = upb_test_TestExtensions_parse_ex(
+      serialized, size, upb_DefPool_ExtensionRegistry(symtab.ptr()), 0,
+      arena.ptr());
+  VerifyMessage(ext_msg2);
+
+  // Test round-trip through JSON format.
+  size_t json_size =
+      upb_JsonEncode(ext_msg, m.ptr(), symtab.ptr(), 0, NULL, 0, status.ptr());
+  char* json_buf =
+      static_cast<char*>(upb_Arena_Malloc(arena.ptr(), json_size + 1));
+  upb_JsonEncode(ext_msg, m.ptr(), symtab.ptr(), 0, json_buf, json_size + 1,
+                 status.ptr());
+  upb_test_TestExtensions* ext_msg3 = upb_test_TestExtensions_new(arena.ptr());
+  EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, ext_msg3, m.ptr(),
+                             symtab.ptr(), 0, arena.ptr(), status.ptr()))
+      << status.error_message();
+  VerifyMessage(ext_msg3);
+}
+
+void VerifyMessageSet(const upb_test_TestMessageSet* mset_msg) {
+  ASSERT_TRUE(mset_msg != nullptr);
+  bool has = upb_test_MessageSetMember_has_message_set_extension(mset_msg);
+  EXPECT_TRUE(has);
+  if (!has) return;
+  const upb_test_MessageSetMember* member =
+      upb_test_MessageSetMember_message_set_extension(mset_msg);
+  EXPECT_TRUE(member != nullptr);
+  EXPECT_TRUE(upb_test_MessageSetMember_has_optional_int32(member));
+  EXPECT_EQ(234, upb_test_MessageSetMember_optional_int32(member));
+}
+
+TEST(MessageTest, MessageSet) {
+  upb::Arena arena;
+  upb_test_TestMessageSet* ext_msg = upb_test_TestMessageSet_new(arena.ptr());
+
+  EXPECT_FALSE(upb_test_MessageSetMember_has_message_set_extension(ext_msg));
+
+  upb::SymbolTable symtab;
+  upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(symtab.ptr()));
+  EXPECT_TRUE(m.ptr() != nullptr);
+
+  std::string json = R"json(
+  {
+      "[upb_test.MessageSetMember]": {"optional_int32": 234}
+  }
+  )json";
+  upb::Status status;
+  EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), ext_msg, m.ptr(),
+                             symtab.ptr(), 0, arena.ptr(), status.ptr()))
+      << status.error_message();
+
+  VerifyMessageSet(ext_msg);
+
+  // Test round-trip through binary format.
+  size_t size;
+  char* serialized =
+      upb_test_TestMessageSet_serialize(ext_msg, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  ASSERT_GE(size, 0);
+
+  upb_test_TestMessageSet* ext_msg2 = upb_test_TestMessageSet_parse_ex(
+      serialized, size, upb_DefPool_ExtensionRegistry(symtab.ptr()), 0,
+      arena.ptr());
+  VerifyMessageSet(ext_msg2);
+
+  // Test round-trip through JSON format.
+  size_t json_size =
+      upb_JsonEncode(ext_msg, m.ptr(), symtab.ptr(), 0, NULL, 0, status.ptr());
+  char* json_buf =
+      static_cast<char*>(upb_Arena_Malloc(arena.ptr(), json_size + 1));
+  upb_JsonEncode(ext_msg, m.ptr(), symtab.ptr(), 0, json_buf, json_size + 1,
+                 status.ptr());
+  upb_test_TestMessageSet* ext_msg3 = upb_test_TestMessageSet_new(arena.ptr());
+  EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, ext_msg3, m.ptr(),
+                             symtab.ptr(), 0, arena.ptr(), status.ptr()))
+      << status.error_message();
+  VerifyMessageSet(ext_msg3);
+}
+
+TEST(MessageTest, UnknownMessageSet) {
+  static const char data[] = "ABCDE";
+  upb_StringView data_view = upb_StringView_FromString(data);
+  upb::Arena arena;
+  upb_test_FakeMessageSet* fake = upb_test_FakeMessageSet_new(arena.ptr());
+
+  // Add a MessageSet item that is unknown (there is no matching extension in
+  // the .proto file)
+  upb_test_FakeMessageSet_Item* item =
+      upb_test_FakeMessageSet_add_item(fake, arena.ptr());
+  upb_test_FakeMessageSet_Item_set_type_id(item, 12345);
+  upb_test_FakeMessageSet_Item_set_message(item, data_view);
+
+  // Set unknown fields inside the message set to test that we can skip them.
+  upb_test_FakeMessageSet_Item_set_unknown_varint(item, 12345678);
+  upb_test_FakeMessageSet_Item_set_unknown_fixed32(item, 12345678);
+  upb_test_FakeMessageSet_Item_set_unknown_fixed64(item, 12345678);
+  upb_test_FakeMessageSet_Item_set_unknown_bytes(item, data_view);
+  upb_test_FakeMessageSet_Item_mutable_unknowngroup(item, arena.ptr());
+
+  // Round trip through a true MessageSet where this item_id is unknown.
+  size_t size;
+  char* serialized =
+      upb_test_FakeMessageSet_serialize(fake, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  ASSERT_GE(size, 0);
+
+  upb::SymbolTable symtab;
+  upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(symtab.ptr()));
+  EXPECT_TRUE(m.ptr() != nullptr);
+  upb_test_TestMessageSet* message_set = upb_test_TestMessageSet_parse_ex(
+      serialized, size, upb_DefPool_ExtensionRegistry(symtab.ptr()), 0,
+      arena.ptr());
+  ASSERT_TRUE(message_set != nullptr);
+
+  char* serialized2 =
+      upb_test_TestMessageSet_serialize(message_set, arena.ptr(), &size);
+  ASSERT_TRUE(serialized2 != nullptr);
+  ASSERT_GE(size, 0);
+
+  // Parse back into a fake MessageSet and verify that the unknown MessageSet
+  // item was preserved in full (both type_id and message).
+  upb_test_FakeMessageSet* fake2 =
+      upb_test_FakeMessageSet_parse(serialized2, size, arena.ptr());
+  ASSERT_TRUE(fake2 != nullptr);
+
+  const upb_test_FakeMessageSet_Item* const* items =
+      upb_test_FakeMessageSet_item(fake2, &size);
+  ASSERT_EQ(1, size);
+  EXPECT_EQ(12345, upb_test_FakeMessageSet_Item_type_id(items[0]));
+  EXPECT_TRUE(upb_StringView_IsEqual(
+      data_view, upb_test_FakeMessageSet_Item_message(items[0])));
+
+  // The non-MessageSet unknown fields should have been discarded.
+  EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_varint(items[0]));
+  EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed32(items[0]));
+  EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed64(items[0]));
+  EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_bytes(items[0]));
+  EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknowngroup(items[0]));
+}
+
+TEST(MessageTest, Proto2Enum) {
+  upb::Arena arena;
+  upb_test_Proto2FakeEnumMessage* fake_msg =
+      upb_test_Proto2FakeEnumMessage_new(arena.ptr());
+
+  upb_test_Proto2FakeEnumMessage_set_optional_enum(fake_msg, 999);
+
+  int32_t* vals = upb_test_Proto2FakeEnumMessage_resize_repeated_enum(
+      fake_msg, 6, arena.ptr());
+  vals[0] = upb_test_Proto2EnumMessage_ZERO;
+  vals[1] = 7;  // Unknown small.
+  vals[2] = upb_test_Proto2EnumMessage_SMALL;
+  vals[3] = 888;  // Unknown large.
+  vals[4] = upb_test_Proto2EnumMessage_LARGE;
+  vals[5] = upb_test_Proto2EnumMessage_NEGATIVE;
+
+  vals = upb_test_Proto2FakeEnumMessage_resize_packed_enum(fake_msg, 6,
+                                                           arena.ptr());
+  vals[0] = upb_test_Proto2EnumMessage_ZERO;
+  vals[1] = 7;  // Unknown small.
+  vals[2] = upb_test_Proto2EnumMessage_SMALL;
+  vals[3] = 888;  // Unknown large.
+  vals[4] = upb_test_Proto2EnumMessage_LARGE;
+  vals[5] = upb_test_Proto2EnumMessage_NEGATIVE;
+
+  size_t size;
+  char* pb =
+      upb_test_Proto2FakeEnumMessage_serialize(fake_msg, arena.ptr(), &size);
+
+  // Parsing as enums puts unknown values into unknown fields.
+  upb_test_Proto2EnumMessage* enum_msg =
+      upb_test_Proto2EnumMessage_parse(pb, size, arena.ptr());
+  ASSERT_TRUE(enum_msg != nullptr);
+
+  EXPECT_EQ(false, upb_test_Proto2EnumMessage_has_optional_enum(enum_msg));
+  const int32_t* vals_const =
+      upb_test_Proto2EnumMessage_repeated_enum(enum_msg, &size);
+  EXPECT_EQ(4, size);  // Two unknown values moved to the unknown field set.
+
+  // Parsing back into the fake message shows the original data, except the
+  // repeated enum is rearranged.
+  pb = upb_test_Proto2EnumMessage_serialize(enum_msg, arena.ptr(), &size);
+  upb_test_Proto2FakeEnumMessage* fake_msg2 =
+      upb_test_Proto2FakeEnumMessage_parse(pb, size, arena.ptr());
+
+  EXPECT_EQ(true, upb_test_Proto2FakeEnumMessage_has_optional_enum(fake_msg2));
+  EXPECT_EQ(999, upb_test_Proto2FakeEnumMessage_optional_enum(fake_msg2));
+
+  int32_t expected[] = {
+      upb_test_Proto2EnumMessage_ZERO,
+      upb_test_Proto2EnumMessage_SMALL,
+      upb_test_Proto2EnumMessage_LARGE,
+      upb_test_Proto2EnumMessage_NEGATIVE,
+      7,
+      888,
+  };
+
+  vals_const = upb_test_Proto2FakeEnumMessage_repeated_enum(fake_msg2, &size);
+  EXPECT_EQ(6, size);
+  EXPECT_THAT(std::vector<int32_t>(vals_const, vals_const + size),
+              ::testing::ElementsAreArray(expected));
+
+  vals_const = upb_test_Proto2FakeEnumMessage_packed_enum(fake_msg2, &size);
+  EXPECT_EQ(6, size);
+  EXPECT_THAT(std::vector<int32_t>(vals_const, vals_const + size),
+              ::testing::ElementsAreArray(expected));
+}
+
+TEST(MessageTest, TestBadUTF8) {
+  upb::Arena arena;
+  std::string serialized("r\x03\xed\xa0\x81");
+  EXPECT_EQ(nullptr, protobuf_test_messages_proto3_TestAllTypesProto3_parse(
+                         serialized.data(), serialized.size(), arena.ptr()));
+}
+
+TEST(MessageTest, DecodeRequiredFieldsTopLevelMessage) {
+  upb::Arena arena;
+  upb_test_TestRequiredFields* test_msg;
+  upb_test_EmptyMessage* empty_msg;
+
+  // Succeeds, because we did not request required field checks.
+  test_msg = upb_test_TestRequiredFields_parse(NULL, 0, arena.ptr());
+  EXPECT_NE(nullptr, test_msg);
+
+  // Fails, because required fields are missing.
+  EXPECT_EQ(kUpb_DecodeStatus_MissingRequired,
+            upb_Decode(NULL, 0, test_msg, &upb_test_TestRequiredFields_msginit,
+                       NULL, kUpb_DecodeOption_CheckRequired, arena.ptr()));
+
+  upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
+  size_t size;
+  char* serialized =
+      upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  EXPECT_NE(0, size);
+
+  // Fails, but the code path is slightly different because the serialized
+  // payload is not empty.
+  EXPECT_EQ(kUpb_DecodeStatus_MissingRequired,
+            upb_Decode(serialized, size, test_msg,
+                       &upb_test_TestRequiredFields_msginit, NULL,
+                       kUpb_DecodeOption_CheckRequired, arena.ptr()));
+
+  empty_msg = upb_test_EmptyMessage_new(arena.ptr());
+  upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
+  upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
+  upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
+
+  // Succeeds, because required fields are present (though not in the input).
+  EXPECT_EQ(kUpb_DecodeStatus_Ok,
+            upb_Decode(NULL, 0, test_msg, &upb_test_TestRequiredFields_msginit,
+                       NULL, kUpb_DecodeOption_CheckRequired, arena.ptr()));
+
+  // Serialize a complete payload.
+  serialized =
+      upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  EXPECT_NE(0, size);
+
+  upb_test_TestRequiredFields* test_msg2 = upb_test_TestRequiredFields_parse_ex(
+      serialized, size, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr());
+  EXPECT_NE(nullptr, test_msg2);
+
+  // When we add an incomplete sub-message, this is not flagged by the parser.
+  // This makes parser checking unsuitable for MergeFrom().
+  upb_test_TestRequiredFields_set_optional_message(
+      test_msg2, upb_test_TestRequiredFields_new(arena.ptr()));
+  EXPECT_EQ(kUpb_DecodeStatus_Ok,
+            upb_Decode(serialized, size, test_msg2,
+                       &upb_test_TestRequiredFields_msginit, NULL,
+                       kUpb_DecodeOption_CheckRequired, arena.ptr()));
+}
+
+TEST(MessageTest, DecodeRequiredFieldsSubMessage) {
+  upb::Arena arena;
+  upb_test_TestRequiredFields* test_msg =
+      upb_test_TestRequiredFields_new(arena.ptr());
+  upb_test_SubMessageHasRequired* sub_msg =
+      upb_test_SubMessageHasRequired_new(arena.ptr());
+  upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr());
+
+  upb_test_SubMessageHasRequired_set_optional_message(sub_msg, test_msg);
+  size_t size;
+  char* serialized =
+      upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size);
+  EXPECT_NE(0, size);
+
+  // No parse error when parsing normally.
+  EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse(serialized, size,
+                                                          arena.ptr()));
+
+  // Parse error when verifying required fields, due to incomplete sub-message.
+  EXPECT_EQ(nullptr, upb_test_SubMessageHasRequired_parse_ex(
+                         serialized, size, NULL,
+                         kUpb_DecodeOption_CheckRequired, arena.ptr()));
+
+  upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
+  upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
+  upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
+
+  serialized =
+      upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size);
+  EXPECT_NE(0, size);
+
+  // No parse error; sub-message now is complete.
+  EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse_ex(
+                         serialized, size, NULL,
+                         kUpb_DecodeOption_CheckRequired, arena.ptr()));
+}
+
+TEST(MessageTest, EncodeRequiredFields) {
+  upb::Arena arena;
+  upb_test_TestRequiredFields* test_msg =
+      upb_test_TestRequiredFields_new(arena.ptr());
+
+  // Succeeds, we didn't ask for required field checking.
+  size_t size;
+  char* serialized =
+      upb_test_TestRequiredFields_serialize_ex(test_msg, 0, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+  EXPECT_EQ(size, 0);
+
+  // Fails, we asked for required field checking but the required field is
+  // missing.
+  serialized = upb_test_TestRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized == nullptr);
+
+  // Fails, some required fields are present but not others.
+  upb_test_TestRequiredFields_set_required_int32(test_msg, 1);
+  serialized = upb_test_TestRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized == nullptr);
+
+  // Succeeds, all required fields are set.
+  upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr());
+  upb_test_TestRequiredFields_set_required_int64(test_msg, 2);
+  upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg);
+  serialized = upb_test_TestRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+}
+
+TEST(MessageTest, MaxRequiredFields) {
+  upb::Arena arena;
+  upb_test_TestMaxRequiredFields* test_msg =
+      upb_test_TestMaxRequiredFields_new(arena.ptr());
+
+  // Fails, we asked for required field checking but the required field is
+  // missing.
+  size_t size;
+  char* serialized = upb_test_TestMaxRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized == nullptr);
+
+  upb::SymbolTable symtab;
+  upb::MessageDefPtr m(upb_test_TestMaxRequiredFields_getmsgdef(symtab.ptr()));
+  upb_MessageValue val;
+  val.int32_val = 1;
+  for (int i = 1; i <= 61; i++) {
+    upb::FieldDefPtr f = m.FindFieldByNumber(i);
+    ASSERT_TRUE(f);
+    upb_Message_Set(test_msg, f.ptr(), val, arena.ptr());
+  }
+
+  // Fails, field 63 still isn't set.
+  serialized = upb_test_TestMaxRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized == nullptr);
+
+  // Succeeds, all required fields are set.
+  upb::FieldDefPtr f = m.FindFieldByNumber(62);
+  ASSERT_TRUE(f);
+  upb_Message_Set(test_msg, f.ptr(), val, arena.ptr());
+  serialized = upb_test_TestMaxRequiredFields_serialize_ex(
+      test_msg, kUpb_Encode_CheckRequired, arena.ptr(), &size);
+  ASSERT_TRUE(serialized != nullptr);
+}
+
+TEST(MessageTest, MapField) {
+  upb::Arena arena;
+  upb_test_TestMapFieldExtra* test_msg_extra =
+      upb_test_TestMapFieldExtra_new(arena.ptr());
+
+  ASSERT_TRUE(upb_test_TestMapFieldExtra_map_field_set(
+      test_msg_extra, 0, upb_test_TestMapFieldExtra_THREE, arena.ptr()));
+
+  size_t size;
+  char* serialized = upb_test_TestMapFieldExtra_serialize_ex(
+      test_msg_extra, 0, arena.ptr(), &size);
+  ASSERT_NE(nullptr, serialized);
+  ASSERT_NE(0, size);
+
+  upb_test_TestMapField* test_msg =
+      upb_test_TestMapField_parse(serialized, size, arena.ptr());
+  ASSERT_NE(nullptr, test_msg);
+
+  ASSERT_FALSE(upb_test_TestMapField_map_field_get(test_msg, 0, nullptr));
+  serialized =
+      upb_test_TestMapField_serialize_ex(test_msg, 0, arena.ptr(), &size);
+  ASSERT_NE(0, size);
+  // parse into second instance
+  upb_test_TestMapFieldExtra* test_msg_extra2 =
+      upb_test_TestMapFieldExtra_parse(serialized, size, arena.ptr());
+  ASSERT_TRUE(
+      upb_test_TestMapFieldExtra_map_field_get(test_msg_extra2, 0, nullptr));
+}

data/ext/ruby_memprofiler_pprof/vendor/upb/upb/msg_test.proto

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// LINT: ALLOW_GROUPS
+
+syntax = "proto2";
+
+package upb_test;
+
+import "google/protobuf/test_messages_proto3.proto";
+
+message TestExtensions {
+  extensions 1000 to max;
+  extend TestExtensions {
+    optional int32 optional_int32_ext = 1000;
+  }
+  message Nested {
+    extend TestExtensions {
+      repeated int32 repeated_int32_ext = 1001;
+    }
+  }
+}
+
+extend TestExtensions {
+  optional protobuf_test_messages.proto3.TestAllTypesProto3 optional_msg_ext =
+      1002;
+}
+
+message TestMessageSet {
+  option message_set_wire_format = true;
+
+  extensions 4 to max;
+}
+
+message MessageSetMember {
+  optional int32 optional_int32 = 1;
+  extend TestMessageSet {
+    optional MessageSetMember message_set_extension = 4;
+  }
+}
+
+message FakeMessageSet {
+  repeated group Item = 1 {
+    optional int32 type_id = 2;
+    optional bytes message = 3;
+    optional int32 unknown_varint = 4;
+    optional fixed32 unknown_fixed32 = 5;
+    optional fixed64 unknown_fixed64 = 6;
+    optional bytes unknown_bytes = 7;
+    optional group UnknownGroup = 8 {}
+  }
+}
+
+message Proto2EnumMessage {
+  enum Proto2TestEnum {
+    ZERO = 0;
+    NEGATIVE = -1;
+    SMALL = 15;
+    LARGE = 12345;
+  }
+
+  optional Proto2TestEnum optional_enum = 1;
+  repeated Proto2TestEnum repeated_enum = 2;
+  repeated Proto2TestEnum packed_enum = 3 [packed = true];
+}
+
+// The same fields as Proto2EnumMessage, but with int32 fields so we can fake
+// wire format.
+message Proto2FakeEnumMessage {
+  optional int32 optional_enum = 1;
+  repeated int32 repeated_enum = 2;
+  repeated int32 packed_enum = 3 [packed = true];
+}
+
+message EmptyMessage {}
+
+message TestRequiredFields {
+  required int32 required_int32 = 1;
+  optional int32 optional_int32 = 2;
+  required int64 required_int64 = 3;
+  optional TestRequiredFields optional_message = 4;
+  required EmptyMessage required_message = 5;
+}
+
+message SubMessageHasRequired {
+  optional TestRequiredFields optional_message = 1;
+}
+
+message TestMaxRequiredFields {
+  required int32 required_int32_1 = 1;
+  required int32 required_int32_2 = 2;
+  required int32 required_int32_3 = 3;
+  required int32 required_int32_4 = 4;
+  required int32 required_int32_5 = 5;
+  required int32 required_int32_6 = 6;
+  required int32 required_int32_7 = 7;
+  required int32 required_int32_8 = 8;
+  required int32 required_int32_9 = 9;
+  required int32 required_int32_10 = 10;
+  required int32 required_int32_11 = 11;
+  required int32 required_int32_12 = 12;
+  required int32 required_int32_13 = 13;
+  required int32 required_int32_14 = 14;
+  required int32 required_int32_15 = 15;
+  required int32 required_int32_16 = 16;
+  required int32 required_int32_17 = 17;
+  required int32 required_int32_18 = 18;
+  required int32 required_int32_19 = 19;
+  required int32 required_int32_20 = 20;
+  required int32 required_int32_21 = 21;
+  required int32 required_int32_22 = 22;
+  required int32 required_int32_23 = 23;
+  required int32 required_int32_24 = 24;
+  required int32 required_int32_25 = 25;
+  required int32 required_int32_26 = 26;
+  required int32 required_int32_27 = 27;
+  required int32 required_int32_28 = 28;
+  required int32 required_int32_29 = 29;
+  required int32 required_int32_30 = 30;
+  required int32 required_int32_31 = 31;
+  required int32 required_int32_32 = 32;
+  required int32 required_int32_33 = 33;
+  required int32 required_int32_34 = 34;
+  required int32 required_int32_35 = 35;
+  required int32 required_int32_36 = 36;
+  required int32 required_int32_37 = 37;
+  required int32 required_int32_38 = 38;
+  required int32 required_int32_39 = 39;
+  required int32 required_int32_40 = 40;
+  required int32 required_int32_41 = 41;
+  required int32 required_int32_42 = 42;
+  required int32 required_int32_43 = 43;
+  required int32 required_int32_44 = 44;
+  required int32 required_int32_45 = 45;
+  required int32 required_int32_46 = 46;
+  required int32 required_int32_47 = 47;
+  required int32 required_int32_48 = 48;
+  required int32 required_int32_49 = 49;
+  required int32 required_int32_50 = 50;
+  required int32 required_int32_51 = 51;
+  required int32 required_int32_52 = 52;
+  required int32 required_int32_53 = 53;
+  required int32 required_int32_54 = 54;
+  required int32 required_int32_55 = 55;
+  required int32 required_int32_56 = 56;
+  required int32 required_int32_57 = 57;
+  required int32 required_int32_58 = 58;
+  required int32 required_int32_59 = 59;
+  required int32 required_int32_60 = 60;
+  required int32 required_int32_61 = 61;
+  required int32 required_int32_62 = 62;
+}
+
+message TestMapField {
+  enum EnumMap {
+    ZERO = 0;
+    ONE = 1;
+    TWO = 2;
+  }
+  map<int32, EnumMap> map_field = 1;
+}
+
+message TestMapFieldExtra {
+  enum EnumMap {
+    ZERO = 0;
+    ONE = 1;
+    TWO = 2;
+    THREE = 3;
+  }
+  map<int32, EnumMap> map_field = 1;
+}