Upload Kmake

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

@@ -0,0 +1,11 @@
+{
+  "targets": [
+    {
+      "target_name": "test_conversions",
+      "sources": [
+        "test_conversions.c",
+        "test_null.c",
+      ]
+    }
+  ]
+}

test/js-native-api/test_conversions/test.js

@@ -0,0 +1,218 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test = require(`./build/${common.buildType}/test_conversions`);
+
+const boolExpected = /boolean was expected/;
+const numberExpected = /number was expected/;
+const stringExpected = /string was expected/;
+
+const testSym = Symbol('test');
+
+assert.strictEqual(test.asBool(false), false);
+assert.strictEqual(test.asBool(true), true);
+assert.throws(() => test.asBool(undefined), boolExpected);
+assert.throws(() => test.asBool(null), boolExpected);
+assert.throws(() => test.asBool(Number.NaN), boolExpected);
+assert.throws(() => test.asBool(0), boolExpected);
+assert.throws(() => test.asBool(''), boolExpected);
+assert.throws(() => test.asBool('0'), boolExpected);
+assert.throws(() => test.asBool(1), boolExpected);
+assert.throws(() => test.asBool('1'), boolExpected);
+assert.throws(() => test.asBool('true'), boolExpected);
+assert.throws(() => test.asBool({}), boolExpected);
+assert.throws(() => test.asBool([]), boolExpected);
+assert.throws(() => test.asBool(testSym), boolExpected);
+
+[test.asInt32, test.asUInt32, test.asInt64].forEach((asInt) => {
+  assert.strictEqual(asInt(0), 0);
+  assert.strictEqual(asInt(1), 1);
+  assert.strictEqual(asInt(1.0), 1);
+  assert.strictEqual(asInt(1.1), 1);
+  assert.strictEqual(asInt(1.9), 1);
+  assert.strictEqual(asInt(0.9), 0);
+  assert.strictEqual(asInt(999.9), 999);
+  assert.strictEqual(asInt(Number.NaN), 0);
+  assert.throws(() => asInt(undefined), numberExpected);
+  assert.throws(() => asInt(null), numberExpected);
+  assert.throws(() => asInt(false), numberExpected);
+  assert.throws(() => asInt(''), numberExpected);
+  assert.throws(() => asInt('1'), numberExpected);
+  assert.throws(() => asInt({}), numberExpected);
+  assert.throws(() => asInt([]), numberExpected);
+  assert.throws(() => asInt(testSym), numberExpected);
+});
+
+assert.strictEqual(test.asInt32(-1), -1);
+assert.strictEqual(test.asInt64(-1), -1);
+assert.strictEqual(test.asUInt32(-1), Math.pow(2, 32) - 1);
+
+assert.strictEqual(test.asDouble(0), 0);
+assert.strictEqual(test.asDouble(1), 1);
+assert.strictEqual(test.asDouble(1.0), 1.0);
+assert.strictEqual(test.asDouble(1.1), 1.1);
+assert.strictEqual(test.asDouble(1.9), 1.9);
+assert.strictEqual(test.asDouble(0.9), 0.9);
+assert.strictEqual(test.asDouble(999.9), 999.9);
+assert.strictEqual(test.asDouble(-1), -1);
+assert.ok(Number.isNaN(test.asDouble(Number.NaN)));
+assert.throws(() => test.asDouble(undefined), numberExpected);
+assert.throws(() => test.asDouble(null), numberExpected);
+assert.throws(() => test.asDouble(false), numberExpected);
+assert.throws(() => test.asDouble(''), numberExpected);
+assert.throws(() => test.asDouble('1'), numberExpected);
+assert.throws(() => test.asDouble({}), numberExpected);
+assert.throws(() => test.asDouble([]), numberExpected);
+assert.throws(() => test.asDouble(testSym), numberExpected);
+
+assert.strictEqual(test.asString(''), '');
+assert.strictEqual(test.asString('test'), 'test');
+assert.throws(() => test.asString(undefined), stringExpected);
+assert.throws(() => test.asString(null), stringExpected);
+assert.throws(() => test.asString(false), stringExpected);
+assert.throws(() => test.asString(1), stringExpected);
+assert.throws(() => test.asString(1.1), stringExpected);
+assert.throws(() => test.asString(Number.NaN), stringExpected);
+assert.throws(() => test.asString({}), stringExpected);
+assert.throws(() => test.asString([]), stringExpected);
+assert.throws(() => test.asString(testSym), stringExpected);
+
+assert.strictEqual(test.toBool(true), true);
+assert.strictEqual(test.toBool(1), true);
+assert.strictEqual(test.toBool(-1), true);
+assert.strictEqual(test.toBool('true'), true);
+assert.strictEqual(test.toBool('false'), true);
+assert.strictEqual(test.toBool({}), true);
+assert.strictEqual(test.toBool([]), true);
+assert.strictEqual(test.toBool(testSym), true);
+assert.strictEqual(test.toBool(false), false);
+assert.strictEqual(test.toBool(undefined), false);
+assert.strictEqual(test.toBool(null), false);
+assert.strictEqual(test.toBool(0), false);
+assert.strictEqual(test.toBool(Number.NaN), false);
+assert.strictEqual(test.toBool(''), false);
+
+assert.strictEqual(test.toNumber(0), 0);
+assert.strictEqual(test.toNumber(1), 1);
+assert.strictEqual(test.toNumber(1.1), 1.1);
+assert.strictEqual(test.toNumber(-1), -1);
+assert.strictEqual(test.toNumber('0'), 0);
+assert.strictEqual(test.toNumber('1'), 1);
+assert.strictEqual(test.toNumber('1.1'), 1.1);
+assert.strictEqual(test.toNumber([]), 0);
+assert.strictEqual(test.toNumber(false), 0);
+assert.strictEqual(test.toNumber(null), 0);
+assert.strictEqual(test.toNumber(''), 0);
+assert.ok(Number.isNaN(test.toNumber(Number.NaN)));
+assert.ok(Number.isNaN(test.toNumber({})));
+assert.ok(Number.isNaN(test.toNumber(undefined)));
+assert.throws(() => test.toNumber(testSym), TypeError);
+
+assert.deepStrictEqual({}, test.toObject({}));
+assert.deepStrictEqual({ 'test': 1 }, test.toObject({ 'test': 1 }));
+assert.deepStrictEqual([], test.toObject([]));
+assert.deepStrictEqual([ 1, 2, 3 ], test.toObject([ 1, 2, 3 ]));
+assert.deepStrictEqual(new Boolean(false), test.toObject(false));
+assert.deepStrictEqual(new Boolean(true), test.toObject(true));
+assert.deepStrictEqual(new String(''), test.toObject(''));
+assert.deepStrictEqual(new Number(0), test.toObject(0));
+assert.deepStrictEqual(new Number(Number.NaN), test.toObject(Number.NaN));
+assert.deepStrictEqual(new Object(testSym), test.toObject(testSym));
+assert.notStrictEqual(test.toObject(false), false);
+assert.notStrictEqual(test.toObject(true), true);
+assert.notStrictEqual(test.toObject(''), '');
+assert.notStrictEqual(test.toObject(0), 0);
+assert.ok(!Number.isNaN(test.toObject(Number.NaN)));
+
+assert.strictEqual(test.toString(''), '');
+assert.strictEqual(test.toString('test'), 'test');
+assert.strictEqual(test.toString(undefined), 'undefined');
+assert.strictEqual(test.toString(null), 'null');
+assert.strictEqual(test.toString(false), 'false');
+assert.strictEqual(test.toString(true), 'true');
+assert.strictEqual(test.toString(0), '0');
+assert.strictEqual(test.toString(1.1), '1.1');
+assert.strictEqual(test.toString(Number.NaN), 'NaN');
+assert.strictEqual(test.toString({}), '[object Object]');
+assert.strictEqual(test.toString({ toString: () => 'test' }), 'test');
+assert.strictEqual(test.toString([]), '');
+assert.strictEqual(test.toString([ 1, 2, 3 ]), '1,2,3');
+assert.throws(() => test.toString(testSym), TypeError);
+
+assert.deepStrictEqual(test.testNull.getValueBool(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'A boolean was expected',
+});
+
+assert.deepStrictEqual(test.testNull.getValueInt32(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'A number was expected',
+});
+
+assert.deepStrictEqual(test.testNull.getValueUint32(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'A number was expected',
+});
+
+assert.deepStrictEqual(test.testNull.getValueInt64(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'A number was expected',
+});
+
+
+assert.deepStrictEqual(test.testNull.getValueDouble(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'A number was expected',
+});
+
+assert.deepStrictEqual(test.testNull.coerceToBool(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'napi_ok',
+});
+
+assert.deepStrictEqual(test.testNull.coerceToObject(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'napi_ok',
+});
+
+assert.deepStrictEqual(test.testNull.coerceToString(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  resultIsNull: 'Invalid argument',
+  inputTypeCheck: 'napi_ok',
+});
+
+assert.deepStrictEqual(test.testNull.getValueStringUtf8(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  wrongTypeIn: 'A string was expected',
+  bufAndOutLengthIsNull: 'Invalid argument',
+});
+
+assert.deepStrictEqual(test.testNull.getValueStringLatin1(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  wrongTypeIn: 'A string was expected',
+  bufAndOutLengthIsNull: 'Invalid argument',
+});
+
+assert.deepStrictEqual(test.testNull.getValueStringUtf16(), {
+  envIsNull: 'Invalid argument',
+  valueIsNull: 'Invalid argument',
+  wrongTypeIn: 'A string was expected',
+  bufAndOutLengthIsNull: 'Invalid argument',
+});

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

@@ -0,0 +1,158 @@
+#include <js_native_api.h>
+#include "../common.h"
+#include "../entry_point.h"
+#include "test_null.h"
+
+static napi_value AsBool(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 value;
+  NODE_API_CALL(env, napi_get_value_bool(env, args[0], &value));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_get_boolean(env, value, &output));
+
+  return output;
+}
+
+static napi_value AsInt32(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));
+
+  int32_t value;
+  NODE_API_CALL(env, napi_get_value_int32(env, args[0], &value));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_create_int32(env, value, &output));
+
+  return output;
+}
+
+static napi_value AsUInt32(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));
+
+  uint32_t value;
+  NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &value));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_create_uint32(env, value, &output));
+
+  return output;
+}
+
+static napi_value AsInt64(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));
+
+  int64_t value;
+  NODE_API_CALL(env, napi_get_value_int64(env, args[0], &value));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_create_int64(env, (double)value, &output));
+
+  return output;
+}
+
+static napi_value AsDouble(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));
+
+  double value;
+  NODE_API_CALL(env, napi_get_value_double(env, args[0], &value));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_create_double(env, value, &output));
+
+  return output;
+}
+
+static napi_value AsString(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));
+
+  char value[100];
+  NODE_API_CALL(env,
+    napi_get_value_string_utf8(env, args[0], value, sizeof(value), NULL));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_create_string_utf8(
+      env, value, NAPI_AUTO_LENGTH, &output));
+
+  return output;
+}
+
+static napi_value ToBool(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));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_coerce_to_bool(env, args[0], &output));
+
+  return output;
+}
+
+static napi_value ToNumber(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));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_coerce_to_number(env, args[0], &output));
+
+  return output;
+}
+
+static napi_value ToObject(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));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_coerce_to_object(env, args[0], &output));
+
+  return output;
+}
+
+static napi_value ToString(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));
+
+  napi_value output;
+  NODE_API_CALL(env, napi_coerce_to_string(env, args[0], &output));
+
+  return output;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NODE_API_PROPERTY("asBool", AsBool),
+    DECLARE_NODE_API_PROPERTY("asInt32", AsInt32),
+    DECLARE_NODE_API_PROPERTY("asUInt32", AsUInt32),
+    DECLARE_NODE_API_PROPERTY("asInt64", AsInt64),
+    DECLARE_NODE_API_PROPERTY("asDouble", AsDouble),
+    DECLARE_NODE_API_PROPERTY("asString", AsString),
+    DECLARE_NODE_API_PROPERTY("toBool", ToBool),
+    DECLARE_NODE_API_PROPERTY("toNumber", ToNumber),
+    DECLARE_NODE_API_PROPERTY("toObject", ToObject),
+    DECLARE_NODE_API_PROPERTY("toString", ToString),
+  };
+
+  NODE_API_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  init_test_null(env, exports);
+
+  return exports;
+}
+EXTERN_C_END

test/js-native-api/test_conversions/test_null.c

@@ -0,0 +1,102 @@
+#include <js_native_api.h>
+
+#include "../common.h"
+#include "test_null.h"
+
+#define GEN_NULL_CHECK_BINDING(binding_name, output_type, api)            \
+  static napi_value binding_name(napi_env env, napi_callback_info info) { \
+    napi_value return_value;                                              \
+    output_type result;                                                   \
+    NODE_API_CALL(env, napi_create_object(env, &return_value));           \
+    add_returned_status(env,                                              \
+                        "envIsNull",                                      \
+                        return_value,                                     \
+                        "Invalid argument",                               \
+                        napi_invalid_arg,                                 \
+                        api(NULL, return_value, &result));                \
+    api(env, NULL, &result);                                              \
+    add_last_status(env, "valueIsNull", return_value);                    \
+    api(env, return_value, NULL);                                         \
+    add_last_status(env, "resultIsNull", return_value);                   \
+    api(env, return_value, &result);                                      \
+    add_last_status(env, "inputTypeCheck", return_value);                 \
+    return return_value;                                                  \
+  }
+
+GEN_NULL_CHECK_BINDING(GetValueBool, bool, napi_get_value_bool)
+GEN_NULL_CHECK_BINDING(GetValueInt32, int32_t, napi_get_value_int32)
+GEN_NULL_CHECK_BINDING(GetValueUint32, uint32_t, napi_get_value_uint32)
+GEN_NULL_CHECK_BINDING(GetValueInt64, int64_t, napi_get_value_int64)
+GEN_NULL_CHECK_BINDING(GetValueDouble, double, napi_get_value_double)
+GEN_NULL_CHECK_BINDING(CoerceToBool, napi_value, napi_coerce_to_bool)
+GEN_NULL_CHECK_BINDING(CoerceToObject, napi_value, napi_coerce_to_object)
+GEN_NULL_CHECK_BINDING(CoerceToString, napi_value, napi_coerce_to_string)
+
+#define GEN_NULL_CHECK_STRING_BINDING(binding_name, arg_type, api)         \
+  static napi_value binding_name(napi_env env, napi_callback_info info) {  \
+    napi_value return_value;                                               \
+    NODE_API_CALL(env, napi_create_object(env, &return_value));            \
+    arg_type buf1[4];                                                      \
+    size_t length1 = 3;                                                    \
+    add_returned_status(env,                                               \
+                        "envIsNull",                                       \
+                        return_value,                                      \
+                        "Invalid argument",                                \
+                        napi_invalid_arg,                                  \
+                        api(NULL, return_value, buf1, length1, &length1)); \
+    arg_type buf2[4];                                                      \
+    size_t length2 = 3;                                                    \
+    api(env, NULL, buf2, length2, &length2);                               \
+    add_last_status(env, "valueIsNull", return_value);                     \
+    api(env, return_value, NULL, 3, NULL);                                 \
+    add_last_status(env, "wrongTypeIn", return_value);                     \
+    napi_value string;                                                     \
+    NODE_API_CALL(env,                                                     \
+              napi_create_string_utf8(env,                                 \
+                                      "Something",                         \
+                                      NAPI_AUTO_LENGTH,                    \
+                                      &string));                           \
+    api(env, string, NULL, 3, NULL);                                       \
+    add_last_status(env, "bufAndOutLengthIsNull", return_value);           \
+    return return_value;                                                   \
+  }
+
+GEN_NULL_CHECK_STRING_BINDING(GetValueStringUtf8,
+                              char,
+                              napi_get_value_string_utf8)
+GEN_NULL_CHECK_STRING_BINDING(GetValueStringLatin1,
+                              char,
+                              napi_get_value_string_latin1)
+GEN_NULL_CHECK_STRING_BINDING(GetValueStringUtf16,
+                              char16_t,
+                              napi_get_value_string_utf16)
+
+void init_test_null(napi_env env, napi_value exports) {
+  napi_value test_null;
+
+  const napi_property_descriptor test_null_props[] = {
+    DECLARE_NODE_API_PROPERTY("getValueBool", GetValueBool),
+    DECLARE_NODE_API_PROPERTY("getValueInt32", GetValueInt32),
+    DECLARE_NODE_API_PROPERTY("getValueUint32", GetValueUint32),
+    DECLARE_NODE_API_PROPERTY("getValueInt64", GetValueInt64),
+    DECLARE_NODE_API_PROPERTY("getValueDouble", GetValueDouble),
+    DECLARE_NODE_API_PROPERTY("coerceToBool", CoerceToBool),
+    DECLARE_NODE_API_PROPERTY("coerceToObject", CoerceToObject),
+    DECLARE_NODE_API_PROPERTY("coerceToString", CoerceToString),
+    DECLARE_NODE_API_PROPERTY("getValueStringUtf8", GetValueStringUtf8),
+    DECLARE_NODE_API_PROPERTY("getValueStringLatin1", GetValueStringLatin1),
+    DECLARE_NODE_API_PROPERTY("getValueStringUtf16", GetValueStringUtf16),
+  };
+
+  NODE_API_CALL_RETURN_VOID(env, napi_create_object(env, &test_null));
+  NODE_API_CALL_RETURN_VOID(env, napi_define_properties(
+      env, test_null, sizeof(test_null_props) / sizeof(*test_null_props),
+      test_null_props));
+
+  const napi_property_descriptor test_null_set = {
+    "testNull", NULL, NULL, NULL, NULL, test_null, napi_enumerable, NULL
+  };
+
+  NODE_API_CALL_RETURN_VOID(env,
+      napi_define_properties(env, exports, 1, &test_null_set));
+}

test/js-native-api/test_conversions/test_null.h

@@ -0,0 +1,8 @@
+#ifndef TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_
+#define TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_
+
+#include <js_native_api.h>
+
+void init_test_null(napi_env env, napi_value exports);
+
+#endif  // TEST_JS_NATIVE_API_TEST_CONVERSIONS_TEST_NULL_H_