Upload Kmake

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

@@ -0,0 +1,10 @@
+{
+  "targets": [
+    {
+      "target_name": "test_promise",
+      "sources": [
+        "test_promise.c"
+      ]
+    }
+  ]
+}

test/js-native-api/test_promise/test.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const common = require('../../common');
+
+// This tests the promise-related n-api calls
+
+const assert = require('assert');
+const test_promise = require(`./build/${common.buildType}/test_promise`);
+
+// A resolution
+{
+  const expected_result = 42;
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result);
+    }),
+    common.mustNotCall());
+  test_promise.concludeCurrentPromise(expected_result, true);
+}
+
+// A rejection
+{
+  const expected_result = 'It\'s not you, it\'s me.';
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustNotCall(),
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result);
+    }));
+  test_promise.concludeCurrentPromise(expected_result, false);
+}
+
+// Chaining
+{
+  const expected_result = 'chained answer';
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result);
+    }),
+    common.mustNotCall());
+  test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
+}
+
+const promiseTypeTestPromise = test_promise.createPromise();
+assert.strictEqual(test_promise.isPromise(promiseTypeTestPromise), true);
+test_promise.concludeCurrentPromise(undefined, true);
+
+const rejectPromise = Promise.reject(-1);
+const expected_reason = -1;
+assert.strictEqual(test_promise.isPromise(rejectPromise), true);
+rejectPromise.catch((reason) => {
+  assert.strictEqual(reason, expected_reason);
+});
+
+assert.strictEqual(test_promise.isPromise(2.4), false);
+assert.strictEqual(test_promise.isPromise('I promise!'), false);
+assert.strictEqual(test_promise.isPromise(undefined), false);
+assert.strictEqual(test_promise.isPromise(null), false);
+assert.strictEqual(test_promise.isPromise({}), false);

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

@@ -0,0 +1,64 @@
+#include <js_native_api.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+napi_deferred deferred = NULL;
+
+static napi_value createPromise(napi_env env, napi_callback_info info) {
+  napi_value promise;
+
+  // We do not overwrite an existing deferred.
+  if (deferred != NULL) {
+    return NULL;
+  }
+
+  NODE_API_CALL(env, napi_create_promise(env, &deferred, &promise));
+
+  return promise;
+}
+
+static napi_value
+concludeCurrentPromise(napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  size_t argc = 2;
+  bool resolution;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NODE_API_CALL(env, napi_get_value_bool(env, argv[1], &resolution));
+  if (resolution) {
+    NODE_API_CALL(env, napi_resolve_deferred(env, deferred, argv[0]));
+  } else {
+    NODE_API_CALL(env, napi_reject_deferred(env, deferred, argv[0]));
+  }
+
+  deferred = NULL;
+
+  return NULL;
+}
+
+static napi_value isPromise(napi_env env, napi_callback_info info) {
+  napi_value promise, result;
+  size_t argc = 1;
+  bool is_promise;
+
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &promise, NULL, NULL));
+  NODE_API_CALL(env, napi_is_promise(env, promise, &is_promise));
+  NODE_API_CALL(env, napi_get_boolean(env, is_promise, &result));
+
+  return result;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NODE_API_PROPERTY("createPromise", createPromise),
+    DECLARE_NODE_API_PROPERTY("concludeCurrentPromise", concludeCurrentPromise),
+    DECLARE_NODE_API_PROPERTY("isPromise", isPromise),
+  };
+
+  NODE_API_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+EXTERN_C_END