Invalid flags in a RegExp literal should be an early SyntaxError
[WebKit-https.git] / JSTests / stress / Number-isNaN-basics.js
1 function numberIsNaNOnInteger(value)
2 {
3     return Number.isNaN(value);
4 }
5 noInline(numberIsNaNOnInteger);
6
7 // *** Test simple cases on integers. ***
8 function testNumberIsNaNOnIntegers()
9 {
10     // Bounds.
11     var value = numberIsNaNOnInteger(0);
12     if (value)
13         throw "numberIsNaNOnInteger(0) = " + value;
14
15     var value = numberIsNaNOnInteger(-2147483648);
16     if (value)
17         throw "numberIsNaNOnInteger(-2147483648) = " + value;
18
19     var value = numberIsNaNOnInteger(2147483647);
20     if (value)
21         throw "numberIsNaNOnInteger(2147483647) = " + value;
22
23     // Simple values.
24     var value = numberIsNaNOnInteger(-1);
25     if (value)
26         throw "numberIsNaNOnInteger(-1) = " + value;
27
28     var value = numberIsNaNOnInteger(42);
29     if (value)
30         throw "numberIsNaNOnInteger(42) = " + value;
31
32     var value = numberIsNaNOnInteger(-42);
33     if (value)
34         throw "numberIsNaNOnInteger(-42) = " + value;
35 }
36 noInline(testNumberIsNaNOnIntegers);
37
38 for (var i = 0; i < 1e4; ++i) {
39     testNumberIsNaNOnIntegers();
40 }
41
42 // Make sure we don't do anything stupid when the type is unexpected.
43 function verifyNumberIsNaNOnIntegerWithOtherTypes()
44 {
45     var value = numberIsNaNOnInteger(Math.PI);
46     if (value)
47         throw "numberIsNaNOnInteger(Math.PI) = " + value;
48
49     var value = numberIsNaNOnInteger("42");
50     if (value)
51         throw "numberIsNaNOnInteger(\"42\") = " + value;
52
53     var value = numberIsNaNOnInteger("WebKit");
54     if (value)
55         throw "numberIsNaNOnInteger(\"WebKit\") = " + value;
56
57     var value = numberIsNaNOnInteger(-0);
58     if (value)
59         throw "numberIsNaNOnInteger(-0) = " + value;
60 }
61 noInline(verifyNumberIsNaNOnIntegerWithOtherTypes);
62
63 for (var i = 0; i < 1e4; ++i) {
64     verifyNumberIsNaNOnIntegerWithOtherTypes();
65 }
66
67
68 // *** Test simple cases on doubles. ***
69 function numberIsNaNOnDouble(value)
70 {
71     return Number.isNaN(value);
72 }
73 noInline(numberIsNaNOnDouble);
74
75 // Test simple cases on doubles.
76 function testNumberIsNaNOnDoubles()
77 {
78     var value = numberIsNaNOnDouble(Math.PI);
79     if (value)
80         throw "numberIsNaNOnDouble(Math.PI) = " + value;
81
82     var value = numberIsNaNOnDouble(Math.E);
83     if (value)
84         throw "numberIsNaNOnDouble(Math.E) = " + value;
85
86     var value = numberIsNaNOnDouble(Math.LN2);
87     if (value)
88         throw "numberIsNaNOnDouble(Math.LN2) = " + value;
89
90     var value = numberIsNaNOnDouble(-0);
91     if (value)
92         throw "numberIsNaNOnDouble(-0) = " + value;
93
94     var value = numberIsNaNOnDouble(NaN);
95     if (!value)
96         throw "numberIsNaNOnDouble(NaN) = " + value;
97
98     var value = numberIsNaNOnDouble(Number.POSITIVE_INFINITY);
99     if (value)
100         throw "numberIsNaNOnDouble(Number.POSITIVE_INFINITY) = " + value;
101
102     var value = numberIsNaNOnDouble(Number.NEGATIVE_INFINITY);
103     if (value)
104         throw "numberIsNaNOnDouble(Number.NEGATIVE_INFINITY) = " + value;
105 }
106 noInline(testNumberIsNaNOnDoubles);
107
108 for (var i = 0; i < 1e4; ++i) {
109     testNumberIsNaNOnDoubles();
110 }
111
112 // Make sure we don't do anything stupid when the type is unexpected.
113 function verifyNumberIsNaNOnDoublesWithOtherTypes()
114 {
115     var value = numberIsNaNOnDouble(1);
116     if (value)
117         throw "numberIsNaNOnDouble(1) = " + value;
118
119     var value = numberIsNaNOnDouble("42");
120     if (value)
121         throw "numberIsNaNOnDouble(\"42\") = " + value;
122
123     var value = numberIsNaNOnDouble("WebKit");
124     if (value)
125         throw "numberIsNaNOnDouble(\"WebKit\") = " + value;
126
127     var value = numberIsNaNOnDouble({});
128     if (value)
129         throw "numberIsNaNOnDouble({}) = " + value;
130 }
131 noInline(verifyNumberIsNaNOnDoublesWithOtherTypes);
132
133 for (var i = 0; i < 1e4; ++i) {
134     verifyNumberIsNaNOnDoublesWithOtherTypes();
135 }
136
137
138 // *** Unusual arguments. ***
139 function numberIsNaNNoArguments()
140 {
141     return Number.isNaN();
142 }
143 noInline(numberIsNaNNoArguments);
144
145 function numberIsNaNTooManyArguments(a, b, c)
146 {
147     return Number.isNaN(a, b, c);
148 }
149 noInline(numberIsNaNTooManyArguments);
150
151
152 for (var i = 0; i < 1e4; ++i) {
153     var value = numberIsNaNNoArguments();
154     if (value)
155         throw "numberIsNaNNoArguments() = " + value;
156
157     value = numberIsNaNTooManyArguments(2, 3, 5);
158     if (value)
159         throw "numberIsNaNTooManyArguments() = " + value;
160 }
161
162
163 // *** Constant as arguments. ***
164 function testNumberIsNaNOnConstants()
165 {
166     var value = Number.isNaN(0);
167     if (value)
168         throw "Number.isNaN(0) = " + value;
169     var value = Number.isNaN(-0);
170     if (value)
171         throw "Number.isNaN(-0) = " + value;
172     var value = Number.isNaN(1);
173     if (value)
174         throw "Number.isNaN(1) = " + value;
175     var value = Number.isNaN(-1);
176     if (value)
177         throw "Number.isNaN(-1) = " + value;
178     var value = Number.isNaN(42);
179     if (value)
180         throw "Number.isNaN(42) = " + value;
181     var value = Number.isNaN(-42);
182     if (value)
183         throw "Number.isNaN(-42) = " + value;
184     var value = Number.isNaN(Number.POSITIVE_INFINITY);
185     if (value)
186         throw "Number.isNaN(Number.POSITIVE_INFINITY) = " + value;
187     var value = Number.isNaN(Number.NEGATIVE_INFINITY);
188     if (value)
189         throw "Number.isNaN(Number.NEGATIVE_INFINITY) = " + value;
190     var value = Number.isNaN(Math.E);
191     if (value)
192         throw "Number.isNaN(Math.E) = " + value;
193     var value = Number.isNaN(NaN);
194     if (!value)
195         throw "Number.isNaN(NaN) = " + value;
196 }
197 noInline(testNumberIsNaNOnConstants);
198
199 for (var i = 0; i < 1e4; ++i) {
200     testNumberIsNaNOnConstants();
201 }
202
203
204 // *** Struct transition. ***
205 function numberIsNaNStructTransition(value)
206 {
207     return Number.isNaN(value);
208 }
209 noInline(numberIsNaNStructTransition);
210
211 for (var i = 0; i < 1e4; ++i) {
212     var value = numberIsNaNStructTransition(42);
213     if (value)
214         throw "numberIsNaNStructTransition(42) = " + value;
215 }
216
217 Number.isNaN = function() { return 123; }
218
219 var value = numberIsNaNStructTransition(42);
220 if (value !== 123)
221     throw "numberIsNaNStructTransition(42) after transition = " + value;