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