From d8b891be2ef8ce31dc503c1352159ba3fc7dd27d Mon Sep 17 00:00:00 2001 From: Your Name Date: Tue, 25 Sep 2018 11:24:18 +0900 Subject: [PATCH 1/3] tests: add operator overloading tests in Number --- test/basic_types/number.cc | 30 ++++++++++++++++++++++++++++++ test/basic_types/number.js | 16 ++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/test/basic_types/number.cc b/test/basic_types/number.cc index 288460365..1f8f3bff7 100644 --- a/test/basic_types/number.cc +++ b/test/basic_types/number.cc @@ -41,6 +41,31 @@ Value MaxDouble(const CallbackInfo& info) { return Number::New(info.Env(), DBL_MAX); } +Value OperatorInt32(const CallbackInfo& info) { + Number jsValue = info[0].As(); + return Boolean::New(info.Env(), jsValue.Int32Value() == static_cast(jsValue)); +} + +Value OperatorUint32(const CallbackInfo& info) { + Number jsValue = info[0].As(); + return Boolean::New(info.Env(), jsValue.Uint32Value() == static_cast(jsValue)); +} + +Value OperatorInt64(const CallbackInfo& info) { + Number jsValue = info[0].As(); + return Boolean::New(info.Env(), jsValue.Int64Value() == static_cast(jsValue)); +} + +Value OperatorFloat(const CallbackInfo& info) { + Number jsValue = info[0].As(); + return Boolean::New(info.Env(), jsValue.FloatValue() == static_cast(jsValue)); +} + +Value OperatorDouble(const CallbackInfo& info) { + Number jsValue = info[0].As(); + return Boolean::New(info.Env(), jsValue.DoubleValue() == static_cast(jsValue)); +} + Object InitBasicTypesNumber(Env env) { Object exports = Object::New(env); @@ -53,6 +78,11 @@ Object InitBasicTypesNumber(Env env) { exports["maxFloat"] = Function::New(env, MaxFloat); exports["minDouble"] = Function::New(env, MinDouble); exports["maxDouble"] = Function::New(env, MaxDouble); + exports["operatorInt32"] = Function::New(env, OperatorInt32); + exports["operatorUint32"] = Function::New(env, OperatorUint32); + exports["operatorInt64"] = Function::New(env, OperatorInt64); + exports["operatorFloat"] = Function::New(env, OperatorFloat); + exports["operatorDouble"] = Function::New(env, OperatorDouble); return exports; } diff --git a/test/basic_types/number.js b/test/basic_types/number.js index df3d9820f..eaa4c67e8 100644 --- a/test/basic_types/number.js +++ b/test/basic_types/number.js @@ -80,4 +80,20 @@ function test(binding) { assert.strictEqual(0, binding.basic_types_number.toDouble(MIN_DOUBLE * MIN_DOUBLE)); assert.strictEqual(Infinity, binding.basic_types_number.toDouble(MAX_DOUBLE * MAX_DOUBLE)); } + + // Test for operator overloading + { + assert.strictEqual(binding.basic_types_number.operatorInt32(MIN_INT32), true); + assert.strictEqual(binding.basic_types_number.operatorInt32(MAX_INT32), true); + assert.strictEqual(binding.basic_types_number.operatorUint32(MIN_UINT32), true); + assert.strictEqual(binding.basic_types_number.operatorUint32(MAX_UINT32), true); + assert.strictEqual(binding.basic_types_number.operatorInt64(MIN_INT64), true); + assert.strictEqual(binding.basic_types_number.operatorInt64(MAX_INT64), true); + assert.strictEqual(binding.basic_types_number.operatorFloat(MIN_FLOAT), true); + assert.strictEqual(binding.basic_types_number.operatorFloat(MAX_FLOAT), true); + assert.strictEqual(binding.basic_types_number.operatorFloat(MAX_DOUBLE), true); + assert.strictEqual(binding.basic_types_number.operatorDouble(MIN_DOUBLE), true); + assert.strictEqual(binding.basic_types_number.operatorDouble(MAX_DOUBLE), true); + } + } From b1bd1b4600a817fc260ed99e4b88a54dbb913b97 Mon Sep 17 00:00:00 2001 From: Your Name Date: Thu, 27 Sep 2018 21:48:23 +0900 Subject: [PATCH 2/3] Added construction tests for Number --- test/basic_types/number.cc | 11 +++++++++++ test/basic_types/number.js | 17 +++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/test/basic_types/number.cc b/test/basic_types/number.cc index 1f8f3bff7..7c2cec0bd 100644 --- a/test/basic_types/number.cc +++ b/test/basic_types/number.cc @@ -66,6 +66,15 @@ Value OperatorDouble(const CallbackInfo& info) { return Boolean::New(info.Env(), jsValue.DoubleValue() == static_cast(jsValue)); } +Value CreateEmptyNumber(const CallbackInfo& info) { + Number* number = new Number(); + return Boolean::New(info.Env(), number->IsEmpty()); +} + +Value CreateNumberFromExistingValue(const CallbackInfo& info) { + return info[0].As(); +} + Object InitBasicTypesNumber(Env env) { Object exports = Object::New(env); @@ -83,6 +92,8 @@ Object InitBasicTypesNumber(Env env) { exports["operatorInt64"] = Function::New(env, OperatorInt64); exports["operatorFloat"] = Function::New(env, OperatorFloat); exports["operatorDouble"] = Function::New(env, OperatorDouble); + exports["createEmptyNumber"] = Function::New(env, CreateEmptyNumber); + exports["createNumberFromExistingValue"] = Function::New(env, CreateNumberFromExistingValue); return exports; } diff --git a/test/basic_types/number.js b/test/basic_types/number.js index eaa4c67e8..a7c66bbc3 100644 --- a/test/basic_types/number.js +++ b/test/basic_types/number.js @@ -96,4 +96,21 @@ function test(binding) { assert.strictEqual(binding.basic_types_number.operatorDouble(MAX_DOUBLE), true); } + // Construction test + { +    assert.strictEqual(binding.basic_types_number.createEmptyNumber(), true); +    randomRangeTestForInteger(MIN_INT32, MAX_INT32, binding.basic_types_number.createNumberFromExistingValue); +    assert.strictEqual(MIN_INT32, binding.basic_types_number.createNumberFromExistingValue(MIN_INT32)); +    assert.strictEqual(MAX_INT32, binding.basic_types_number.createNumberFromExistingValue(MAX_INT32)); +    randomRangeTestForInteger(MIN_UINT32, MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue); +    assert.strictEqual(MIN_UINT32, binding.basic_types_number.createNumberFromExistingValue(MIN_UINT32)); +    assert.strictEqual(MAX_UINT32, binding.basic_types_number.createNumberFromExistingValue(MAX_UINT32)); +    randomRangeTestForInteger(MIN_INT64, MAX_INT64, binding.basic_types_number.createNumberFromExistingValue); +    assert.strictEqual(MIN_INT64, binding.basic_types_number.createNumberFromExistingValue(MIN_INT64)); +    assert.strictEqual(MAX_INT64, binding.basic_types_number.createNumberFromExistingValue(MAX_INT64)); +    assert.strictEqual(MIN_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MIN_FLOAT)); +    assert.strictEqual(MAX_FLOAT, binding.basic_types_number.createNumberFromExistingValue(MAX_FLOAT)); +    assert.strictEqual(MIN_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MIN_DOUBLE)); +    assert.strictEqual(MAX_DOUBLE, binding.basic_types_number.createNumberFromExistingValue(MAX_DOUBLE)); + } } From fd04f57de0769b9fdd1f0e7538d96b1036e8d951 Mon Sep 17 00:00:00 2001 From: Your Name Date: Thu, 27 Sep 2018 21:50:23 +0900 Subject: [PATCH 3/3] Renamed variable name in Number tests --- test/basic_types/number.cc | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/test/basic_types/number.cc b/test/basic_types/number.cc index 7c2cec0bd..436d51918 100644 --- a/test/basic_types/number.cc +++ b/test/basic_types/number.cc @@ -42,28 +42,28 @@ Value MaxDouble(const CallbackInfo& info) { } Value OperatorInt32(const CallbackInfo& info) { - Number jsValue = info[0].As(); - return Boolean::New(info.Env(), jsValue.Int32Value() == static_cast(jsValue)); + Number number = info[0].As(); + return Boolean::New(info.Env(), number.Int32Value() == static_cast(number)); } Value OperatorUint32(const CallbackInfo& info) { - Number jsValue = info[0].As(); - return Boolean::New(info.Env(), jsValue.Uint32Value() == static_cast(jsValue)); + Number number = info[0].As(); + return Boolean::New(info.Env(), number.Uint32Value() == static_cast(number)); } Value OperatorInt64(const CallbackInfo& info) { - Number jsValue = info[0].As(); - return Boolean::New(info.Env(), jsValue.Int64Value() == static_cast(jsValue)); + Number number = info[0].As(); + return Boolean::New(info.Env(), number.Int64Value() == static_cast(number)); } Value OperatorFloat(const CallbackInfo& info) { - Number jsValue = info[0].As(); - return Boolean::New(info.Env(), jsValue.FloatValue() == static_cast(jsValue)); + Number number = info[0].As(); + return Boolean::New(info.Env(), number.FloatValue() == static_cast(number)); } Value OperatorDouble(const CallbackInfo& info) { - Number jsValue = info[0].As(); - return Boolean::New(info.Env(), jsValue.DoubleValue() == static_cast(jsValue)); + Number number = info[0].As(); + return Boolean::New(info.Env(), number.DoubleValue() == static_cast(number)); } Value CreateEmptyNumber(const CallbackInfo& info) {