Upload Kmake

test/js-native-api/test_finalizer/binding.gyp

@@ -0,0 +1,11 @@
+{
+  "targets": [
+    {
+      "target_name": "test_finalizer",
+      "defines": [ "NAPI_EXPERIMENTAL" ],
+      "sources": [
+        "test_finalizer.c"
+      ]
+    }
+  ]
+}

test/js-native-api/test_finalizer/test.js

@@ -0,0 +1,45 @@
+'use strict';
+// Flags: --expose-gc
+
+const common = require('../../common');
+const test_finalizer = require(`./build/${common.buildType}/test_finalizer`);
+const assert = require('assert');
+
+const { gcUntil } = require('../../common/gc');
+
+// The goal of this test is to show that we can run "pure" finalizers in the
+// current JS loop tick. Thus, we do not use gcUntil function works
+// asynchronously using micro tasks.
+// We use IIFE for the obj scope instead of {} to be compatible with
+// non-V8 JS engines that do not support scoped variables.
+(() => {
+  const obj = {};
+  test_finalizer.addFinalizer(obj);
+})();
+
+for (let i = 0; i < 10; ++i) {
+  global.gc();
+  if (test_finalizer.getFinalizerCallCount() === 1) {
+    break;
+  }
+}
+
+assert.strictEqual(test_finalizer.getFinalizerCallCount(), 1);
+
+// The finalizer that access JS cannot run synchronously. They are run in the
+// next JS loop tick. Thus, we must use gcUntil.
+async function runAsyncTests() {
+  // We do not use common.mustCall() because we want to see the finalizer
+  // called in response to GC and not as a part of env destruction.
+  let js_is_called = false;
+  // We use IIFE for the obj scope instead of {} to be compatible with
+  // non-V8 JS engines that do not support scoped variables.
+  (() => {
+    const obj = {};
+    test_finalizer.addFinalizerWithJS(obj, () => { js_is_called = true; });
+  })();
+  await gcUntil('ensure JS finalizer called',
+                () => (test_finalizer.getFinalizerCallCount() === 2));
+  assert(js_is_called);
+}
+runAsyncTests();

test/js-native-api/test_finalizer/test_fatal_finalize.js

@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../../common');
+
+if (process.argv[2] === 'child') {
+  const test_finalizer = require(`./build/${common.buildType}/test_finalizer`);
+
+  (() => {
+    const obj = {};
+    test_finalizer.addFinalizerFailOnJS(obj);
+  })();
+
+  // Collect garbage 10 times. At least one of those should throw the exception
+  // and cause the whole process to bail with it, its text printed to stderr and
+  // asserted by the parent process to match expectations.
+  let gcCount = 10;
+  (function gcLoop() {
+    global.gc();
+    if (--gcCount > 0) {
+      setImmediate(() => gcLoop());
+    }
+  })();
+  return;
+}
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const child = spawnSync(process.execPath, [
+  '--expose-gc', __filename, 'child',
+]);
+assert(common.nodeProcessAborted(child.status, child.signal));
+assert.match(child.stderr.toString(), /Finalizer is calling a function that may affect GC state/);

test/js-native-api/test_finalizer/test_finalizer.c

@@ -0,0 +1,148 @@
+#include <js_native_api.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+typedef struct {
+  int32_t finalize_count;
+  napi_ref js_func;
+} FinalizerData;
+
+static void finalizerOnlyCallback(node_api_basic_env env,
+                                  void* finalize_data,
+                                  void* finalize_hint) {
+  FinalizerData* data = (FinalizerData*)finalize_data;
+  int32_t count = ++data->finalize_count;
+
+  // It is safe to access instance data
+  NODE_API_BASIC_CALL_RETURN_VOID(env,
+                                  napi_get_instance_data(env, (void**)&data));
+  NODE_API_BASIC_ASSERT_RETURN_VOID(count = data->finalize_count,
+                                    "Expected to be the same FinalizerData");
+}
+
+static void finalizerCallingJSCallback(napi_env env,
+                                       void* finalize_data,
+                                       void* finalize_hint) {
+  napi_value js_func, undefined;
+  FinalizerData* data = (FinalizerData*)finalize_data;
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_get_reference_value(env, data->js_func, &js_func));
+  NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_call_function(env, undefined, js_func, 0, NULL, NULL));
+  NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_func));
+  data->js_func = NULL;
+  ++data->finalize_count;
+}
+
+// Schedule async finalizer to run JavaScript-touching code.
+static void finalizerWithJSCallback(node_api_basic_env env,
+                                    void* finalize_data,
+                                    void* finalize_hint) {
+  NODE_API_BASIC_CALL_RETURN_VOID(
+      env,
+      node_api_post_finalizer(
+          env, finalizerCallingJSCallback, finalize_data, finalize_hint));
+}
+
+static void finalizerWithFailedJSCallback(node_api_basic_env basic_env,
+                                          void* finalize_data,
+                                          void* finalize_hint) {
+  // Intentionally cast to a napi_env to test the fatal failure.
+  napi_env env = (napi_env)basic_env;
+  napi_value obj;
+  FinalizerData* data = (FinalizerData*)finalize_data;
+  ++data->finalize_count;
+  NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &obj));
+}
+
+static napi_value addFinalizer(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1] = {0};
+  FinalizerData* data;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_CALL(env,
+                napi_add_finalizer(
+                    env, argv[0], data, finalizerOnlyCallback, NULL, NULL));
+  return NULL;
+}
+
+// This finalizer is going to call JavaScript from finalizer and succeed.
+static napi_value addFinalizerWithJS(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2] = {0};
+  napi_valuetype arg_type;
+  FinalizerData* data;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_CALL(env, napi_typeof(env, argv[1], &arg_type));
+  NODE_API_ASSERT(
+      env, arg_type == napi_function, "Expected function as the second arg");
+  NODE_API_CALL(env, napi_create_reference(env, argv[1], 1, &data->js_func));
+  NODE_API_CALL(env,
+                napi_add_finalizer(
+                    env, argv[0], data, finalizerWithJSCallback, NULL, NULL));
+  return NULL;
+}
+
+// This finalizer is going to call JavaScript from finalizer and fail.
+static napi_value addFinalizerFailOnJS(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1] = {0};
+  FinalizerData* data;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_CALL(
+      env,
+      napi_add_finalizer(
+          env, argv[0], data, finalizerWithFailedJSCallback, NULL, NULL));
+  return NULL;
+}
+
+static napi_value getFinalizerCallCount(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  FinalizerData* data;
+  napi_value result;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_CALL(env, napi_create_int32(env, data->finalize_count, &result));
+  return result;
+}
+
+static void finalizeData(napi_env env, void* data, void* hint) {
+  free(data);
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  FinalizerData* data = (FinalizerData*)malloc(sizeof(FinalizerData));
+  NODE_API_ASSERT(env, data != NULL, "Failed to allocate memory");
+  memset(data, 0, sizeof(FinalizerData));
+  NODE_API_CALL(env, napi_set_instance_data(env, data, finalizeData, NULL));
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NODE_API_PROPERTY("addFinalizer", addFinalizer),
+      DECLARE_NODE_API_PROPERTY("addFinalizerWithJS", addFinalizerWithJS),
+      DECLARE_NODE_API_PROPERTY("addFinalizerFailOnJS", addFinalizerFailOnJS),
+      DECLARE_NODE_API_PROPERTY("getFinalizerCallCount",
+                                getFinalizerCallCount)};
+
+  NODE_API_CALL(
+      env,
+      napi_define_properties(env,
+                             exports,
+                             sizeof(descriptors) / sizeof(*descriptors),
+                             descriptors));
+
+  return exports;
+}
+EXTERN_C_END