build,test: add tests for binary linked with shared libnode

This adds tests to ensure the V8 parts (v8, libplatform, cppgc)
in shared libnode works correctly.
PR-URL: #61463
Backport-PR-URL: #65219
Refs: #61144
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>

Author: joyeecheung

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});

node.gyp

@@ -1511,6 +1511,61 @@
  ],
  }, # embedtest
 
+ {
+'target_name': 'shared_embedtest',
+'type': 'executable',
+
+'dependencies': [
+'<(node_lib_target_name)',
+ ],
+
+# Don't depend on node.gypi - it otherwise links to
+# the static libraries and resolve symbols at build time.
+'include_dirs': [
+'deps/v8/include',
+ ],
+
+'sources': [
+'test/embedding/shared_embedtest.cc',
+ ],
+'conditions': [
+ [ 'node_shared=="true"', {
+'defines': [
+'USING_V8_SHARED',
+'USING_V8_PLATFORM_SHARED',
+ ],
+'defines!': [
+'BUILDING_V8_PLATFORM_SHARED=1',
+'BUILDING_V8_SHARED=1',
+ ],
+ }, {
+# Only test shared embedding when Node is built as shared library.
+'type': 'none',
+ }],
+# Only test platforms known to work.
+ ['OS not in "mac win linux"', {
+'type': 'none',
+ }],
+ ['OS=="win"', {
+'libraries': [
+'Dbghelp.lib',
+'winmm.lib',
+'Ws2_32.lib',
+ ],
+ }],
+ ['OS=="mac"', {
+'xcode_settings': {
+'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+ }
+ }],
+ ['OS=="linux"', {
+'ldflags': [
+'-Wl,-rpath,\\$$ORIGIN'
+ ],
+ }],
+ ],
+ }, # shared_embedtest
+
  {
 'target_name': 'overlapped-checker',
 'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 constnoop=()=>{};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+constusesSharedLibrary=process.config.variables.node_shared;
 consthasCrypto=Boolean(process.versions.openssl)&&
 !process.env.NODE_SKIP_CRYPTO;
 
@@ -945,6 +947,13 @@ function sleepSync(ms) {
 Atomics.wait(i32,0,0,ms);
 }
 
+functionresolveBuiltBinary(binary){
+if(isWindows){
+binary+='.exe';
+}
+returnpath.join(path.dirname(process.execPath),binary);
+}
+
 constcommon={
  allowGlobals,
  buildType,
@@ -990,6 +999,7 @@ const common = {
  printSkipMessage,
  pwdCommand,
  requireNoPackageJSONAbove,
+ resolveBuiltBinary,
  runWithInvalidFD,
  skip,
  skipIf32Bits,
@@ -998,6 +1008,7 @@ const common = {
  skipIfSQLiteMissing,
  spawnPromisified,
  sleepSync,
+ usesSharedLibrary,
 
 getenoughTestMem(){
 returnrequire('os').totalmem()>0x70000000;/* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,58 @@
+#include<libplatform/libplatform.h>
+#include<v8-cppgc.h>
+#include<v8.h>
+
+#include<cppgc/allocation.h>
+#include<cppgc/default-platform.h>
+#include<cppgc/garbage-collected.h>
+#include<cppgc/heap.h>
+#include<cppgc/member.h>
+#include<cppgc/platform.h>
+#include<cppgc/visitor.h>
+
+classWrappablefinal : public cppgc::GarbageCollected<Wrappable> {
+public:
+voidTrace(cppgc::Visitor* visitor) const {}
+};
+
+intmain(int argc, char* argv[]) {
+ std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+v8::V8::InitializePlatform(platform.get());
+cppgc::InitializeProcess(platform->GetPageAllocator());
+v8::V8::Initialize();
+
+auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator =
+v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+ create_params.cpp_heap = heap.release();
+
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+ Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+ isolate->GetCppHeap()->GetAllocationHandle());
+ v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+ isolate, obj, wrappable);
+ v8::Local<v8::String> source =
+v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+ v8::Local<v8::Script> script =
+v8::Script::Compile(context, source).ToLocalChecked();
+ v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+ v8::String::Utf8Value utf8(isolate, result);
+printf("%s\n", *utf8);
+ }
+
+ isolate->Dispose();
+cppgc::ShutdownProcess();
+v8::V8::Dispose();
+v8::V8::DisposePlatform();
+delete create_params.array_buffer_allocator;
+
+return0;
+}

test/embedding/test-embedding.js

@@ -8,22 +8,14 @@ const {
  spawnSyncAndExit,
  spawnSyncAndExitWithoutError,
 }=require('../common/child_process');
-constpath=require('path');
 constfs=require('fs');
 constos=require('os');
 
 tmpdir.refresh();
 common.allowGlobals(global.require);
 common.allowGlobals(global.embedVars);
 
-functionresolveBuiltBinary(binary){
-if(common.isWindows){
-binary+='.exe';
-}
-returnpath.join(path.dirname(process.execPath),binary);
-}
-
-constbinary=resolveBuiltBinary('embedtest');
+constbinary=common.resolveBuiltBinary('embedtest');
 
 spawnSyncAndAssert(
 binary,

test/embedding/test-shared-embedding-v8.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests the V8 parts in the shared library work correctly.
+// TODO(joyeecheung): also test that the Node.js parts work correctly,
+// which can be done in embedtest just built in shared library mode.
+
+constcommon=require('../common');
+
+if(!common.usesSharedLibrary){
+common.skip('Only tests builds linking against Node.js shared library');
+}
+
+const{ spawnSyncAndAssert }=require('../common/child_process');
+constfs=require('fs');
+
+constbinary=common.resolveBuiltBinary('shared_embedtest');
+
+if(!fs.existsSync(binary)){
+common.skip('shared_embedtest binary not built');
+}
+
+spawnSyncAndAssert(binary,{
+trim: true,
+stdout: 'Hello, World!',
+});