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