Upload Kmake

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

@@ -0,0 +1,16 @@
+{
+  "targets": [
+    {
+      "target_name": "test_reference",
+      "sources": [
+        "test_reference.c"
+      ]
+    },
+    {
+      "target_name": "test_finalizer",
+      "sources": [
+        "test_finalizer.c"
+      ]
+    }
+  ]
+}

test/js-native-api/test_reference/test.js

@@ -0,0 +1,156 @@
+'use strict';
+// Flags: --expose-gc
+
+const { buildType } = require('../../common');
+const { gcUntil } = require('../../common/gc');
+const assert = require('assert');
+
+const test_reference = require(`./build/${buildType}/test_reference`);
+
+// This test script uses external values with finalizer callbacks
+// in order to track when values get garbage-collected. Each invocation
+// of a finalizer callback increments the finalizeCount property.
+assert.strictEqual(test_reference.finalizeCount, 0);
+
+// Run each test function in sequence,
+// with an async delay and GC call between each.
+async function runTests() {
+  (() => {
+    const symbol = test_reference.createSymbol('testSym');
+    test_reference.createReference(symbol, 0);
+    assert.strictEqual(test_reference.referenceValue, symbol);
+  })();
+  test_reference.deleteReference();
+
+  (() => {
+    const symbol = test_reference.createSymbolFor('testSymFor');
+    test_reference.createReference(symbol, 0);
+    assert.strictEqual(test_reference.referenceValue, symbol);
+  })();
+  test_reference.deleteReference();
+
+  (() => {
+    const symbol = test_reference.createSymbolFor('testSymFor');
+    test_reference.createReference(symbol, 1);
+    assert.strictEqual(test_reference.referenceValue, symbol);
+    assert.strictEqual(test_reference.referenceValue, Symbol.for('testSymFor'));
+  })();
+  test_reference.deleteReference();
+
+  (() => {
+    const symbol = test_reference.createSymbolForEmptyString();
+    test_reference.createReference(symbol, 0);
+    assert.strictEqual(test_reference.referenceValue, Symbol.for(''));
+  })();
+  test_reference.deleteReference();
+
+  (() => {
+    const symbol = test_reference.createSymbolForEmptyString();
+    test_reference.createReference(symbol, 1);
+    assert.strictEqual(test_reference.referenceValue, symbol);
+    assert.strictEqual(test_reference.referenceValue, Symbol.for(''));
+  })();
+  test_reference.deleteReference();
+
+  assert.throws(() => test_reference.createSymbolForIncorrectLength(),
+                /Invalid argument/);
+
+  (() => {
+    const value = test_reference.createExternal();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(typeof value, 'object');
+    test_reference.checkExternal(value);
+  })();
+  await gcUntil('External value without a finalizer',
+                () => (test_reference.finalizeCount === 0));
+
+  (() => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(typeof value, 'object');
+    test_reference.checkExternal(value);
+  })();
+  await gcUntil('External value with a finalizer',
+                () => (test_reference.finalizeCount === 1));
+
+  (() => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 0);
+    assert.strictEqual(test_reference.referenceValue, value);
+  })();
+  // Value should be GC'd because there is only a weak ref
+  await gcUntil('Weak reference',
+                () => (test_reference.referenceValue === undefined &&
+                test_reference.finalizeCount === 1));
+  test_reference.deleteReference();
+
+  (() => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 1);
+    assert.strictEqual(test_reference.referenceValue, value);
+  })();
+  // Value should NOT be GC'd because there is a strong ref
+  await gcUntil('Strong reference',
+                () => (test_reference.finalizeCount === 0));
+  test_reference.deleteReference();
+  await gcUntil('Strong reference (cont.d)',
+                () => (test_reference.finalizeCount === 1));
+
+  (() => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 1);
+  })();
+  // Value should NOT be GC'd because there is a strong ref
+  await gcUntil('Strong reference, increment then decrement to weak reference',
+                () => (test_reference.finalizeCount === 0));
+  assert.strictEqual(test_reference.incrementRefcount(), 2);
+  // Value should NOT be GC'd because there is a strong ref
+  await gcUntil(
+    'Strong reference, increment then decrement to weak reference (cont.d-1)',
+    () => (test_reference.finalizeCount === 0));
+  assert.strictEqual(test_reference.decrementRefcount(), 1);
+  // Value should NOT be GC'd because there is a strong ref
+  await gcUntil(
+    'Strong reference, increment then decrement to weak reference (cont.d-2)',
+    () => (test_reference.finalizeCount === 0));
+  assert.strictEqual(test_reference.decrementRefcount(), 0);
+  // Value should be GC'd because the ref is now weak!
+  await gcUntil(
+    'Strong reference, increment then decrement to weak reference (cont.d-3)',
+    () => (test_reference.finalizeCount === 1));
+  test_reference.deleteReference();
+  // Value was already GC'd
+  await gcUntil(
+    'Strong reference, increment then decrement to weak reference (cont.d-4)',
+    () => (test_reference.finalizeCount === 1));
+}
+runTests();
+
+// This test creates a napi_ref on an object that has
+// been wrapped by napi_wrap and for which the finalizer
+// for the wrap calls napi_delete_ref on that napi_ref.
+//
+// Since both the wrap and the reference use the same
+// object the finalizer for the wrap and reference
+// may run in the same gc and in any order.
+//
+// It does that to validate that napi_delete_ref can be
+// called before the finalizer has been run for the
+// reference (there is a finalizer behind the scenes even
+// though it cannot be passed to napi_create_reference).
+//
+// Since the order is not guaranteed, run the
+// test a number of times maximize the chance that we
+// get a run with the desired order for the test.
+//
+// 1000 reliably recreated the problem without the fix
+// required to ensure delete could be called before
+// the finalizer in manual testing.
+for (let i = 0; i < 1000; i++) {
+  const wrapObject = new Object();
+  test_reference.validateDeleteBeforeFinalize(wrapObject);
+  global.gc();
+}

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

@@ -0,0 +1,71 @@
+#include <assert.h>
+#include <js_native_api.h>
+#include <stdlib.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+static int test_value = 1;
+static int finalize_count = 0;
+
+static void FinalizeExternalCallJs(napi_env env, void* data, void* hint) {
+  int* actual_value = data;
+  NODE_API_ASSERT_RETURN_VOID(
+      env,
+      actual_value == &test_value,
+      "The correct pointer was passed to the finalizer");
+
+  napi_ref finalizer_ref = (napi_ref)hint;
+  napi_value js_finalizer;
+  napi_value recv;
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_get_reference_value(env, finalizer_ref, &js_finalizer));
+  NODE_API_CALL_RETURN_VOID(env, napi_get_global(env, &recv));
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_call_function(env, recv, js_finalizer, 0, NULL, NULL));
+  NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, finalizer_ref));
+}
+
+static napi_value CreateExternalWithJsFinalize(napi_env env,
+                                               napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value finalizer = args[0];
+  napi_valuetype finalizer_valuetype;
+  NODE_API_CALL(env, napi_typeof(env, finalizer, &finalizer_valuetype));
+  NODE_API_ASSERT(env,
+                  finalizer_valuetype == napi_function,
+                  "Wrong type of first argument");
+  napi_ref finalizer_ref;
+  NODE_API_CALL(env, napi_create_reference(env, finalizer, 1, &finalizer_ref));
+
+  napi_value result;
+  NODE_API_CALL(env,
+                napi_create_external(env,
+                                     &test_value,
+                                     FinalizeExternalCallJs,
+                                     finalizer_ref, /* finalize_hint */
+                                     &result));
+
+  finalize_count = 0;
+  return result;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NODE_API_PROPERTY("createExternalWithJsFinalize",
+                                CreateExternalWithJsFinalize),
+  };
+
+  NODE_API_CALL(
+      env,
+      napi_define_properties(env,
+                             exports,
+                             sizeof(descriptors) / sizeof(*descriptors),
+                             descriptors));
+
+  return exports;
+}
+EXTERN_C_END

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

@@ -0,0 +1,20 @@
+'use strict';
+// Flags: --expose-gc --force-node-api-uncaught-exceptions-policy
+
+const common = require('../../common');
+const binding = require(`./build/${common.buildType}/test_finalizer`);
+const assert = require('assert');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.throws(() => { throw err; }, /finalizer error/);
+}));
+
+(async function() {
+  {
+    binding.createExternalWithJsFinalize(
+      common.mustCall(() => {
+        throw new Error('finalizer error');
+      }));
+  }
+  global.gc();
+})().then(common.mustCall());

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

@@ -0,0 +1,252 @@
+#define NAPI_VERSION 9
+#include <assert.h>
+#include <js_native_api.h>
+#include <stdlib.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+static int test_value = 1;
+static int finalize_count = 0;
+static napi_ref test_reference = NULL;
+
+static napi_value GetFinalizeCount(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NODE_API_CALL(env, napi_create_int32(env, finalize_count, &result));
+  return result;
+}
+
+static void FinalizeExternal(napi_env env, void* data, void* hint) {
+  int *actual_value = data;
+  NODE_API_ASSERT_RETURN_VOID(env, actual_value == &test_value,
+      "The correct pointer was passed to the finalizer");
+  finalize_count++;
+}
+
+static napi_value CreateExternal(napi_env env, napi_callback_info info) {
+  int* data = &test_value;
+
+  napi_value result;
+  NODE_API_CALL(env,
+      napi_create_external(env,
+                           data,
+                           NULL, /* finalize_cb */
+                           NULL, /* finalize_hint */
+                           &result));
+
+  finalize_count = 0;
+  return result;
+}
+
+static napi_value CreateSymbol(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NODE_API_ASSERT(
+      env, argc == 1, "Expect one argument only (symbol description)");
+
+  napi_value result_symbol;
+
+  NODE_API_CALL(env, napi_create_symbol(env, args[0], &result_symbol));
+  return result_symbol;
+}
+
+static napi_value CreateSymbolFor(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+
+  char description[256];
+  size_t description_length;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NODE_API_ASSERT(
+      env, argc == 1, "Expect one argument only (symbol description)");
+
+  NODE_API_CALL(
+      env,
+      napi_get_value_string_utf8(
+          env, args[0], description, sizeof(description), &description_length));
+  NODE_API_ASSERT(env,
+                  description_length <= 255,
+                  "Cannot accommodate descriptions longer than 255 bytes");
+
+  napi_value result_symbol;
+
+  NODE_API_CALL(env,
+                node_api_symbol_for(
+                    env, description, description_length, &result_symbol));
+  return result_symbol;
+}
+
+static napi_value CreateSymbolForEmptyString(napi_env env, napi_callback_info info) {
+  napi_value result_symbol;
+  NODE_API_CALL(env, node_api_symbol_for(env, NULL, 0, &result_symbol));
+  return result_symbol;
+}
+
+static napi_value CreateSymbolForIncorrectLength(napi_env env, napi_callback_info info) {
+  napi_value result_symbol;
+  NODE_API_CALL(env, node_api_symbol_for(env, NULL, 5, &result_symbol));
+  return result_symbol;
+}
+
+static napi_value
+CreateExternalWithFinalize(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NODE_API_CALL(env,
+      napi_create_external(env,
+                           &test_value,
+                           FinalizeExternal,
+                           NULL, /* finalize_hint */
+                           &result));
+
+  finalize_count = 0;
+  return result;
+}
+
+static napi_value CheckExternal(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value arg;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
+
+  NODE_API_ASSERT(env, argc == 1, "Expected one argument.");
+
+  napi_valuetype argtype;
+  NODE_API_CALL(env, napi_typeof(env, arg, &argtype));
+
+  NODE_API_ASSERT(env, argtype == napi_external, "Expected an external value.");
+
+  void* data;
+  NODE_API_CALL(env, napi_get_value_external(env, arg, &data));
+
+  NODE_API_ASSERT(env, data != NULL && *(int*)data == test_value,
+      "An external data value of 1 was expected.");
+
+  return NULL;
+}
+
+static napi_value CreateReference(napi_env env, napi_callback_info info) {
+  NODE_API_ASSERT(env, test_reference == NULL,
+      "The test allows only one reference at a time.");
+
+  size_t argc = 2;
+  napi_value args[2];
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NODE_API_ASSERT(env, argc == 2, "Expected two arguments.");
+
+  uint32_t initial_refcount;
+  NODE_API_CALL(env, napi_get_value_uint32(env, args[1], &initial_refcount));
+
+  NODE_API_CALL(env,
+      napi_create_reference(env, args[0], initial_refcount, &test_reference));
+
+  NODE_API_ASSERT(env, test_reference != NULL,
+      "A reference should have been created.");
+
+  return NULL;
+}
+
+static napi_value DeleteReference(napi_env env, napi_callback_info info) {
+  NODE_API_ASSERT(env, test_reference != NULL,
+      "A reference must have been created.");
+
+  NODE_API_CALL(env, napi_delete_reference(env, test_reference));
+  test_reference = NULL;
+  return NULL;
+}
+
+static napi_value IncrementRefcount(napi_env env, napi_callback_info info) {
+  NODE_API_ASSERT(env, test_reference != NULL,
+      "A reference must have been created.");
+
+  uint32_t refcount;
+  NODE_API_CALL(env, napi_reference_ref(env, test_reference, &refcount));
+
+  napi_value result;
+  NODE_API_CALL(env, napi_create_uint32(env, refcount, &result));
+  return result;
+}
+
+static napi_value DecrementRefcount(napi_env env, napi_callback_info info) {
+  NODE_API_ASSERT(env, test_reference != NULL,
+      "A reference must have been created.");
+
+  uint32_t refcount;
+  NODE_API_CALL(env, napi_reference_unref(env, test_reference, &refcount));
+
+  napi_value result;
+  NODE_API_CALL(env, napi_create_uint32(env, refcount, &result));
+  return result;
+}
+
+static napi_value GetReferenceValue(napi_env env, napi_callback_info info) {
+  NODE_API_ASSERT(env, test_reference != NULL,
+      "A reference must have been created.");
+
+  napi_value result;
+  NODE_API_CALL(env, napi_get_reference_value(env, test_reference, &result));
+  return result;
+}
+
+static void DeleteBeforeFinalizeFinalizer(
+    napi_env env, void* finalize_data, void* finalize_hint) {
+  napi_ref* ref = (napi_ref*)finalize_data;
+  napi_value value;
+  assert(napi_get_reference_value(env, *ref, &value) == napi_ok);
+  assert(value == NULL);
+  napi_delete_reference(env, *ref);
+  free(ref);
+}
+
+static napi_value ValidateDeleteBeforeFinalize(napi_env env, napi_callback_info info) {
+  napi_value wrapObject;
+  size_t argc = 1;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &wrapObject, NULL, NULL));
+
+  napi_ref* ref_t = malloc(sizeof(napi_ref));
+  NODE_API_CALL(env,
+      napi_wrap(
+          env, wrapObject, ref_t, DeleteBeforeFinalizeFinalizer, NULL, NULL));
+
+  // Create a reference that will be eligible for collection at the same
+  // time as the wrapped object by passing in the same wrapObject.
+  // This means that the FinalizeOrderValidation callback may be run
+  // before the finalizer for the newly created reference (there is a finalizer
+  // behind the scenes even though it cannot be passed to napi_create_reference)
+  // The Finalizer for the wrap (which is different than the finalizer
+  // for the reference) calls napi_delete_reference validating that
+  // napi_delete_reference can be called before the finalizer for the
+  // reference runs.
+  NODE_API_CALL(env, napi_create_reference(env, wrapObject, 0, ref_t));
+  return wrapObject;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NODE_API_GETTER("finalizeCount", GetFinalizeCount),
+      DECLARE_NODE_API_PROPERTY("createExternal", CreateExternal),
+      DECLARE_NODE_API_PROPERTY("createExternalWithFinalize",
+                                CreateExternalWithFinalize),
+      DECLARE_NODE_API_PROPERTY("checkExternal", CheckExternal),
+      DECLARE_NODE_API_PROPERTY("createReference", CreateReference),
+      DECLARE_NODE_API_PROPERTY("createSymbol", CreateSymbol),
+      DECLARE_NODE_API_PROPERTY("createSymbolFor", CreateSymbolFor),
+      DECLARE_NODE_API_PROPERTY("createSymbolForEmptyString",
+                                CreateSymbolForEmptyString),
+      DECLARE_NODE_API_PROPERTY("createSymbolForIncorrectLength",
+                                CreateSymbolForIncorrectLength),
+      DECLARE_NODE_API_PROPERTY("deleteReference", DeleteReference),
+      DECLARE_NODE_API_PROPERTY("incrementRefcount", IncrementRefcount),
+      DECLARE_NODE_API_PROPERTY("decrementRefcount", DecrementRefcount),
+      DECLARE_NODE_API_GETTER("referenceValue", GetReferenceValue),
+      DECLARE_NODE_API_PROPERTY("validateDeleteBeforeFinalize",
+                                ValidateDeleteBeforeFinalize),
+  };
+
+  NODE_API_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+EXTERN_C_END