Upload Kmake

test/js-native-api/8_passing_wrapped/8_passing_wrapped.cc

@@ -0,0 +1,61 @@
+#include <js_native_api.h>
+#include "../common.h"
+#include "../entry_point.h"
+#include "myobject.h"
+
+extern size_t finalize_count;
+
+static napi_value CreateObject(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, nullptr, nullptr));
+
+  napi_value instance;
+  NODE_API_CALL(env, MyObject::NewInstance(env, args[0], &instance));
+
+  return instance;
+}
+
+static napi_value Add(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NODE_API_CALL(env,
+      napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  MyObject* obj1;
+  NODE_API_CALL(env,
+      napi_unwrap(env, args[0], reinterpret_cast<void**>(&obj1)));
+
+  MyObject* obj2;
+  NODE_API_CALL(env,
+      napi_unwrap(env, args[1], reinterpret_cast<void**>(&obj2)));
+
+  napi_value sum;
+  NODE_API_CALL(env, napi_create_double(env, obj1->Val() + obj2->Val(), &sum));
+
+  return sum;
+}
+
+static napi_value FinalizeCount(napi_env env, napi_callback_info info) {
+  napi_value return_value;
+  NODE_API_CALL(env, napi_create_uint32(env, finalize_count, &return_value));
+  return return_value;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  MyObject::Init(env);
+
+  napi_property_descriptor desc[] = {
+    DECLARE_NODE_API_PROPERTY("createObject", CreateObject),
+    DECLARE_NODE_API_PROPERTY("add", Add),
+    DECLARE_NODE_API_PROPERTY("finalizeCount", FinalizeCount),
+  };
+
+  NODE_API_CALL(env,
+      napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc));
+
+  return exports;
+}
+EXTERN_C_END

test/js-native-api/8_passing_wrapped/binding.gyp

@@ -0,0 +1,11 @@
+{
+  "targets": [
+    {
+      "target_name": "8_passing_wrapped",
+      "sources": [
+        "8_passing_wrapped.cc",
+        "myobject.cc"
+      ]
+    }
+  ]
+}

test/js-native-api/8_passing_wrapped/myobject.cc

@@ -0,0 +1,80 @@
+#include "myobject.h"
+#include "../common.h"
+
+size_t finalize_count = 0;
+
+MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() {
+  finalize_count++;
+  napi_delete_reference(env_, wrapper_);
+}
+
+void MyObject::Destructor(
+  napi_env env, void* nativeObject, void* /*finalize_hint*/) {
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+}
+
+napi_ref MyObject::constructor;
+
+napi_status MyObject::Init(napi_env env) {
+  napi_status status;
+
+  napi_value cons;
+  status = napi_define_class(
+      env, "MyObject", -1, New, nullptr, 0, nullptr, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_create_reference(env, cons, 1, &constructor);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}
+
+napi_value MyObject::New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
+
+  MyObject* obj = new MyObject();
+
+  napi_valuetype valuetype;
+  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  if (valuetype == napi_undefined) {
+    obj->val_ = 0;
+  } else {
+    NODE_API_CALL(env, napi_get_value_double(env, args[0], &obj->val_));
+  }
+
+  obj->env_ = env;
+
+  // The below call to napi_wrap() must request a reference to the wrapped
+  // object via the out-parameter, because this ensures that we test the code
+  // path that deals with a reference that is destroyed from its own finalizer.
+  NODE_API_CALL(env,
+      napi_wrap(env, _this, obj, MyObject::Destructor,
+          nullptr /* finalize_hint */, &obj->wrapper_));
+
+  return _this;
+}
+
+napi_status MyObject::NewInstance(napi_env env,
+                                  napi_value arg,
+                                  napi_value* instance) {
+  napi_status status;
+
+  const int argc = 1;
+  napi_value argv[argc] = {arg};
+
+  napi_value cons;
+  status = napi_get_reference_value(env, constructor, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_new_instance(env, cons, argc, argv, instance);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}

test/js-native-api/8_passing_wrapped/myobject.h

@@ -0,0 +1,26 @@
+#ifndef TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_
+#define TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_
+
+#include <js_native_api.h>
+
+class MyObject {
+ public:
+  static napi_status Init(napi_env env);
+  static void Destructor(napi_env env, void* nativeObject, void* finalize_hint);
+  static napi_status NewInstance(napi_env env,
+                                 napi_value arg,
+                                 napi_value* instance);
+  double Val() const { return val_; }
+
+ private:
+  MyObject();
+  ~MyObject();
+
+  static napi_ref constructor;
+  static napi_value New(napi_env env, napi_callback_info info);
+  double val_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_JS_NATIVE_API_8_PASSING_WRAPPED_MYOBJECT_H_

test/js-native-api/8_passing_wrapped/test.js

@@ -0,0 +1,21 @@
+'use strict';
+// Flags: --expose-gc
+
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/8_passing_wrapped`);
+const { gcUntil } = require('../../common/gc');
+
+async function runTest() {
+  let obj1 = addon.createObject(10);
+  let obj2 = addon.createObject(20);
+  const result = addon.add(obj1, obj2);
+  assert.strictEqual(result, 30);
+
+  // Make sure the native destructor gets called.
+  obj1 = null;
+  obj2 = null;
+  await gcUntil('8_passing_wrapped',
+                () => (addon.finalizeCount() === 2));
+}
+runTest();