GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — n-api: add more `int64_t` tests · nodejs/node@07a6770

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

doc/api
- n-api.md
src
- node_api.cc
test/addons-napi/test_number
- test.js

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎doc/api/n-api.md‎`

Copy file name to clipboardExpand all lines: doc/api/n-api.md

+20-7Lines changed: 20 additions & 7 deletions

Display the source diff
Display the rich diff

Original file line number	Diff line number	Diff line change
`@@ -1808,13 +1808,17 @@ napi_status napi_get_value_int32(napi_env env,`
`1808`	`1808`	- `[out] result`: C int32 primitive equivalent of the given JavaScript Number.
`1809`	`1809`
`1810`	`1810`	Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
`1811`		-is passed in `napi_number_expected .
	`1811`	+is passed in `napi_number_expected`.
`1812`	`1812`
`1813`	`1813`	`This API returns the C int32 primitive equivalent`
`1814`		`-of the given JavaScript Number. If the number exceeds the range of the`
`1815`		`-32 bit integer, then the result is truncated to the equivalent of the`
`1816`		`-bottom 32 bits. This can result in a large positive number becoming`
`1817`		`-a negative number if the value is > 2^31 -1.`
	`1814`	`+of the given JavaScript Number.`
	`1815`	`+`
	`1816`	`+If the number exceeds the range of the 32 bit integer, then the result is`
	`1817`	`+truncated to the equivalent of the bottom 32 bits. This can result in a large`
	`1818`	`+positive number becoming a negative number if the value is > 2^31 -1.`
	`1819`	`+`
	`1820`	`+Non-finite number values (NaN, positive infinity, or negative infinity) set the`
	`1821`	`+result to zero.`
`1818`	`1822`
`1819`	`1823`	`#### napi_get_value_int64`
`1820`	`1824`	`<!-- YAML`
`@@ -1833,8 +1837,17 @@ napi_status napi_get_value_int64(napi_env env,`
`1833`	`1837`	Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
`1834`	`1838`	is passed in it returns `napi_number_expected`.
`1835`	`1839`
`1836`		`-This API returns the C int64 primitive equivalent of the given`
`1837`		`-JavaScript Number.`
	`1840`	`+This API returns the C int64 primitive equivalent of the given JavaScript`
	`1841`	`+Number.`
	`1842`	`+`
	`1843`	`+Number values outside the range of`
	`1844`	+[`Number.MIN_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.min_safe_integer)
	`1845`	`+-(2^53 - 1) -`
	`1846`	+[`Number.MAX_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.max_safe_integer)
	`1847`	`+(2^53 - 1) will lose precision.`
	`1848`	`+`
	`1849`	`+Non-finite number values (NaN, positive infinity, or negative infinity) set the`
	`1850`	`+result to zero.`
`1838`	`1851`
`1839`	`1852`	`#### napi_get_value_string_latin1`
`1840`	`1853`	`<!-- YAML`

Collapse file

`‎src/node_api.cc‎`

Copy file name to clipboardExpand all lines: src/node_api.cc

+6-5Lines changed: 6 additions & 5 deletions

Original file line number	Diff line number	Diff line change
`@@ -2197,15 +2197,16 @@ napi_status napi_get_value_int64(napi_env env,`
`2197`	`2197`
`2198`	`2198`	`RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);`
`2199`	`2199`
`2200`		`- // v8::Value::IntegerValue() converts NaN to INT64_MIN, inconsistent with`
`2201`		`- // v8::Value::Int32Value() that converts NaN to 0. So special-case NaN here.`
	`2200`	`+ // v8::Value::IntegerValue() converts NaN, +Inf, and -Inf to INT64_MIN,`
	`2201`	`+ // inconsistent with v8::Value::Int32Value() which converts those values to 0.`
	`2202`	`+ // Special-case all non-finite values to match that behavior.`
`2202`	`2203`	`double doubleValue = val.As<v8::Number>()->Value();`
`2203`		`- if (std::isnan(doubleValue)) {`
`2204`		`- *result = 0;`
`2205`		`- } else {`
	`2204`	`+ if (std::isfinite(doubleValue)) {`
`2206`	`2205`	`// Empty context: https://github.com/nodejs/node/issues/14379`
`2207`	`2206`	`v8::Local<v8::Context> context;`
`2208`	`2207`	`*result = val->IntegerValue(context).FromJust();`
	`2208`	`+ } else {`
	`2209`	`+ *result = 0;`
`2209`	`2210`	`}`
`2210`	`2211`
`2211`	`2212`	`return napi_clear_last_error(env);`

Collapse file

`‎test/addons-napi/test_number/test.js‎`

Copy file name to clipboardExpand all lines: test/addons-napi/test_number/test.js

+99-36Lines changed: 99 additions & 36 deletions

Original file line number	Diff line number	Diff line change
@@ -5,50 +5,113 @@ const test_number = require(`./build/${common.buildType}/test_number`);
`5`	`5`
`6`	`6`
`7`	`7`	`// testing api calls for number`
`8`		`-assert.strictEqual(0, test_number.Test(0));`
`9`		`-assert.strictEqual(1, test_number.Test(1));`
`10`		`-assert.strictEqual(-1, test_number.Test(-1));`
`11`		`-assert.strictEqual(100, test_number.Test(100));`
`12`		`-assert.strictEqual(2121, test_number.Test(2121));`
`13`		`-assert.strictEqual(-1233, test_number.Test(-1233));`
`14`		`-assert.strictEqual(986583, test_number.Test(986583));`
`15`		`-assert.strictEqual(-976675, test_number.Test(-976675));`
	`8`	`+function testNumber(num) {`
	`9`	`+ assert.strictEqual(num, test_number.Test(num));`
	`10`	`+}`
`16`	`11`
`17`		`-const num1 = 98765432213456789876546896323445679887645323232436587988766545658;`
`18`		`-assert.strictEqual(num1, test_number.Test(num1));`
	`12`	`+testNumber(0);`
	`13`	`+testNumber(-0);`
	`14`	`+testNumber(1);`
	`15`	`+testNumber(-1);`
	`16`	`+testNumber(100);`
	`17`	`+testNumber(2121);`
	`18`	`+testNumber(-1233);`
	`19`	`+testNumber(986583);`
	`20`	`+testNumber(-976675);`
`19`	`21`
`20`		`-const num2 = -4350987086545760976737453646576078997096876957864353245245769809;`
`21`		`-assert.strictEqual(num2, test_number.Test(num2));`
	`22`	`+testNumber(`
	`23`	`+ 98765432213456789876546896323445679887645323232436587988766545658);`
	`24`	`+testNumber(`
	`25`	`+ -4350987086545760976737453646576078997096876957864353245245769809);`
	`26`	`+testNumber(Number.MIN_SAFE_INTEGER);`
	`27`	`+testNumber(Number.MAX_SAFE_INTEGER);`
	`28`	`+testNumber(Number.MAX_SAFE_INTEGER + 10);`
`22`	`29`
`23`		`-const num3 = Number.MAX_SAFE_INTEGER;`
`24`		`-assert.strictEqual(num3, test_number.Test(num3));`
	`30`	`+testNumber(Number.MIN_VALUE);`
	`31`	`+testNumber(Number.MAX_VALUE);`
	`32`	`+testNumber(Number.MAX_VALUE + 10);`
`25`	`33`
`26`		`-const num4 = Number.MAX_SAFE_INTEGER + 10;`
`27`		`-assert.strictEqual(num4, test_number.Test(num4));`
	`34`	`+testNumber(Number.POSITIVE_INFINITY);`
	`35`	`+testNumber(Number.NEGATIVE_INFINITY);`
	`36`	`+assert(Object.is(NaN, test_number.Test(NaN)));`
`28`	`37`
`29`		`-const num5 = Number.MAX_VALUE;`
`30`		`-assert.strictEqual(num5, test_number.Test(num5));`
	`38`	`+// validate documented behavior when value is retrieved as 32-bit integer with`
	`39`	+// `napi_get_value_int32`
	`40`	`+function testInt32(input, expected = input) {`
	`41`	`+ assert.strictEqual(expected, test_number.TestInt32Truncation(input));`
	`42`	`+}`
`31`	`43`
`32`		`-const num6 = Number.MAX_VALUE + 10;`
`33`		`-assert.strictEqual(num6, test_number.Test(num6));`
	`44`	`+// Test zero`
	`45`	`+testInt32(0.0, 0);`
	`46`	`+testInt32(-0.0, 0);`
`34`	`47`
`35`		`-const num7 = Number.POSITIVE_INFINITY;`
`36`		`-assert.strictEqual(num7, test_number.Test(num7));`
	`48`	`+// Test min/max int32 range`
	`49`	`+testInt32(-Math.pow(2, 31));`
	`50`	`+testInt32(Math.pow(2, 31) - 1);`
`37`	`51`
`38`		`-const num8 = Number.NEGATIVE_INFINITY;`
`39`		`-assert.strictEqual(num8, test_number.Test(num8));`
	`52`	`+// Test overflow scenarios`
	`53`	`+testInt32(4294967297, 1);`
	`54`	`+testInt32(4294967296, 0);`
	`55`	`+testInt32(4294967295, -1);`
	`56`	`+testInt32(4294967296 * 5 + 3, 3);`
`40`	`57`
	`58`	`+// Test min/max safe integer range`
	`59`	`+testInt32(Number.MIN_SAFE_INTEGER, 1);`
	`60`	`+testInt32(Number.MAX_SAFE_INTEGER, -1);`
`41`	`61`
`42`		`-// validate documented behaviour when value is retrieved`
`43`		`-// as 32 bit integer with napi_get_value_int32`
`44`		`-assert.strictEqual(1, test_number.TestInt32Truncation(4294967297));`
`45`		`-assert.strictEqual(0, test_number.TestInt32Truncation(4294967296));`
`46`		`-assert.strictEqual(-1, test_number.TestInt32Truncation(4294967295));`
`47`		`-assert.strictEqual(3, test_number.TestInt32Truncation(4294967296 * 5 + 3));`
	`62`	`+// Test within int64_t range (with precision loss)`
	`63`	`+testInt32(-Math.pow(2, 63) + (Math.pow(2, 9) + 1), 1024);`
	`64`	`+testInt32(Math.pow(2, 63) - (Math.pow(2, 9) + 1), -1024);`
`48`	`65`
`49`		`-// validate that the boundaries of safe integer can be passed through`
`50`		`-// successfully`
`51`		`-assert.strictEqual(Number.MAX_SAFE_INTEGER,`
`52`		`- test_number.TestInt64Truncation(Number.MAX_SAFE_INTEGER));`
`53`		`-assert.strictEqual(Number.MIN_SAFE_INTEGER,`
`54`		`- test_number.TestInt64Truncation(Number.MIN_SAFE_INTEGER));`
	`66`	`+// Test min/max double value`
	`67`	`+testInt32(-Number.MIN_VALUE, 0);`
	`68`	`+testInt32(Number.MIN_VALUE, 0);`
	`69`	`+testInt32(-Number.MAX_VALUE, 0);`
	`70`	`+testInt32(Number.MAX_VALUE, 0);`
	`71`	`+`
	`72`	`+// Test outside int64_t range`
	`73`	`+testInt32(-Math.pow(2, 63) + (Math.pow(2, 9)), 0);`
	`74`	`+testInt32(Math.pow(2, 63) - (Math.pow(2, 9)), 0);`
	`75`	`+`
	`76`	`+// Test non-finite numbers`
	`77`	`+testInt32(Number.POSITIVE_INFINITY, 0);`
	`78`	`+testInt32(Number.NEGATIVE_INFINITY, 0);`
	`79`	`+testInt32(Number.NaN, 0);`
	`80`	`+`
	`81`	`+// validate documented behavior when value is retrieved as 64-bit integer with`
	`82`	+// `napi_get_value_int64`
	`83`	`+function testInt64(input, expected = input) {`
	`84`	`+ assert.strictEqual(expected, test_number.TestInt64Truncation(input));`
	`85`	`+}`
	`86`	`+`
	`87`	+// Both V8 and ChakraCore return a sentinel value of `0x8000000000000000` when
	`88`	`+// the conversion goes out of range, but V8 treats it as unsigned in some cases.`
	`89`	`+const RANGEERROR_POSITIVE = Math.pow(2, 63);`
	`90`	`+const RANGEERROR_NEGATIVE = -Math.pow(2, 63);`
	`91`	`+`
	`92`	`+// Test zero`
	`93`	`+testInt64(0.0, 0);`
	`94`	`+testInt64(-0.0, 0);`
	`95`	`+`
	`96`	`+// Test min/max safe integer range`
	`97`	`+testInt64(Number.MIN_SAFE_INTEGER);`
	`98`	`+testInt64(Number.MAX_SAFE_INTEGER);`
	`99`	`+`
	`100`	`+// Test within int64_t range (with precision loss)`
	`101`	`+testInt64(-Math.pow(2, 63) + (Math.pow(2, 9) + 1));`
	`102`	`+testInt64(Math.pow(2, 63) - (Math.pow(2, 9) + 1));`
	`103`	`+`
	`104`	`+// Test min/max double value`
	`105`	`+testInt64(-Number.MIN_VALUE, 0);`
	`106`	`+testInt64(Number.MIN_VALUE, 0);`
	`107`	`+testInt64(-Number.MAX_VALUE, RANGEERROR_NEGATIVE);`
	`108`	`+testInt64(Number.MAX_VALUE, RANGEERROR_POSITIVE);`
	`109`	`+`
	`110`	`+// Test outside int64_t range`
	`111`	`+testInt64(-Math.pow(2, 63) + (Math.pow(2, 9)), RANGEERROR_NEGATIVE);`
	`112`	`+testInt64(Math.pow(2, 63) - (Math.pow(2, 9)), RANGEERROR_POSITIVE);`
	`113`	`+`
	`114`	`+// Test non-finite numbers`
	`115`	`+testInt64(Number.POSITIVE_INFINITY, 0);`
	`116`	`+testInt64(Number.NEGATIVE_INFINITY, 0);`
	`117`	`+testInt64(Number.NaN, 0);`

0 commit comments

Comments

0 (0)

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.