Add Chromium-only Blender WebEngine parity work

blender-5.2.0/tests/gtests/testing/CMakeLists.txt

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: 2014 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+add_definitions(${GFLAGS_DEFINES})
+add_definitions(${GLOG_DEFINES})
+add_definitions(-DBLENDER_GFLAGS_NAMESPACE=${GFLAGS_NAMESPACE})
+
+set(INC
+  .
+  ..
+)
+
+set(INC_SYS
+  ${GLOG_INCLUDE_DIRS}
+  ${GFLAGS_INCLUDE_DIRS}
+  ../../../extern/gtest/include
+)
+
+set(SRC
+  testing_main.cc
+
+  testing.h
+)
+
+set(LIB
+  PRIVATE bf::intern::guardedalloc
+)
+
+blender_add_lib(bf_testing_main "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

blender-5.2.0/tests/gtests/testing/mock_log.h

@@ -0,0 +1,148 @@
+/* SPDX-FileCopyrightText: 2007 Google Inc. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause */
+
+/** \file
+ * Defines the #ScopedMockLog class (using Google C++ Mocking Framework),
+ * which is convenient for testing code that uses LOG().
+ *
+ * NOTE(@keir): This is a fork until Google Log exports the scoped mock log class;
+ * see: http://code.google.com/p/google-glog/issues/detail?id=88
+ *
+ * Author: Zhanyong Wan
+ */
+
+#ifndef GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
+#define GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
+
+#include <string>
+
+#include "glog/logging.h"
+#include "gmock/gmock.h"
+
+// Needed to make the scoped mock log tests work without modification.
+namespace ceres {
+namespace internal {
+using google::WARNING;
+}  // namespace internal
+}  // namespace ceres
+
+namespace testing {
+
+// A ScopedMockLog object intercepts LOG() messages issued during its
+// lifespan.  Using this together with Google C++ Mocking Framework,
+// it's very easy to test how a piece of code calls LOG().  The
+// typical usage:
+//
+//   TEST(FooTest, LogsCorrectly) {
+//     ScopedMockLog log;
+//
+//     // We expect the WARNING "Something bad!" exactly twice.
+//     EXPECT_CALL(log, Log(WARNING, _, "Something bad!"))
+//         .Times(2);
+//
+//     // We allow foo.cc to call LOG(INFO) any number of times.
+//     EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _))
+//         .Times(AnyNumber());
+//
+//     Foo();  // Exercises the code under test.
+//   }
+class ScopedMockLog : public google::LogSink {
+ public:
+  // When a ScopedMockLog object is constructed, it starts to
+  // intercept logs.
+  ScopedMockLog()
+  {
+    AddLogSink(this);
+  }
+
+  // When the object is destructed, it stops intercepting logs.
+  virtual ~ScopedMockLog()
+  {
+    RemoveLogSink(this);
+  }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity, const string& file_path,
+  //            const string& message);
+  //
+  // The second argument to Send() is the full path of the source file
+  // in which the LOG() was issued.
+  //
+  // Note, that in a multi-threaded environment, all LOG() messages from a
+  // single thread will be handled in sequence, but that cannot be guaranteed
+  // for messages from different threads. In fact, if the same or multiple
+  // expectations are matched on two threads concurrently, their actions will
+  // be executed concurrently as well and may interleave.
+  MOCK_METHOD3(Log,
+               void(google::LogSeverity severity,
+                    const std::string &file_path,
+                    const std::string &message));
+
+ private:
+  // Implements the send() virtual function in class LogSink.
+  // Whenever a LOG() statement is executed, this function will be
+  // invoked with information presented in the LOG().
+  //
+  // The method argument list is long and carries much information a
+  // test usually doesn't care about, so we trim the list before
+  // forwarding the call to Log(), which is much easier to use in
+  // tests.
+  //
+  // We still cannot call Log() directly, as it may invoke other LOG()
+  // messages, either due to Invoke, or due to an error logged in
+  // Google C++ Mocking Framework code, which would trigger a deadlock
+  // since a lock is held during send().
+  //
+  // Hence, we save the message for WaitTillSent() which will be called after
+  // the lock on send() is released, and we'll call Log() inside
+  // WaitTillSent(). Since while a single send() call may be running at a
+  // time, multiple WaitTillSent() calls (along with the one send() call) may
+  // be running simultaneously, we ensure thread-safety of the exchange between
+  // send() and WaitTillSent(), and that for each message, LOG(), send(),
+  // WaitTillSent() and Log() are executed in the same thread.
+  virtual void send(google::LogSeverity severity,
+                    const char *full_filename,
+                    const char * /*base_filename*/,
+                    int /*line*/,
+                    const tm * /*tm_time*/,
+                    const char *message,
+                    size_t message_len)
+  {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    message_info_.severity = severity;
+    message_info_.file_path = full_filename;
+    message_info_.message = std::string(message, message_len);
+  }
+
+  // Implements the WaitTillSent() virtual function in class LogSink.
+  // It will be executed after send() and after the global logging lock is
+  // released, so calls within it (or rather within the Log() method called
+  // within) may also issue LOG() statements.
+  //
+  // LOG(), send(), WaitTillSent() and Log() will occur in the same thread for
+  // a given log message.
+  virtual void WaitTillSent()
+  {
+    // First, and very importantly, we save a copy of the message being
+    // processed before calling Log(), since Log() may indirectly call send()
+    // and WaitTillSent() in the same thread again.
+    MessageInfo message_info = message_info_;
+    Log(message_info.severity, message_info.file_path, message_info.message);
+  }
+
+  // All relevant information about a logged message that needs to be passed
+  // from send() to WaitTillSent().
+  struct MessageInfo {
+    google::LogSeverity severity;
+    std::string file_path;
+    std::string message;
+  };
+  MessageInfo message_info_;
+};
+
+}  // namespace testing
+
+#endif  // GOOGLE_CERES_INTERNAL_MOCK_LOG_H_

blender-5.2.0/tests/gtests/testing/testing.h

@@ -0,0 +1,222 @@
+/* SPDX-FileCopyrightText: 2014 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+#ifndef __BLENDER_TESTING_H__
+#define __BLENDER_TESTING_H__
+
+#include <cstdint>
+#include <vector>
+
+#include <gflags/gflags.h>  // IWYU pragma: export
+#include <glog/logging.h>   // IWYU pragma: export
+#include <gtest/gtest.h>    // IWYU pragma: export
+
+/* Fwd.
+ */
+namespace blender {
+
+template<typename T> class Span;
+
+}  // namespace blender
+
+namespace blender::tests {
+
+/* These strings are passed on the CLI with the --test-asset-dir and --test-release-dir arguments.
+ * The arguments are added automatically when invoking tests via `ctest`. */
+const std::string &flags_test_asset_dir();   /* tests/files in the Blender repository. */
+const std::string &flags_test_release_dir(); /* bin/{blender version} in the build directory. */
+
+/* Returns true if the `BLENDER_TEST_IGNORE_BLOCKLIST` environment variable is set. */
+bool should_ignore_blocklist(bool is_all_gpu_vendors);
+
+}  // namespace blender::tests
+
+#define EXPECT_V2_NEAR(a, b, eps) \
+  { \
+    EXPECT_NEAR(a[0], b[0], eps); \
+    EXPECT_NEAR(a[1], b[1], eps); \
+  } \
+  (void)0
+
+#define EXPECT_V3_NEAR(a, b, eps) \
+  { \
+    EXPECT_NEAR(a[0], b[0], eps); \
+    EXPECT_NEAR(a[1], b[1], eps); \
+    EXPECT_NEAR(a[2], b[2], eps); \
+  } \
+  (void)0
+
+#define EXPECT_V4_NEAR(a, b, eps) \
+  { \
+    EXPECT_NEAR(a[0], b[0], eps); \
+    EXPECT_NEAR(a[1], b[1], eps); \
+    EXPECT_NEAR(a[2], b[2], eps); \
+    EXPECT_NEAR(a[3], b[3], eps); \
+  } \
+  (void)0
+
+#define EXPECT_M2_NEAR(a, b, eps) \
+  do { \
+    EXPECT_V2_NEAR(a[0], b[0], eps); \
+    EXPECT_V2_NEAR(a[1], b[1], eps); \
+  } while (false);
+
+#define EXPECT_M3_NEAR(a, b, eps) \
+  do { \
+    EXPECT_V3_NEAR(a[0], b[0], eps); \
+    EXPECT_V3_NEAR(a[1], b[1], eps); \
+    EXPECT_V3_NEAR(a[2], b[2], eps); \
+  } while (false);
+
+#define EXPECT_M4_NEAR(a, b, eps) \
+  do { \
+    EXPECT_V4_NEAR(a[0], b[0], eps); \
+    EXPECT_V4_NEAR(a[1], b[1], eps); \
+    EXPECT_V4_NEAR(a[2], b[2], eps); \
+    EXPECT_V4_NEAR(a[3], b[3], eps); \
+  } while (false);
+
+#define EXPECT_MATRIX_NEAR(a, b, tolerance) \
+  do { \
+    bool dims_match = (a.rows() == b.rows()) && (a.cols() == b.cols()); \
+    EXPECT_EQ(a.rows(), b.rows()) << "Matrix rows don't match."; \
+    EXPECT_EQ(a.cols(), b.cols()) << "Matrix cols don't match."; \
+    if (dims_match) { \
+      for (int r = 0; r < a.rows(); ++r) { \
+        for (int c = 0; c < a.cols(); ++c) { \
+          EXPECT_NEAR(a(r, c), b(r, c), tolerance) << "r=" << r << ", c=" << c << "."; \
+        } \
+      } \
+    } \
+  } while (false);
+
+#define EXPECT_MATRIX_NEAR_ZERO(a, tolerance) \
+  do { \
+    for (int r = 0; r < a.rows(); ++r) { \
+      for (int c = 0; c < a.cols(); ++c) { \
+        EXPECT_NEAR(0.0, a(r, c), tolerance) << "r=" << r << ", c=" << c << "."; \
+      } \
+    } \
+  } while (false);
+
+#define EXPECT_MATRIX_EQ(a, b) \
+  do { \
+    bool dims_match = (a.rows() == b.rows()) && (a.cols() == b.cols()); \
+    EXPECT_EQ(a.rows(), b.rows()) << "Matrix rows don't match."; \
+    EXPECT_EQ(a.cols(), b.cols()) << "Matrix cols don't match."; \
+    if (dims_match) { \
+      for (int r = 0; r < a.rows(); ++r) { \
+        for (int c = 0; c < a.cols(); ++c) { \
+          EXPECT_EQ(a(r, c), b(r, c)) << "r=" << r << ", c=" << c << "."; \
+        } \
+      } \
+    } \
+  } while (false);
+
+// Check that sin(angle(a, b)) < tolerance.
+#define EXPECT_MATRIX_PROP(a, b, tolerance) \
+  do { \
+    bool dims_match = (a.rows() == b.rows()) && (a.cols() == b.cols()); \
+    EXPECT_EQ(a.rows(), b.rows()) << "Matrix rows don't match."; \
+    EXPECT_EQ(a.cols(), b.cols()) << "Matrix cols don't match."; \
+    if (dims_match) { \
+      double c = CosinusBetweenMatrices(a, b); \
+      if (c * c < 1) { \
+        double s = sqrt(1 - c * c); \
+        EXPECT_NEAR(0, s, tolerance); \
+      } \
+    } \
+  } while (false);
+
+#ifdef LIBMV_NUMERIC_NUMERIC_H
+template<class TMat> double CosinusBetweenMatrices(const TMat &a, const TMat &b)
+{
+  return (a.array() * b.array()).sum() / libmv::FrobeniusNorm(a) / libmv::FrobeniusNorm(b);
+}
+#endif
+
+template<typename T>
+inline void EXPECT_EQ_VECTOR(const std::vector<T> &expected, const std::vector<T> &actual)
+{
+  EXPECT_EQ(expected.size(), actual.size());
+  if (expected.size() == actual.size()) {
+    for (size_t i = 0; i < expected.size(); ++i) {
+      EXPECT_EQ(expected[i], actual[i]) << "Element mismatch at index " << i;
+    }
+  }
+}
+
+template<typename T>
+inline void EXPECT_EQ_SPAN(const blender::Span<T> expected, const blender::Span<T> actual)
+{
+  EXPECT_EQ(expected.size(), actual.size());
+  if (expected.size() == actual.size()) {
+    for (const int64_t i : expected.index_range()) {
+      EXPECT_EQ(expected[i], actual[i]) << "Element mismatch at index " << i;
+    }
+  }
+}
+
+template<typename T, typename U>
+inline void EXPECT_NEAR_SPAN(const blender::Span<T> expected,
+                             const blender::Span<T> actual,
+                             const U tolerance)
+{
+  EXPECT_EQ(expected.size(), actual.size());
+  if (expected.size() == actual.size()) {
+    for (const int64_t i : expected.index_range()) {
+      EXPECT_NEAR(expected[i], actual[i], tolerance) << "Element mismatch at index " << i;
+    }
+  }
+}
+
+template<typename T>
+inline void EXPECT_EQ_ARRAY(const T *expected, const T *actual, const size_t N)
+{
+  for (size_t i = 0; i < N; ++i) {
+    EXPECT_EQ(expected[i], actual[i]) << "Element mismatch at index " << i;
+  }
+}
+
+template<typename T>
+inline void EXPECT_EQ_ARRAY_ND(const T *expected, const T *actual, const size_t N, const size_t D)
+{
+  for (size_t i = 0; i < N; ++i) {
+    for (size_t j = 0; j < D; ++j) {
+      EXPECT_EQ(expected[i][j], actual[i][j])
+          << "Element mismatch at index " << i << ", component index " << j;
+    }
+  }
+}
+
+template<typename T, typename U>
+inline void EXPECT_NEAR_ARRAY_ND(
+    const T *expected, const T *actual, const size_t N, const size_t D, const U tolerance)
+{
+  for (size_t i = 0; i < N; ++i) {
+    for (size_t j = 0; j < D; ++j) {
+      EXPECT_NEAR(expected[i][j], actual[i][j], tolerance)
+          << "Element mismatch at index " << i << ", component index " << j;
+    }
+  }
+}
+
+#ifdef _WIN32
+#  define ABORT_PREDICATE ::testing::ExitedWithCode(3)
+#else
+#  define ABORT_PREDICATE ::testing::KilledBySignal(SIGABRT)
+#endif
+
+/* Test macro for when BLI_assert() is expected to fail.
+ * Note that the EXPECT_BLI_ASSERT macro is a no-op, unless used in a debug build with
+ * WITH_ASSERT_ABORT=ON. */
+#if defined(WITH_ASSERT_ABORT) && !defined(NDEBUG)
+/* EXPECT_EXIT() is used as that's the only exit-expecting function in GTest that allows us to
+ * check for SIGABRT. */
+#  define EXPECT_BLI_ASSERT(function_call, expect_message) \
+    EXPECT_EXIT(function_call, ABORT_PREDICATE, expect_message)
+#else
+#  define EXPECT_BLI_ASSERT(function_call, expect_message) function_call
+#endif
+
+#endif  // __BLENDER_TESTING_H__

blender-5.2.0/tests/gtests/testing/testing_main.cc

@@ -0,0 +1,52 @@
+/* SPDX-FileCopyrightText: 2014 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "testing/testing.h"
+
+#include "MEM_guardedalloc.h"
+
+#include <stdlib.h>
+
+DEFINE_string(test_assets_dir, "", "tests/files directory containing the test assets.");
+DEFINE_string(test_release_dir, "", "bin/{blender version} directory of the current build.");
+
+namespace blender::tests {
+
+const std::string &flags_test_asset_dir()
+{
+  if (FLAGS_test_assets_dir.empty()) {
+    ADD_FAILURE() << "Pass the flag --test-assets-dir and point to the tests/files directory.";
+  }
+  return FLAGS_test_assets_dir;
+}
+
+const std::string &flags_test_release_dir()
+{
+  if (FLAGS_test_release_dir.empty()) {
+    ADD_FAILURE()
+        << "Pass the flag --test-release-dir and point to the bin/{blender version} directory.";
+  }
+  return FLAGS_test_release_dir;
+}
+
+bool should_ignore_blocklist(bool is_all_gpu_vendors)
+{
+  static bool has_env = getenv("BLENDER_TEST_IGNORE_BLOCKLIST");
+  static bool has_env_vendor = getenv("BLENDER_TEST_IGNORE_VENDOR_BLOCKLIST");
+  return has_env || (!is_all_gpu_vendors && has_env_vendor);
+}
+
+}  // namespace blender::tests
+
+int main(int argc, char **argv)
+{
+  MEM_use_guarded_allocator();
+  MEM_init_memleak_detection();
+  MEM_enable_fail_on_memleak();
+  testing::InitGoogleTest(&argc, argv);
+  BLENDER_GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
+  google::InitGoogleLogging(argv[0]);
+
+  return RUN_ALL_TESTS();
+}