2021 12 02 fix V8 initialization order (nodejs#133)

Fix initialization order in testrunner

Author: camillobruni

test/cctest/node_test_fixture.cc

@@ -1,7 +1,39 @@
 #include "node_test_fixture.h"
+#include "cppgc/platform.h"
 
 ArrayBufferUniquePtr NodeZeroIsolateTestFixture::allocator{nullptr, nullptr};
 uv_loop_t NodeZeroIsolateTestFixture::current_loop;
 NodePlatformUniquePtr NodeZeroIsolateTestFixture::platform;
 TracingAgentUniquePtr NodeZeroIsolateTestFixture::tracing_agent;
 bool NodeZeroIsolateTestFixture::node_initialized = false;
+
+
+void NodeTestEnvironment::SetUp() {
+  NodeZeroIsolateTestFixture::tracing_agent =
+      std::make_unique<node::tracing::Agent>();
+  node::tracing::TraceEventHelper::SetAgent(
+      NodeZeroIsolateTestFixture::tracing_agent.get());
+  node::tracing::TracingController* tracing_controller =
+      NodeZeroIsolateTestFixture::tracing_agent->GetTracingController();
+  static constexpr int kV8ThreadPoolSize = 4;
+  NodeZeroIsolateTestFixture::platform.reset(
+      new node::NodePlatform(kV8ThreadPoolSize, tracing_controller));
+  v8::V8::InitializePlatform(NodeZeroIsolateTestFixture::platform.get());
+#ifdef V8_VIRTUAL_MEMORY_CAGE
+  ASSERT_TRUE(v8::V8::InitializeVirtualMemoryCage());
+#endif
+  cppgc::InitializeProcess(
+      NodeZeroIsolateTestFixture::platform->GetPageAllocator());
+  v8::V8::Initialize();
+}
+
+void NodeTestEnvironment::TearDown() {
+  v8::V8::Dispose();
+  v8::V8::ShutdownPlatform();
+  NodeZeroIsolateTestFixture::platform->Shutdown();
+  NodeZeroIsolateTestFixture::platform.reset(nullptr);
+  NodeZeroIsolateTestFixture::tracing_agent.reset(nullptr);
+}
+
+::testing::Environment* const node_env =
+::testing::AddGlobalTestEnvironment(new NodeTestEnvironment());

test/cctest/node_test_fixture.h

@@ -60,18 +60,26 @@ using ArrayBufferUniquePtr = std::unique_ptr<node::ArrayBufferAllocator,
 using TracingAgentUniquePtr = std::unique_ptr<node::tracing::Agent>;
 using NodePlatformUniquePtr = std::unique_ptr<node::NodePlatform>;
 
+class NodeTestEnvironment final : public ::testing::Environment {
+ public:
+  NodeTestEnvironment()  = default;
+  void SetUp() override;
+  void TearDown() override;
+};
+
+
 class NodeZeroIsolateTestFixture : public ::testing::Test {
  protected:
-  static ArrayBufferUniquePtr allocator;
-  static TracingAgentUniquePtr tracing_agent;
-  static NodePlatformUniquePtr platform;
   static uv_loop_t current_loop;
   static bool node_initialized;
+  static ArrayBufferUniquePtr allocator;
+  static NodePlatformUniquePtr platform;
+  static TracingAgentUniquePtr tracing_agent;
 
   static void SetUpTestCase() {
     if (!node_initialized) {
-      uv_os_unsetenv("NODE_OPTIONS");
       node_initialized = true;
+      uv_os_unsetenv("NODE_OPTIONS");
       std::vector<std::string> argv { "cctest" };
       std::vector<std::string> exec_argv;
       std::vector<std::string> errors;
@@ -80,32 +88,22 @@ class NodeZeroIsolateTestFixture : public ::testing::Test {
       CHECK_EQ(exitcode, 0);
       CHECK(errors.empty());
     }
-
-    tracing_agent = std::make_unique<node::tracing::Agent>();
-    node::tracing::TraceEventHelper::SetAgent(tracing_agent.get());
-    node::tracing::TracingController* tracing_controller =
-        tracing_agent->GetTracingController();
     CHECK_EQ(0, uv_loop_init(&current_loop));
-    static constexpr int kV8ThreadPoolSize = 4;
-    platform.reset(
-        new node::NodePlatform(kV8ThreadPoolSize, tracing_controller));
-    v8::V8::InitializePlatform(platform.get());
-    v8::V8::Initialize();
   }
 
   static void TearDownTestCase() {
-    platform->Shutdown();
     while (uv_loop_alive(&current_loop)) {
       uv_run(&current_loop, UV_RUN_ONCE);
     }
-    v8::V8::DisposePlatform();
     CHECK_EQ(0, uv_loop_close(&current_loop));
   }
 
   void SetUp() override {
     allocator = ArrayBufferUniquePtr(node::CreateArrayBufferAllocator(),
                                      &node::FreeArrayBufferAllocator);
   }
+
+  friend NodeTestEnvironment;
 };
 
 

tools/code_cache/mkcodecache.cc

@@ -68,6 +68,7 @@ int main(int argc, char* argv[]) {
   }
   isolate->Dispose();
 
+  v8::V8::Dispose();
   v8::V8::DisposePlatform();
   return 0;
 }