ruby_memprofiler_pprof 0.0.1

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

@@ -0,0 +1,425 @@
+/*
+ * 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.
+ */
+
+/* Test of mini table accessors.
+ *
+ * Messages are created and mutated using generated code, and then
+ * accessed through reflective APIs exposed through mini table accessors.
+ */
+
+#include "upb/mini_table_accessors.h"
+
+#include "gtest/gtest.h"
+#include "google/protobuf/test_messages_proto2.upb.h"
+#include "google/protobuf/test_messages_proto3.upb.h"
+#include "upb/collections.h"
+#include "upb/mini_table.h"
+#include "upb/test.upb.h"
+
+namespace {
+
+// Proto2 test messages field numbers used for reflective access.
+const uint32_t kFieldOptionalInt32 = 1;
+const uint32_t kFieldOptionalUInt32 = 3;
+const uint32_t kFieldOptionalBool = 13;
+const uint32_t kFieldOptionalString = 14;
+const uint32_t kFieldOptionalNestedMessage = 18;
+const uint32_t kFieldOptionalRepeatedInt32 = 31;
+const uint32_t kFieldOptionalNestedMessageA = 1;
+const uint32_t kFieldOptionalOneOfUInt32 = 111;
+const uint32_t kFieldOptionalOneOfString = 113;
+
+const uint32_t kFieldProto3OptionalInt64 = 2;
+const uint32_t kFieldProto3OptionalUInt64 = 4;
+
+const char kTestStr1[] = "Hello1";
+const char kTestStr2[] = "Hello2";
+const int32_t kTestInt32 = 567;
+const int32_t kTestUInt32 = 0xF1234567;
+const uint64_t kTestUInt64 = 0xFEDCBAFF87654321;
+
+const upb_MiniTable_Field* find_proto3_field(int field_number) {
+  return upb_MiniTable_FindFieldByNumber(
+      &protobuf_test_messages_proto3_TestAllTypesProto3_msginit, field_number);
+}
+
+const upb_MiniTable_Field* find_proto2_field(int field_number) {
+  return upb_MiniTable_FindFieldByNumber(
+      &protobuf_test_messages_proto2_TestAllTypesProto2_msginit, field_number);
+}
+
+TEST(GeneratedCode, HazzersProto2) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto2_TestAllTypesProto2* msg =
+      protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
+
+  // Scalar/Boolean.
+  const upb_MiniTable_Field* optional_bool_field =
+      find_proto2_field(kFieldOptionalBool);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_bool_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_bool(msg, true);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_bool_field));
+  upb_MiniTable_ClearField(msg, optional_bool_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_bool_field));
+  EXPECT_EQ(
+      false,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg));
+
+  // String.
+  const upb_MiniTable_Field* optional_string_field =
+      find_proto2_field(kFieldOptionalString);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_string_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_string(
+      msg, upb_StringView_FromString(kTestStr1));
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_string_field));
+  EXPECT_EQ(
+      strlen(kTestStr1),
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg)
+          .size);
+  upb_MiniTable_ClearField(msg, optional_string_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_string_field));
+  EXPECT_EQ(
+      0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg)
+             .size);
+
+  // Message.
+  const upb_MiniTable_Field* optional_message_field =
+      find_proto2_field(kFieldOptionalNestedMessage);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_message_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_mutable_optional_nested_message(
+      msg, arena);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_message_field));
+  upb_MiniTable_ClearField(msg, optional_message_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_message_field));
+  EXPECT_EQ(
+      true,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_nested_message(
+          msg) == nullptr);
+
+  // One of.
+  const upb_MiniTable_Field* optional_oneof_uint32_field =
+      find_proto2_field(kFieldOptionalOneOfUInt32);
+  const upb_MiniTable_Field* optional_oneof_string_field =
+      find_proto2_field(kFieldOptionalOneOfString);
+
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_uint32_field));
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_string_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_set_oneof_uint32(msg, 123);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_oneof_uint32_field));
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_string_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_set_oneof_string(
+      msg, upb_StringView_FromString(kTestStr1));
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_uint32_field));
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_oneof_string_field));
+  upb_MiniTable_ClearField(msg, optional_oneof_uint32_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_uint32_field));
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_oneof_string_field));
+  upb_MiniTable_ClearField(msg, optional_oneof_string_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_uint32_field));
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_oneof_string_field));
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, ScalarsProto2) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto2_TestAllTypesProto2* msg =
+      protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
+
+  const upb_MiniTable_Field* optional_int32_field =
+      find_proto2_field(kFieldOptionalInt32);
+
+  EXPECT_EQ(
+      0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(msg));
+
+  EXPECT_EQ(0, upb_MiniTable_GetInt32(msg, optional_int32_field));
+  upb_MiniTable_SetInt32(msg, optional_int32_field, kTestInt32);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_int32_field));
+  EXPECT_EQ(kTestInt32, upb_MiniTable_GetInt32(msg, optional_int32_field));
+  EXPECT_EQ(
+      kTestInt32,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(msg));
+
+  const upb_MiniTable_Field* optional_uint32_field =
+      find_proto2_field(kFieldOptionalUInt32);
+
+  EXPECT_EQ(
+      0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg));
+  EXPECT_EQ(0, upb_MiniTable_GetUInt32(msg, optional_uint32_field));
+  upb_MiniTable_SetUInt32(msg, optional_uint32_field, kTestUInt32);
+  EXPECT_EQ(kTestUInt32, upb_MiniTable_GetUInt32(msg, optional_uint32_field));
+  EXPECT_EQ(
+      kTestUInt32,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg));
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, ScalarProto3) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto3_TestAllTypesProto3* msg =
+      protobuf_test_messages_proto3_TestAllTypesProto3_new(arena);
+
+  const upb_MiniTable_Field* optional_int64_field =
+      find_proto3_field(kFieldProto3OptionalInt64);
+  const upb_MiniTable_Field* optional_uint64_field =
+      find_proto3_field(kFieldProto3OptionalUInt64);
+
+  EXPECT_EQ(
+      0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64(msg));
+  upb_MiniTable_SetInt64(msg, optional_int64_field, -1);
+  EXPECT_EQ(
+      -1, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64(msg));
+  EXPECT_EQ(-1, upb_MiniTable_GetInt64(msg, optional_int64_field));
+
+  EXPECT_EQ(
+      0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg));
+  upb_MiniTable_SetUInt64(msg, optional_uint64_field, kTestUInt64);
+  EXPECT_EQ(
+      kTestUInt64,
+      protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg));
+  EXPECT_EQ(kTestUInt64, upb_MiniTable_GetUInt64(msg, optional_uint64_field));
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, Strings) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto2_TestAllTypesProto2* msg =
+      protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
+
+  const upb_MiniTable_Field* optional_string_field =
+      find_proto2_field(kFieldOptionalString);
+
+  // Test default.
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_string_field));
+  // Test read after write using C.
+  protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_string(
+      msg, upb_StringView_FromString(kTestStr1));
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_string_field));
+  upb_StringView value = upb_MiniTable_GetString(msg, optional_string_field);
+  std::string read_value = std::string(value.data, value.size);
+  EXPECT_EQ(kTestStr1, read_value);
+  // Clear.
+  upb_MiniTable_ClearField(msg, optional_string_field);
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_string_field));
+  EXPECT_EQ(
+      false,
+      protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string(
+          msg));
+  upb_MiniTable_SetString(msg, optional_string_field,
+                          upb_StringView_FromString(kTestStr2));
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_string_field));
+  EXPECT_EQ(
+      true,
+      protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string(
+          msg));
+  value = protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg);
+  read_value = std::string(value.data, value.size);
+  EXPECT_EQ(kTestStr2, read_value);
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, SubMessage) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto2_TestAllTypesProto2* msg =
+      protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
+
+  const upb_MiniTable_Field* optional_message_field =
+      find_proto2_field(kFieldOptionalNestedMessage);
+
+  const upb_Message* test_message =
+      upb_MiniTable_GetMessage(msg, optional_message_field);
+  EXPECT_EQ(NULL, test_message);
+
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_message_field));
+
+  // Get mutable using C API.
+  protobuf_test_messages_proto2_TestAllTypesProto2_NestedMessage* nested_message =
+      protobuf_test_messages_proto2_TestAllTypesProto2_mutable_optional_nested_message(
+          msg, arena);
+  EXPECT_EQ(true, nested_message != nullptr);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_message_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_NestedMessage_set_a(
+      nested_message, 5);
+
+  // Read back using mini table API.
+  const upb_Message* sub_message =
+      upb_MiniTable_GetMessage(msg, optional_message_field);
+  EXPECT_EQ(true, sub_message != NULL);
+
+  const upb_MiniTable_Field* nested_message_a_field =
+      upb_MiniTable_FindFieldByNumber(
+          &protobuf_test_messages_proto2_TestAllTypesProto2_NestedMessage_msginit,
+          kFieldOptionalNestedMessageA);
+  EXPECT_EQ(5, upb_MiniTable_GetInt32(sub_message, nested_message_a_field));
+
+  upb_MiniTable_ClearField(msg, optional_message_field);
+  EXPECT_EQ(
+      NULL,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_nested_message(
+          msg));
+  EXPECT_EQ(false, upb_MiniTable_HasField(msg, optional_message_field));
+
+  upb_Message* new_nested_message =
+      protobuf_test_messages_proto2_TestAllTypesProto2_NestedMessage_new(arena);
+  upb_MiniTable_SetInt32(new_nested_message, nested_message_a_field, 123);
+  upb_MiniTable_SetMessage(msg, optional_message_field, new_nested_message);
+
+  upb_Message* mutable_message = upb_MiniTable_GetMutableMessage(
+      msg, &protobuf_test_messages_proto2_TestAllTypesProto2_msginit,
+      optional_message_field, arena);
+  EXPECT_EQ(
+      true,
+      protobuf_test_messages_proto2_TestAllTypesProto2_optional_nested_message(
+          msg) != NULL);
+  EXPECT_EQ(true, upb_MiniTable_HasField(msg, optional_message_field));
+  EXPECT_EQ(123,
+            upb_MiniTable_GetInt32(mutable_message, nested_message_a_field));
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, RepeatedScalar) {
+  upb_Arena* arena = upb_Arena_New();
+  protobuf_test_messages_proto2_TestAllTypesProto2* msg =
+      protobuf_test_messages_proto2_TestAllTypesProto2_new(arena);
+
+  const upb_MiniTable_Field* repeated_int32_field =
+      find_proto2_field(kFieldOptionalRepeatedInt32);
+
+  size_t len;
+  const int32_t* arr =
+      protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg,
+                                                                      &len);
+  // Test Get/Set Array values, validate with C API.
+  EXPECT_EQ(0, len);
+  EXPECT_EQ(NULL, arr);
+  EXPECT_EQ(NULL, upb_MiniTable_GetArray(msg, repeated_int32_field));
+  protobuf_test_messages_proto2_TestAllTypesProto2_resize_repeated_int32(
+      msg, 10, arena);
+  int32_t* mutable_values =
+      protobuf_test_messages_proto2_TestAllTypesProto2_mutable_repeated_int32(
+          msg, &len);
+  mutable_values[5] = 123;
+  const upb_Array* readonly_arr =
+      upb_MiniTable_GetArray(msg, repeated_int32_field);
+  EXPECT_EQ(123, upb_Array_Get(readonly_arr, 5).int32_val);
+
+  upb_MessageValue new_value;
+  new_value.int32_val = 567;
+  upb_Array* mutable_array =
+      upb_MiniTable_GetMutableArray(msg, repeated_int32_field);
+  upb_Array_Set(mutable_array, 5, new_value);
+  EXPECT_EQ(new_value.int32_val,
+            protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(
+                msg, &len)[5]);
+
+  // Test resize.
+  bool result = upb_Array_Resize(mutable_array, 20, arena);
+  EXPECT_EQ(true, result);
+  upb_Array_Set(mutable_array, 19, new_value);
+  EXPECT_EQ(new_value.int32_val,
+            protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(
+                msg, &len)[19]);
+  upb_Array_Resize(mutable_array, 0, arena);
+  const int32_t* zero_length_array =
+      protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg,
+                                                                      &len);
+  EXPECT_EQ(0, len);
+  EXPECT_EQ(true, zero_length_array != NULL);
+
+  upb_Arena_Free(arena);
+}
+
+TEST(GeneratedCode, Extensions) {
+  upb_Arena* arena = upb_Arena_New();
+  upb_test_ModelWithExtensions* msg = upb_test_ModelWithExtensions_new(arena);
+  upb_test_ModelWithExtensions_set_random_int32(msg, 10);
+  upb_test_ModelWithExtensions_set_random_name(
+      msg, upb_StringView_FromString("Hello"));
+
+  upb_test_ModelExtension1* extension1 = upb_test_ModelExtension1_new(arena);
+  upb_test_ModelExtension1_set_str(extension1,
+                                   upb_StringView_FromString("World"));
+
+  upb_test_ModelExtension2* extension2 = upb_test_ModelExtension2_new(arena);
+  upb_test_ModelExtension2_set_i(extension2, 5);
+
+  upb_test_ModelExtension1_set_model_ext(msg, extension1, arena);
+  upb_test_ModelExtension2_set_model_ext(msg, extension2, arena);
+
+  size_t serialized_size;
+  char* serialized =
+      upb_test_ModelWithExtensions_serialize(msg, arena, &serialized_size);
+
+  // Test known GetExtension
+  const upb_Message_Extension* upb_ext2;
+  upb_GetExtension_Status promote_status = upb_MiniTable_GetOrPromoteExtension(
+      msg, &upb_test_ModelExtension2_model_ext_ext, 0, arena, &upb_ext2);
+
+  upb_test_ModelExtension2* ext2 =
+      (upb_test_ModelExtension2*)upb_ext2->data.ptr;
+  EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
+  EXPECT_EQ(5, upb_test_ModelExtension2_i(ext2));
+
+  upb_test_EmptyMessageWithExtensions* base_msg =
+      upb_test_EmptyMessageWithExtensions_parse(serialized, serialized_size,
+                                                arena);
+
+  // Get unknown extension bytes before promotion.
+  const char* extension_data;
+  size_t len;
+  upb_GetExtensionAsBytes_Status status = status =
+      upb_MiniTable_GetExtensionAsBytes(base_msg,
+                                        &upb_test_ModelExtension2_model_ext_ext,
+                                        0, arena, &extension_data, &len);
+  EXPECT_EQ(kUpb_GetExtensionAsBytes_Ok, status);
+  EXPECT_EQ(0x48, extension_data[0]);
+  EXPECT_EQ(5, extension_data[1]);
+
+  // Test unknown GetExtension.
+  promote_status = upb_MiniTable_GetOrPromoteExtension(
+      base_msg, &upb_test_ModelExtension2_model_ext_ext, 0, arena, &upb_ext2);
+
+  ext2 = (upb_test_ModelExtension2*)upb_ext2->data.ptr;
+  EXPECT_EQ(kUpb_GetExtension_Ok, promote_status);
+  EXPECT_EQ(5, upb_test_ModelExtension2_i(ext2));
+
+  // Get unknown extension bytes after promotion.
+  status = upb_MiniTable_GetExtensionAsBytes(
+      base_msg, &upb_test_ModelExtension2_model_ext_ext, 0, arena,
+      &extension_data, &len);
+  EXPECT_EQ(kUpb_GetExtensionAsBytes_Ok, status);
+  EXPECT_EQ(0x48, extension_data[0]);
+  EXPECT_EQ(5, extension_data[1]);
+
+  upb_Arena_Free(arena);
+}
+
+}  // namespace

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

@@ -0,0 +1,230 @@
+/*
+ * 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 "upb/mini_table.hpp"
+
+#include "absl/container/flat_hash_set.h"
+#include "gmock/gmock.h"
+#include "google/protobuf/descriptor.h"
+#include "gtest/gtest.h"
+#include "upb/msg_internal.h"
+#include "upb/upb.hpp"
+
+namespace protobuf = ::google::protobuf;
+
+class MiniTableTest : public testing::TestWithParam<upb_MiniTablePlatform> {};
+
+TEST_P(MiniTableTest, Empty) {
+  upb::Arena arena;
+  upb::Status status;
+  upb_MiniTable* table =
+      upb_MiniTable_Build(NULL, 0, GetParam(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table);
+  EXPECT_EQ(0, table->field_count);
+  EXPECT_EQ(0, table->required_count);
+}
+
+TEST_P(MiniTableTest, AllScalarTypes) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+  ASSERT_TRUE(e.StartMessage(0));
+  int count = 0;
+  for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
+    ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i, 0));
+    count++;
+  }
+  upb::Status status;
+  upb_MiniTable* table = upb_MiniTable_Build(
+      e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table);
+  EXPECT_EQ(count, table->field_count);
+  absl::flat_hash_set<size_t> offsets;
+  for (int i = 0; i < 16; i++) {
+    const upb_MiniTable_Field* f = &table->fields[i];
+    EXPECT_EQ(i + 1, f->number);
+    EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
+    EXPECT_TRUE(offsets.insert(f->offset).second);
+    EXPECT_TRUE(f->offset < table->size);
+  }
+  EXPECT_EQ(0, table->required_count);
+}
+
+TEST_P(MiniTableTest, AllRepeatedTypes) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+  ASSERT_TRUE(e.StartMessage(0));
+  int count = 0;
+  for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
+    ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i,
+                           kUpb_FieldModifier_IsRepeated));
+    count++;
+  }
+  upb::Status status;
+  upb_MiniTable* table = upb_MiniTable_Build(
+      e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table);
+  EXPECT_EQ(count, table->field_count);
+  absl::flat_hash_set<size_t> offsets;
+  for (int i = 0; i < 16; i++) {
+    const upb_MiniTable_Field* f = &table->fields[i];
+    EXPECT_EQ(i + 1, f->number);
+    EXPECT_EQ(kUpb_FieldMode_Array, f->mode & kUpb_FieldMode_Mask);
+    EXPECT_TRUE(offsets.insert(f->offset).second);
+    EXPECT_TRUE(f->offset < table->size);
+  }
+  EXPECT_EQ(0, table->required_count);
+}
+
+TEST_P(MiniTableTest, Skips) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+  ASSERT_TRUE(e.StartMessage(0));
+  int count = 0;
+  std::vector<int> field_numbers;
+  for (int i = 0; i < 25; i++) {
+    int field_number = 1 << i;
+    field_numbers.push_back(field_number);
+    ASSERT_TRUE(e.PutField(kUpb_FieldType_Float, field_number, 0));
+    count++;
+  }
+  upb::Status status;
+  upb_MiniTable* table = upb_MiniTable_Build(
+      e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table);
+  EXPECT_EQ(count, table->field_count);
+  absl::flat_hash_set<size_t> offsets;
+  for (size_t i = 0; i < field_numbers.size(); i++) {
+    const upb_MiniTable_Field* f = &table->fields[i];
+    EXPECT_EQ(field_numbers[i], f->number);
+    EXPECT_EQ(kUpb_FieldType_Float, f->descriptortype);
+    EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
+    EXPECT_TRUE(offsets.insert(f->offset).second);
+    EXPECT_TRUE(f->offset < table->size);
+  }
+  EXPECT_EQ(0, table->required_count);
+}
+
+TEST_P(MiniTableTest, AllScalarTypesOneof) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+  ASSERT_TRUE(e.StartMessage(0));
+  int count = 0;
+  for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
+    ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i, 0));
+    count++;
+  }
+  ASSERT_TRUE(e.StartOneof());
+  for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
+    ASSERT_TRUE(e.PutOneofField(i));
+  }
+  upb::Status status;
+  upb_MiniTable* table = upb_MiniTable_Build(
+      e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table) << status.error_message();
+  EXPECT_EQ(count, table->field_count);
+  absl::flat_hash_set<size_t> offsets;
+  for (int i = 0; i < 16; i++) {
+    const upb_MiniTable_Field* f = &table->fields[i];
+    EXPECT_EQ(i + 1, f->number);
+    EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
+    // For a oneof all fields have the same offset.
+    EXPECT_EQ(table->fields[0].offset, f->offset);
+    // All presence fields should point to the same oneof case offset.
+    size_t case_ofs = _upb_oneofcase_ofs(f);
+    EXPECT_EQ(table->fields[0].presence, f->presence);
+    EXPECT_TRUE(f->offset < table->size);
+    EXPECT_TRUE(case_ofs < table->size);
+    EXPECT_TRUE(case_ofs != f->offset);
+  }
+  EXPECT_EQ(0, table->required_count);
+}
+
+INSTANTIATE_TEST_SUITE_P(Platforms, MiniTableTest,
+                         testing::Values(kUpb_MiniTablePlatform_32Bit,
+                                         kUpb_MiniTablePlatform_64Bit));
+
+TEST(MiniTablePlatformIndependentTest, Base92Roundtrip) {
+  for (char i = 0; i < 92; i++) {
+    EXPECT_EQ(i, upb_FromBase92(upb_ToBase92(i)));
+  }
+}
+
+TEST(MiniTablePlatformIndependentTest, IsTypePackable) {
+  for (int i = 1; i <= protobuf::FieldDescriptor::MAX_TYPE; i++) {
+    EXPECT_EQ(upb_IsTypePackable(static_cast<upb_FieldType>(i)),
+              protobuf::FieldDescriptor::IsTypePackable(
+                  static_cast<protobuf::FieldDescriptor::Type>(i)));
+  }
+}
+
+TEST(MiniTableEnumTest, Enum) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+
+  e.StartEnum();
+  absl::flat_hash_set<int32_t> values;
+  for (int i = 0; i < 256; i++) {
+    values.insert(i * 2);
+    e.PutEnumValue(i * 2);
+  }
+  e.EndEnum();
+
+  upb::Status status;
+  upb_MiniTable_Enum* table = upb_MiniTable_BuildEnum(
+      e.data().data(), e.data().size(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table) << status.error_message();
+
+  for (int i = 0; i < UINT16_MAX; i++) {
+    EXPECT_EQ(values.contains(i), upb_MiniTable_Enum_CheckValue(table, i)) << i;
+  }
+}
+
+TEST(MiniTableEnumTest, PositiveAndNegative) {
+  upb::Arena arena;
+  upb::MtDataEncoder e;
+
+  e.StartEnum();
+  absl::flat_hash_set<int32_t> values;
+  for (int i = 0; i < 100; i++) {
+    values.insert(i);
+    e.PutEnumValue(i);
+  }
+  for (int i = 100; i > 0; i--) {
+    values.insert(-i);
+    e.PutEnumValue(-i);
+  }
+  e.EndEnum();
+
+  upb::Status status;
+  upb_MiniTable_Enum* table = upb_MiniTable_BuildEnum(
+      e.data().data(), e.data().size(), arena.ptr(), status.ptr());
+  ASSERT_NE(nullptr, table) << status.error_message();
+
+  for (int i = -UINT16_MAX; i < UINT16_MAX; i++) {
+    EXPECT_EQ(values.contains(i), upb_MiniTable_Enum_CheckValue(table, i)) << i;
+  }
+}