Upload Kmake

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

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

test/js-native-api/test_error/test.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const common = require('../../common');
+const test_error = require(`./build/${common.buildType}/test_error`);
+const assert = require('assert');
+const theError = new Error('Some error');
+const theTypeError = new TypeError('Some type error');
+const theSyntaxError = new SyntaxError('Some syntax error');
+const theRangeError = new RangeError('Some type error');
+const theReferenceError = new ReferenceError('Some reference error');
+const theURIError = new URIError('Some URI error');
+const theEvalError = new EvalError('Some eval error');
+
+class MyError extends Error { }
+const myError = new MyError('Some MyError');
+
+// Test that native error object is correctly classed
+assert.strictEqual(test_error.checkError(theError), true);
+
+// Test that native type error object is correctly classed
+assert.strictEqual(test_error.checkError(theTypeError), true);
+
+// Test that native syntax error object is correctly classed
+assert.strictEqual(test_error.checkError(theSyntaxError), true);
+
+// Test that native range error object is correctly classed
+assert.strictEqual(test_error.checkError(theRangeError), true);
+
+// Test that native reference error object is correctly classed
+assert.strictEqual(test_error.checkError(theReferenceError), true);
+
+// Test that native URI error object is correctly classed
+assert.strictEqual(test_error.checkError(theURIError), true);
+
+// Test that native eval error object is correctly classed
+assert.strictEqual(test_error.checkError(theEvalError), true);
+
+// Test that class derived from native error is correctly classed
+assert.strictEqual(test_error.checkError(myError), true);
+
+// Test that non-error object is correctly classed
+assert.strictEqual(test_error.checkError({}), false);
+
+// Test that non-error primitive is correctly classed
+assert.strictEqual(test_error.checkError('non-object'), false);
+
+assert.throws(() => {
+  test_error.throwExistingError();
+}, /^Error: existing error$/);
+
+assert.throws(() => {
+  test_error.throwError();
+}, /^Error: error$/);
+
+assert.throws(() => {
+  test_error.throwRangeError();
+}, /^RangeError: range error$/);
+
+assert.throws(() => {
+  test_error.throwTypeError();
+}, /^TypeError: type error$/);
+
+assert.throws(() => {
+  test_error.throwSyntaxError();
+}, /^SyntaxError: syntax error$/);
+
+[42, {}, [], Symbol('xyzzy'), true, 'ball', undefined, null, NaN]
+  .forEach((value) => assert.throws(
+    () => test_error.throwArbitrary(value),
+    (err) => {
+      assert.strictEqual(err, value);
+      return true;
+    },
+  ));
+
+assert.throws(
+  () => test_error.throwErrorCode(),
+  {
+    code: 'ERR_TEST_CODE',
+    message: 'Error [error]',
+  });
+
+assert.throws(
+  () => test_error.throwRangeErrorCode(),
+  {
+    code: 'ERR_TEST_CODE',
+    message: 'RangeError [range error]',
+  });
+
+assert.throws(
+  () => test_error.throwTypeErrorCode(),
+  {
+    code: 'ERR_TEST_CODE',
+    message: 'TypeError [type error]',
+  });
+
+assert.throws(
+  () => test_error.throwSyntaxErrorCode(),
+  {
+    code: 'ERR_TEST_CODE',
+    message: 'SyntaxError [syntax error]',
+  });
+
+let error = test_error.createError();
+assert.ok(error instanceof Error, 'expected error to be an instance of Error');
+assert.strictEqual(error.message, 'error');
+
+error = test_error.createRangeError();
+assert.ok(error instanceof RangeError,
+          'expected error to be an instance of RangeError');
+assert.strictEqual(error.message, 'range error');
+
+error = test_error.createTypeError();
+assert.ok(error instanceof TypeError,
+          'expected error to be an instance of TypeError');
+assert.strictEqual(error.message, 'type error');
+
+error = test_error.createSyntaxError();
+assert.ok(error instanceof SyntaxError,
+          'expected error to be an instance of SyntaxError');
+assert.strictEqual(error.message, 'syntax error');
+
+error = test_error.createErrorCode();
+assert.ok(error instanceof Error, 'expected error to be an instance of Error');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.message, 'Error [error]');
+assert.strictEqual(error.name, 'Error');
+
+error = test_error.createRangeErrorCode();
+assert.ok(error instanceof RangeError,
+          'expected error to be an instance of RangeError');
+assert.strictEqual(error.message, 'RangeError [range error]');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.name, 'RangeError');
+
+error = test_error.createTypeErrorCode();
+assert.ok(error instanceof TypeError,
+          'expected error to be an instance of TypeError');
+assert.strictEqual(error.message, 'TypeError [type error]');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.name, 'TypeError');
+
+error = test_error.createSyntaxErrorCode();
+assert.ok(error instanceof SyntaxError,
+          'expected error to be an instance of SyntaxError');
+assert.strictEqual(error.message, 'SyntaxError [syntax error]');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.name, 'SyntaxError');

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

@@ -0,0 +1,197 @@
+#define NAPI_VERSION 9
+#include <js_native_api.h>
+#include "../common.h"
+#include "../entry_point.h"
+
+static napi_value checkError(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));
+
+  bool r;
+  NODE_API_CALL(env, napi_is_error(env, args[0], &r));
+
+  napi_value result;
+  NODE_API_CALL(env, napi_get_boolean(env, r, &result));
+
+  return result;
+}
+
+static napi_value throwExistingError(napi_env env, napi_callback_info info) {
+  napi_value message;
+  napi_value error;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "existing error", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_error(env, NULL,  message, &error));
+  NODE_API_CALL(env, napi_throw(env, error));
+  return NULL;
+}
+
+static napi_value throwError(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env, napi_throw_error(env, NULL, "error"));
+  return NULL;
+}
+
+static napi_value throwRangeError(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env, napi_throw_range_error(env, NULL, "range error"));
+  return NULL;
+}
+
+static napi_value throwTypeError(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env, napi_throw_type_error(env, NULL, "type error"));
+  return NULL;
+}
+
+static napi_value throwSyntaxError(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env, node_api_throw_syntax_error(env, NULL, "syntax error"));
+  return NULL;
+}
+
+static napi_value throwErrorCode(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env, napi_throw_error(env, "ERR_TEST_CODE", "Error [error]"));
+  return NULL;
+}
+
+static napi_value throwRangeErrorCode(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env,
+      napi_throw_range_error(env, "ERR_TEST_CODE", "RangeError [range error]"));
+  return NULL;
+}
+
+static napi_value throwTypeErrorCode(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env,
+      napi_throw_type_error(env, "ERR_TEST_CODE", "TypeError [type error]"));
+  return NULL;
+}
+
+static napi_value throwSyntaxErrorCode(napi_env env, napi_callback_info info) {
+  NODE_API_CALL(env,
+      node_api_throw_syntax_error(env, "ERR_TEST_CODE", "SyntaxError [syntax error]"));
+  return NULL;
+}
+
+static napi_value createError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "error", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_error(env, NULL, message, &result));
+  return result;
+}
+
+static napi_value createRangeError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "range error", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_range_error(env, NULL, message, &result));
+  return result;
+}
+
+static napi_value createTypeError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "type error", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_type_error(env, NULL, message, &result));
+  return result;
+}
+
+static napi_value createSyntaxError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "syntax error", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, node_api_create_syntax_error(env, NULL, message, &result));
+  return result;
+}
+
+static napi_value createErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "Error [error]", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
+  NODE_API_CALL(env, napi_create_error(env, code, message, &result));
+  return result;
+}
+
+static napi_value createRangeErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NODE_API_CALL(env,
+      napi_create_string_utf8(
+          env, "RangeError [range error]", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
+  NODE_API_CALL(env, napi_create_range_error(env, code, message, &result));
+  return result;
+}
+
+static napi_value createTypeErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NODE_API_CALL(env,
+      napi_create_string_utf8(
+          env, "TypeError [type error]", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
+  NODE_API_CALL(env, napi_create_type_error(env, code, message, &result));
+  return result;
+}
+
+static napi_value createSyntaxErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NODE_API_CALL(env,
+      napi_create_string_utf8(
+          env, "SyntaxError [syntax error]", NAPI_AUTO_LENGTH, &message));
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
+  NODE_API_CALL(env, node_api_create_syntax_error(env, code, message, &result));
+  return result;
+}
+
+static napi_value throwArbitrary(napi_env env, napi_callback_info info) {
+  napi_value arbitrary;
+  size_t argc = 1;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, &arbitrary, NULL, NULL));
+  NODE_API_CALL(env, napi_throw(env, arbitrary));
+  return NULL;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NODE_API_PROPERTY("checkError", checkError),
+    DECLARE_NODE_API_PROPERTY("throwExistingError", throwExistingError),
+    DECLARE_NODE_API_PROPERTY("throwError", throwError),
+    DECLARE_NODE_API_PROPERTY("throwRangeError", throwRangeError),
+    DECLARE_NODE_API_PROPERTY("throwTypeError", throwTypeError),
+    DECLARE_NODE_API_PROPERTY("throwSyntaxError", throwSyntaxError),
+    DECLARE_NODE_API_PROPERTY("throwErrorCode", throwErrorCode),
+    DECLARE_NODE_API_PROPERTY("throwRangeErrorCode", throwRangeErrorCode),
+    DECLARE_NODE_API_PROPERTY("throwTypeErrorCode", throwTypeErrorCode),
+    DECLARE_NODE_API_PROPERTY("throwSyntaxErrorCode", throwSyntaxErrorCode),
+    DECLARE_NODE_API_PROPERTY("throwArbitrary", throwArbitrary),
+    DECLARE_NODE_API_PROPERTY("createError", createError),
+    DECLARE_NODE_API_PROPERTY("createRangeError", createRangeError),
+    DECLARE_NODE_API_PROPERTY("createTypeError", createTypeError),
+    DECLARE_NODE_API_PROPERTY("createSyntaxError", createSyntaxError),
+    DECLARE_NODE_API_PROPERTY("createErrorCode", createErrorCode),
+    DECLARE_NODE_API_PROPERTY("createRangeErrorCode", createRangeErrorCode),
+    DECLARE_NODE_API_PROPERTY("createTypeErrorCode", createTypeErrorCode),
+    DECLARE_NODE_API_PROPERTY("createSyntaxErrorCode", createSyntaxErrorCode),
+  };
+
+  NODE_API_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+EXTERN_C_END