feat: port test_instance_data to CTS

Author: bavulapati

PORTING.md

@@ -60,7 +60,7 @@ Tests covering the engine-specific part of Node-API, defined in `js_native_api.h
 | `test_function`              | Ported ✅  | Medium     |
 | `test_general`               | Not ported | Hard       |
 | `test_handle_scope`          | Ported ✅  | Easy       |
-| `test_instance_data`         | Not ported | Medium     |
+| `test_instance_data`         | Ported ✅  | Medium     |
 | `test_new_target`            | Ported ✅  | Easy       |
 | `test_number`                | Ported ✅  | Easy       |
 | `test_object`                | Not ported | Hard       |

tests/js-native-api/test_instance_data/CMakeLists.txt

@@ -0,0 +1 @@
+add_node_api_cts_addon(test_instance_data test_instance_data.c)

tests/js-native-api/test_instance_data/test.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const test_instance_data = loadAddon('test_instance_data');
+
+// The addon seeds its instance data with 41, so seeing 42 here proves the
+// binding read back the very data the addon set at init.
+assert.strictEqual(test_instance_data.increment(), 42);
+
+// Instance data is reachable from a finalizer too: the JS callback invoked
+// below is held in a reference stored in that data.
+let finalizerCalled = false;
+test_instance_data.objectWithFinalizer(mustCall(() => {
+  finalizerCalled = true;
+}));
+
+await gcUntil('instance data finalizer', () => finalizerCalled);

tests/js-native-api/test_instance_data/testInstanceDataTeardown.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// The delete hook passed to napi_set_instance_data only runs when the
+// environment goes away, so observing it takes a child process. This is the
+// main-thread environment; testInstanceDataWorker.js covers a secondary one.
+if (!runtimeFeatures.spawn) {
+  skipTest();
+}
+
+const result = await spawnTest('testInstanceDataTeardown_child.mjs');
+
+assert.strictEqual(
+  result.status,
+  0,
+  `child exited with status ${result.status}; stderr:\n${result.stderr}`,
+);
+assert.strictEqual(
+  result.stdout.split(/\r\n?|\n/)[0],
+  'deleting addon data',
+);

tests/js-native-api/test_instance_data/testInstanceDataTeardown_child.mjs

@@ -0,0 +1,6 @@
+// Child of testInstanceDataTeardown.js: arms the addon to print from its
+// instance-data delete hook, then exits so the hook runs at environment
+// teardown and the parent can read the line off stdout.
+const test_instance_data = loadAddon('test_instance_data');
+
+test_instance_data.setPrintOnDelete();

tests/js-native-api/test_instance_data/testInstanceDataWorker.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// Upstream's worker variant: the same body in a secondary environment, which
+// covers instance data being per-environment and the delete hook running when
+// that environment is torn down while the process keeps going. A conformant
+// runtime looks the same as the main-thread run, so the value here is in
+// exercising the secondary-environment path at all.
+if (!runtimeFeatures.spawn || !runtimeFeatures.worker) {
+  skipTest();
+}
+
+const result = await spawnTest('testInstanceDataWorker_child.mjs', { worker: true });
+
+assert.strictEqual(
+  result.status,
+  0,
+  `child exited with status ${result.status}; stderr:\n${result.stderr}`,
+);
+assert.strictEqual(
+  result.stdout.split(/\r\n?|\n/)[0],
+  'deleting addon data',
+);

tests/js-native-api/test_instance_data/testInstanceDataWorker_child.mjs

@@ -0,0 +1,20 @@
+// Child of testInstanceDataWorker.js, run in a worker: a secondary Node-API
+// environment. Runs the same body as test.js does on the main thread, since
+// that is what the secondary environment has to reproduce.
+
+const test_instance_data = loadAddon('test_instance_data');
+
+// Instance data is per-environment, so it is seeded at 41 here as well rather
+// than continuing from another environment's count.
+assert.strictEqual(test_instance_data.increment(), 42);
+
+let finalizerCalled = false;
+test_instance_data.objectWithFinalizer(mustCall(() => {
+  finalizerCalled = true;
+}));
+
+await gcUntil('instance data finalizer in worker', () => finalizerCalled);
+
+// Arm the delete hook so it prints when this environment - not the whole
+// process - is torn down.
+test_instance_data.setPrintOnDelete();

tests/js-native-api/test_instance_data/test_instance_data.c

@@ -0,0 +1,96 @@
+#include <js_native_api.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+typedef struct {
+  size_t value;
+  bool print;
+  napi_ref js_cb_ref;
+} AddonData;
+
+static napi_value Increment(napi_env env, napi_callback_info info) {
+  AddonData* data;
+  napi_value result;
+
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_CALL(env, napi_create_uint32(env, ++data->value, &result));
+
+  return result;
+}
+
+static void DeleteAddonData(napi_env env, void* raw_data, void* hint) {
+  AddonData* data = raw_data;
+  if (data->print) {
+    printf("deleting addon data\n");
+  }
+  if (data->js_cb_ref != NULL) {
+    NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref));
+  }
+  free(data);
+}
+
+static napi_value SetPrintOnDelete(napi_env env, napi_callback_info info) {
+  AddonData* data;
+
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  data->print = true;
+
+  return NULL;
+}
+
+static void TestFinalizer(napi_env env, void* raw_data, void* hint) {
+  (void) raw_data;
+  (void) hint;
+
+  AddonData* data;
+  NODE_API_CALL_RETURN_VOID(env, napi_get_instance_data(env, (void**)&data));
+  napi_value js_cb, undefined;
+  NODE_API_CALL_RETURN_VOID(env,
+      napi_get_reference_value(env, data->js_cb_ref, &js_cb));
+  NODE_API_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
+  NODE_API_CALL_RETURN_VOID(env,
+      napi_call_function(env, undefined, js_cb, 0, NULL, NULL));
+  NODE_API_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref));
+  data->js_cb_ref = NULL;
+}
+
+static napi_value ObjectWithFinalizer(napi_env env, napi_callback_info info) {
+  AddonData* data;
+  napi_value result, js_cb;
+  size_t argc = 1;
+
+  NODE_API_CALL(env, napi_get_instance_data(env, (void**)&data));
+  NODE_API_ASSERT(env, data->js_cb_ref == NULL, "reference must be NULL");
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL));
+  NODE_API_CALL(env, napi_create_object(env, &result));
+  NODE_API_CALL(env,
+      napi_add_finalizer(env, result, NULL, TestFinalizer, NULL, NULL));
+  NODE_API_CALL(env, napi_create_reference(env, js_cb, 1, &data->js_cb_ref));
+
+  return result;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  AddonData* data = malloc(sizeof(*data));
+  data->value = 41;
+  data->print = false;
+  data->js_cb_ref = NULL;
+
+  NODE_API_CALL(env, napi_set_instance_data(env, data, DeleteAddonData, NULL));
+
+  napi_property_descriptor props[] = {
+    DECLARE_NODE_API_PROPERTY("increment", Increment),
+    DECLARE_NODE_API_PROPERTY("setPrintOnDelete", SetPrintOnDelete),
+    DECLARE_NODE_API_PROPERTY("objectWithFinalizer", ObjectWithFinalizer),
+  };
+
+  NODE_API_CALL(env,
+      napi_define_properties(
+          env, exports, sizeof(props) / sizeof(*props), props));
+
+  return exports;
+}
+EXTERN_C_END