Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/makesdna/tests/CMakeLists.txt

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: 2025 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+set(INC_SYS
+)
+
+if(WITH_GTESTS)
+  # Output dna.cc
+  add_custom_command(
+    OUTPUT
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_defaults.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_struct_ids.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_type_offsets.h
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_verify.cc
+    COMMAND
+      ${CMAKE_COMMAND} -E env ${PLATFORM_ENV_BUILD}
+      "$<TARGET_FILE:makesdna>"
+      --include-file dna_test.h
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_type_offsets.h
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_verify.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_struct_ids.cc
+      ${CMAKE_CURRENT_BINARY_DIR}/test_dna_defaults.cc
+      ${CMAKE_SOURCE_DIR}/source/blender/makesdna/tests/dna/
+    DEPENDS
+      makesdna
+      dna/dna_test.h
+  )
+
+  set_source_files_properties(
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna.cc
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_defaults.cc
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_struct_ids.cc
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_type_offsets.h
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_verify.cc
+    PROPERTIES GENERATED TRUE
+  )
+
+  set(TEST_SRC
+    makesdna_test.cc
+
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna.cc
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_struct_ids.cc
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_type_offsets.h
+    ${CMAKE_CURRENT_BINARY_DIR}/test_dna_verify.cc
+  )
+  set(TEST_INC
+    PRIVATE ..
+    PRIVATE ../intern
+  )
+  set(TEST_LIB
+    # bf::blenlib twice to avoid ld link error with circular dependency.
+    PRIVATE bf::blenlib
+    PRIVATE bf::dna
+    PRIVATE bf::blenlib
+  )
+
+  blender_add_test_executable(makesdna "${TEST_SRC}" "${TEST_INC}" "${INC_SYS}" "${TEST_LIB}")
+endif()

blender-5.2.0/source/blender/makesdna/tests/dna/dna_test.h

@@ -0,0 +1,79 @@
+/* SPDX-FileCopyrightText: 2025 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup DNA
+ * \brief DNA file which is used for the makesdna_test
+ */
+
+#pragma once
+
+#include "BLI_math_matrix_types.hh"
+#include "BLI_math_vector_types.hh"
+
+namespace blender {
+
+struct Library;
+struct TestStruct;
+
+/* Structure that is to be skipped from SDNA. */
+#
+#
+struct RuntimeStruct {
+  int foo;
+};
+
+/* NOTE: This type must exist in order for the SDNA to be considered valid. */
+struct ListBase {
+  void *first, *last;
+};
+
+struct TestStruct {
+#ifdef __cplusplus
+  TestStruct() = default;
+#endif
+
+  void *next, *prev;
+
+  char name[/*MAX_ID_NAME*/ 258];
+
+  short flag;
+  int _pad1;
+
+  ListBase some_list;
+  int tag;
+
+  int _pad2;
+};
+
+struct StructWithVectorMatrixTypes {
+  int2 my_int2;
+  float3 my_float3;
+  float _pad[3];
+  float4x4 my_matrix;
+};
+
+enum class TestEnum8 : int8_t {
+  A = 0,
+  B = 1,
+};
+
+enum TestEnum16 : int16_t {
+  TEST_ENUM16_A = 0,
+  TEST_ENUM16_B = 1,
+};
+
+enum class TestEnum32 : int32_t {
+  A = 0,
+  B = 1,
+};
+
+struct StructWithEnumMembers {
+  TestEnum8 my_enum8;
+  char _pad0;
+  TestEnum16 my_enum16;
+  TestEnum32 my_enum32;
+};
+
+}  // namespace blender

blender-5.2.0/source/blender/makesdna/tests/makesdna_test.cc

@@ -0,0 +1,184 @@
+/* SPDX-FileCopyrightText: 2025 Blender Authors
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "DNA_genfile.h"
+#include "DNA_sdna_types.h"
+
+#include "BLI_string_ref.hh"
+
+#include "dna/dna_test.h"
+
+namespace blender::dna {
+namespace {
+
+class SDNATest : public ::testing::Test {
+  void SetUp() override
+  {
+    sdna = DNA_sdna_from_data(DNAstr, DNAlen, false, true, nullptr);
+  }
+
+  void TearDown() override
+  {
+    if (sdna) {
+      DNA_sdna_free(sdna);
+    }
+  }
+
+ protected:
+  SDNA *sdna = nullptr;
+};
+
+/**
+ * Get the struct member with an exact name.
+ * For example, expects the C array size in the name.
+ * For example, pass "name[258]" to access the test struct name, not `name[]`.
+ */
+const SDNA_StructMember *get_struct_member(const SDNA *sdna,
+                                           const StringRefNull struct_name,
+                                           const StringRefNull member_name)
+{
+  const int struct_index = DNA_struct_find_index_without_alias(sdna, struct_name.c_str());
+  if (struct_index == -1) {
+    return nullptr;
+  }
+
+  const SDNA_Struct *struct_ptr = sdna->structs[struct_index];
+  for (int i = 0; i < struct_ptr->members_num; ++i) {
+    const SDNA_StructMember &struct_member = struct_ptr->members[i];
+    if (sdna->members[struct_member.member_index] == member_name) {
+      return &struct_member;
+    }
+  }
+
+  return nullptr;
+}
+
+/**
+ * Get struct member size with the exact name.
+ * For example, expects the C array size in the name.
+ * For example, pass `name[258]` to access test struct name, not `name[]`.
+ */
+int get_struct_member_size(const SDNA *sdna,
+                           const StringRefNull struct_name,
+                           const StringRefNull member_name)
+{
+  const SDNA_StructMember *struct_member = get_struct_member(sdna, struct_name, member_name);
+  if (!struct_member) {
+    return -1;
+  }
+  return DNA_struct_member_size(sdna, struct_member->type_index, struct_member->member_index);
+}
+
+}  // namespace
+
+constexpr int kRawDataStructId = 0;               /* raw_data */
+constexpr int kListBaseStructId = 1;              /* ListBase */
+constexpr int kTestStructId = 2;                  /* ID */
+constexpr int kStructWithVectorMatrixTypesId = 3; /* float3 and float4x4 */
+constexpr int kStructWithEnumMembersId = 4;       /* enums with underlying types */
+
+TEST_F(SDNATest, basic)
+{
+  ASSERT_NE(sdna, nullptr);
+
+  EXPECT_EQ(sdna->structs_num, 5);
+}
+
+TEST_F(SDNATest, index_without_alias)
+{
+  ASSERT_NE(sdna, nullptr);
+
+  EXPECT_EQ(DNA_struct_find_index_without_alias(sdna, "raw_data"), kRawDataStructId);
+  EXPECT_EQ(DNA_struct_find_index_without_alias(sdna, "ListBase"), kListBaseStructId);
+  EXPECT_EQ(DNA_struct_find_index_without_alias(sdna, "TestStruct"), kTestStructId);
+  EXPECT_EQ(DNA_struct_find_index_without_alias(sdna, "StructWithVectorMatrixTypes"),
+            kStructWithVectorMatrixTypesId);
+  EXPECT_EQ(DNA_struct_find_index_without_alias(sdna, "StructWithEnumMembers"),
+            kStructWithEnumMembersId);
+}
+
+TEST_F(SDNATest, struct_size)
+{
+  ASSERT_NE(sdna, nullptr);
+
+  EXPECT_EQ(DNA_struct_size(sdna, kListBaseStructId), sizeof(ListBase));
+  EXPECT_EQ(DNA_struct_size(sdna, kTestStructId), sizeof(TestStruct));
+  EXPECT_EQ(DNA_struct_size(sdna, kStructWithVectorMatrixTypesId),
+            sizeof(StructWithVectorMatrixTypes));
+  EXPECT_EQ(DNA_struct_size(sdna, kStructWithEnumMembersId), sizeof(StructWithEnumMembers));
+}
+
+TEST_F(SDNATest, struct_member_size)
+{
+  ASSERT_NE(sdna, nullptr);
+
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "*next"), sizeof(TestStruct::next));
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "*prev"), sizeof(TestStruct::prev));
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "name[258]"), sizeof(TestStruct::name));
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "flag"), sizeof(TestStruct::flag));
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "some_list"),
+            sizeof(TestStruct::some_list));
+  EXPECT_EQ(get_struct_member_size(sdna, "TestStruct", "tag"), sizeof(TestStruct::tag));
+
+  /* VectorMatrix members. */
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithVectorMatrixTypes", "my_int2[2]"),
+            sizeof(StructWithVectorMatrixTypes::my_int2));
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithVectorMatrixTypes", "my_float3[3]"),
+            sizeof(StructWithVectorMatrixTypes::my_float3));
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithVectorMatrixTypes", "my_matrix[4][4]"),
+            sizeof(StructWithVectorMatrixTypes::my_matrix));
+
+  /* Enum members get their underlying integer type's size. */
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithEnumMembers", "my_enum8"),
+            sizeof(StructWithEnumMembers::my_enum8));
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithEnumMembers", "my_enum16"),
+            sizeof(StructWithEnumMembers::my_enum16));
+  EXPECT_EQ(get_struct_member_size(sdna, "StructWithEnumMembers", "my_enum32"),
+            sizeof(StructWithEnumMembers::my_enum32));
+}
+
+TEST_F(SDNATest, struct_member_offset_by_name_without_alias)
+{
+  ASSERT_NE(sdna, nullptr);
+
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "void", "*next"),
+            offsetof(TestStruct, next));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "void", "*prev"),
+            offsetof(TestStruct, prev));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "char", "name[]"),
+            offsetof(TestStruct, name));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "short", "flag"),
+            offsetof(TestStruct, flag));
+  EXPECT_EQ(
+      DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "ListBase", "some_list"),
+      offsetof(TestStruct, some_list));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(sdna, "TestStruct", "int", "tag"),
+            offsetof(TestStruct, tag));
+
+  /* VectorMatrix members. */
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithVectorMatrixTypes", "int", "my_int2[2]"),
+            offsetof(StructWithVectorMatrixTypes, my_int2));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithVectorMatrixTypes", "float", "my_float3[3]"),
+            offsetof(StructWithVectorMatrixTypes, my_float3));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithVectorMatrixTypes", "float", "my_matrix[4][4]"),
+            offsetof(StructWithVectorMatrixTypes, my_matrix));
+
+  /* Enum members are stored using their underlying integer type. */
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithEnumMembers", "int8_t", "my_enum8"),
+            offsetof(StructWithEnumMembers, my_enum8));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithEnumMembers", "short", "my_enum16"),
+            offsetof(StructWithEnumMembers, my_enum16));
+  EXPECT_EQ(DNA_struct_member_offset_by_name_without_alias(
+                sdna, "StructWithEnumMembers", "int", "my_enum32"),
+            offsetof(StructWithEnumMembers, my_enum32));
+}
+
+}  // namespace blender::dna