Upload Kmake

test/js-native-api/7_factory_wrap/7_factory_wrap.cc

@@ -0,0 +1,32 @@
+#include <js_native_api.h>
+#include "../common.h"
+#include "../entry_point.h"
+#include "myobject.h"
+
+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;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  NODE_API_CALL(env, MyObject::Init(env));
+
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NODE_API_GETTER("finalizeCount", MyObject::GetFinalizeCount),
+    DECLARE_NODE_API_PROPERTY("createObject", CreateObject),
+  };
+
+  NODE_API_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+EXTERN_C_END

test/js-native-api/7_factory_wrap/binding.gyp

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

test/js-native-api/7_factory_wrap/myobject.cc

@@ -0,0 +1,101 @@
+#include "myobject.h"
+#include "../common.h"
+
+static int finalize_count = 0;
+
+MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); }
+
+void MyObject::Destructor(napi_env env,
+                          void* nativeObject,
+                          void* /*finalize_hint*/) {
+  ++finalize_count;
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+}
+
+napi_value MyObject::GetFinalizeCount(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NODE_API_CALL(env, napi_create_int32(env, finalize_count, &result));
+  return result;
+}
+
+napi_ref MyObject::constructor;
+
+napi_status MyObject::Init(napi_env env) {
+  napi_status status;
+  napi_property_descriptor properties[] = {
+    DECLARE_NODE_API_PROPERTY("plusOne", PlusOne),
+  };
+
+  napi_value cons;
+  status = napi_define_class(
+      env, "MyObject", -1, New, nullptr, 1, properties, &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));
+
+  napi_valuetype valuetype;
+  NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  MyObject* obj = new MyObject();
+
+  if (valuetype == napi_undefined) {
+    obj->counter_ = 0;
+  } else {
+    NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &obj->counter_));
+  }
+
+  obj->env_ = env;
+  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;
+}
+
+napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NODE_API_CALL(env,
+      napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+
+  MyObject* obj;
+  NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
+
+  obj->counter_ += 1;
+
+  napi_value num;
+  NODE_API_CALL(env, napi_create_uint32(env, obj->counter_, &num));
+
+  return num;
+}

test/js-native-api/7_factory_wrap/myobject.h

@@ -0,0 +1,27 @@
+#ifndef TEST_JS_NATIVE_API_7_FACTORY_WRAP_MYOBJECT_H_
+#define TEST_JS_NATIVE_API_7_FACTORY_WRAP_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_value GetFinalizeCount(napi_env env, napi_callback_info info);
+  static napi_status NewInstance(napi_env env,
+                                 napi_value arg,
+                                 napi_value* instance);
+
+ private:
+  MyObject();
+  ~MyObject();
+
+  static napi_ref constructor;
+  static napi_value New(napi_env env, napi_callback_info info);
+  static napi_value PlusOne(napi_env env, napi_callback_info info);
+  uint32_t counter_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_JS_NATIVE_API_7_FACTORY_WRAP_MYOBJECT_H_

test/js-native-api/7_factory_wrap/test.js

@@ -0,0 +1,27 @@
+'use strict';
+// Flags: --expose-gc
+
+const common = require('../../common');
+const assert = require('assert');
+const test = require(`./build/${common.buildType}/7_factory_wrap`);
+const { gcUntil } = require('../../common/gc');
+
+assert.strictEqual(test.finalizeCount, 0);
+async function runGCTests() {
+  (() => {
+    const obj = test.createObject(10);
+    assert.strictEqual(obj.plusOne(), 11);
+    assert.strictEqual(obj.plusOne(), 12);
+    assert.strictEqual(obj.plusOne(), 13);
+  })();
+  await gcUntil('test 1', () => (test.finalizeCount === 1));
+
+  (() => {
+    const obj2 = test.createObject(20);
+    assert.strictEqual(obj2.plusOne(), 21);
+    assert.strictEqual(obj2.plusOne(), 22);
+    assert.strictEqual(obj2.plusOne(), 23);
+  })();
+  await gcUntil('test 2', () => (test.finalizeCount === 2));
+}
+runGCTests();