Debian Codegraph @

tests/auto/qml/ecmascripttests/test262/test/language/expressions/unsigned-right-shift/bigint-toprimitive.js

raw
1 // Copyright (C) 2017 Josh Wolfe. All rights reserved.
2 // This code is governed by the BSD license found in the LICENSE file.
3 /*---
4 description: unsigned-right-shift operator ToNumeric with BigInt operands
5 esid: sec-unsigned-right-shift-operator-runtime-semantics-evaluation
6 info: After ToNumeric type coercion, unsigned-right-shift always throws for BigInt operands
7 features: [BigInt, Symbol.toPrimitive, computed-property-names]
8 ---*/
9
10 function err() {
11 throw new Test262Error();
12 }
13
14 function MyError() {}
15
16 assert.throws(TypeError, function() {
17 ({
18 [Symbol.toPrimitive]: function() {
19 return 2n;
20 },
21 valueOf: err,
22 toString: err
23 }) >>> 0n;
24 }, "ToPrimitive: @@toPrimitive takes precedence");
25 assert.throws(TypeError, function() {
26 0n >>> {
27 [Symbol.toPrimitive]: function() {
28 return 2n;
29 },
30 valueOf: err,
31 toString: err
32 };
33 }, "ToPrimitive: @@toPrimitive takes precedence");
34 assert.throws(TypeError, function() {
35 ({
36 valueOf: function() {
37 return 2n;
38 },
39 toString: err
40 }) >>> 0n;
41 }, "ToPrimitive: valueOf takes precedence over toString");
42 assert.throws(TypeError, function() {
43 0n >>> {
44 valueOf: function() {
45 return 2n;
46 },
47 toString: err
48 };
49 }, "ToPrimitive: valueOf takes precedence over toString");
50 assert.throws(TypeError, function() {
51 ({
52 toString: function() {
53 return 2n;
54 }
55 }) >>> 0n;
56 }, "ToPrimitive: toString with no valueOf");
57 assert.throws(TypeError, function() {
58 0n >>> {
59 toString: function() {
60 return 2n;
61 }
62 };
63 }, "ToPrimitive: toString with no valueOf");
64 assert.throws(TypeError, function() {
65 ({
66 [Symbol.toPrimitive]: undefined,
67 valueOf: function() {
68 return 2n;
69 }
70 }) >>> 0n;
71 }, "ToPrimitive: skip @@toPrimitive when it's undefined");
72 assert.throws(TypeError, function() {
73 0n >>> {
74 [Symbol.toPrimitive]: undefined,
75 valueOf: function() {
76 return 2n;
77 }
78 };
79 }, "ToPrimitive: skip @@toPrimitive when it's undefined");
80 assert.throws(TypeError, function() {
81 ({
82 [Symbol.toPrimitive]: null,
83 valueOf: function() {
84 return 2n;
85 }
86 }) >>> 0n;
87 }, "ToPrimitive: skip @@toPrimitive when it's null");
88 assert.throws(TypeError, function() {
89 0n >>> {
90 [Symbol.toPrimitive]: null,
91 valueOf: function() {
92 return 2n;
93 }
94 };
95 }, "ToPrimitive: skip @@toPrimitive when it's null");
96 assert.throws(TypeError, function() {
97 ({
98 valueOf: null,
99 toString: function() {
100 return 2n;
101 }
102 }) >>> 0n;
103 }, "ToPrimitive: skip valueOf when it's not callable");
104 assert.throws(TypeError, function() {
105 0n >>> {
106 valueOf: null,
107 toString: function() {
108 return 2n;
109 }
110 };
111 }, "ToPrimitive: skip valueOf when it's not callable");
112 assert.throws(TypeError, function() {
113 ({
114 valueOf: 1,
115 toString: function() {
116 return 2n;
117 }
118 }) >>> 0n;
119 }, "ToPrimitive: skip valueOf when it's not callable");
120 assert.throws(TypeError, function() {
121 0n >>> {
122 valueOf: 1,
123 toString: function() {
124 return 2n;
125 }
126 };
127 }, "ToPrimitive: skip valueOf when it's not callable");
128 assert.throws(TypeError, function() {
129 ({
130 valueOf: {},
131 toString: function() {
132 return 2n;
133 }
134 }) >>> 0n;
135 }, "ToPrimitive: skip valueOf when it's not callable");
136 assert.throws(TypeError, function() {
137 0n >>> {
138 valueOf: {},
139 toString: function() {
140 return 2n;
141 }
142 };
143 }, "ToPrimitive: skip valueOf when it's not callable");
144 assert.throws(TypeError, function() {
145 ({
146 valueOf: function() {
147 return {};
148 },
149 toString: function() {
150 return 2n;
151 }
152 }) >>> 0n;
153 }, "ToPrimitive: skip valueOf when it returns an object");
154 assert.throws(TypeError, function() {
155 0n >>> {
156 valueOf: function() {
157 return {};
158 },
159 toString: function() {
160 return 2n;
161 }
162 };
163 }, "ToPrimitive: skip valueOf when it returns an object");
164 assert.throws(TypeError, function() {
165 ({
166 valueOf: function() {
167 return Object(12345);
168 },
169 toString: function() {
170 return 2n;
171 }
172 }) >>> 0n;
173 }, "ToPrimitive: skip valueOf when it returns an object");
174 assert.throws(TypeError, function() {
175 0n >>> {
176 valueOf: function() {
177 return Object(12345);
178 },
179 toString: function() {
180 return 2n;
181 }
182 };
183 }, "ToPrimitive: skip valueOf when it returns an object");
184 assert.throws(TypeError, function() {
185 ({
186 [Symbol.toPrimitive]: 1
187 }) >>> 0n;
188 }, "ToPrimitive: throw when @@toPrimitive is not callable");
189 assert.throws(TypeError, function() {
190 0n >>> {
191 [Symbol.toPrimitive]: 1
192 };
193 }, "ToPrimitive: throw when @@toPrimitive is not callable");
194 assert.throws(TypeError, function() {
195 ({
196 [Symbol.toPrimitive]: {}
197 }) >>> 0n;
198 }, "ToPrimitive: throw when @@toPrimitive is not callable");
199 assert.throws(TypeError, function() {
200 0n >>> {
201 [Symbol.toPrimitive]: {}
202 };
203 }, "ToPrimitive: throw when @@toPrimitive is not callable");
204 assert.throws(TypeError, function() {
205 ({
206 [Symbol.toPrimitive]: function() {
207 return Object(1);
208 }
209 }) >>> 0n;
210 }, "ToPrimitive: throw when @@toPrimitive returns an object");
211 assert.throws(TypeError, function() {
212 0n >>> {
213 [Symbol.toPrimitive]: function() {
214 return Object(1);
215 }
216 };
217 }, "ToPrimitive: throw when @@toPrimitive returns an object");
218 assert.throws(TypeError, function() {
219 ({
220 [Symbol.toPrimitive]: function() {
221 return {};
222 }
223 }) >>> 0n;
224 }, "ToPrimitive: throw when @@toPrimitive returns an object");
225 assert.throws(TypeError, function() {
226 0n >>> {
227 [Symbol.toPrimitive]: function() {
228 return {};
229 }
230 };
231 }, "ToPrimitive: throw when @@toPrimitive returns an object");
232 assert.throws(MyError, function() {
233 ({
234 [Symbol.toPrimitive]: function() {
235 throw new MyError();
236 }
237 }) >>> 0n;
238 }, "ToPrimitive: propagate errors from @@toPrimitive");
239 assert.throws(MyError, function() {
240 0n >>> {
241 [Symbol.toPrimitive]: function() {
242 throw new MyError();
243 }
244 };
245 }, "ToPrimitive: propagate errors from @@toPrimitive");
246 assert.throws(MyError, function() {
247 ({
248 valueOf: function() {
249 throw new MyError();
250 }
251 }) >>> 0n;
252 }, "ToPrimitive: propagate errors from valueOf");
253 assert.throws(MyError, function() {
254 0n >>> {
255 valueOf: function() {
256 throw new MyError();
257 }
258 };
259 }, "ToPrimitive: propagate errors from valueOf");
260 assert.throws(MyError, function() {
261 ({
262 toString: function() {
263 throw new MyError();
264 }
265 }) >>> 0n;
266 }, "ToPrimitive: propagate errors from toString");
267 assert.throws(MyError, function() {
268 0n >>> {
269 toString: function() {
270 throw new MyError();
271 }
272 };
273 }, "ToPrimitive: propagate errors from toString");
274 assert.throws(TypeError, function() {
275 ({
276 valueOf: null,
277 toString: null
278 }) >>> 0n;
279 }, "ToPrimitive: throw when skipping both valueOf and toString");
280 assert.throws(TypeError, function() {
281 0n >>> {
282 valueOf: null,
283 toString: null
284 };
285 }, "ToPrimitive: throw when skipping both valueOf and toString");
286 assert.throws(TypeError, function() {
287 ({
288 valueOf: 1,
289 toString: 1
290 }) >>> 0n;
291 }, "ToPrimitive: throw when skipping both valueOf and toString");
292 assert.throws(TypeError, function() {
293 0n >>> {
294 valueOf: 1,
295 toString: 1
296 };
297 }, "ToPrimitive: throw when skipping both valueOf and toString");
298 assert.throws(TypeError, function() {
299 ({
300 valueOf: {},
301 toString: {}
302 }) >>> 0n;
303 }, "ToPrimitive: throw when skipping both valueOf and toString");
304 assert.throws(TypeError, function() {
305 0n >>> {
306 valueOf: {},
307 toString: {}
308 };
309 }, "ToPrimitive: throw when skipping both valueOf and toString");
310 assert.throws(TypeError, function() {
311 ({
312 valueOf: function() {
313 return Object(1);
314 },
315 toString: function() {
316 return Object(1);
317 }
318 }) >>> 0n;
319 }, "ToPrimitive: throw when skipping both valueOf and toString");
320 assert.throws(TypeError, function() {
321 0n >>> {
322 valueOf: function() {
323 return Object(1);
324 },
325 toString: function() {
326 return Object(1);
327 }
328 };
329 }, "ToPrimitive: throw when skipping both valueOf and toString");
330 assert.throws(TypeError, function() {
331 ({
332 valueOf: function() {
333 return {};
334 },
335 toString: function() {
336 return {};
337 }
338 }) >>> 0n;
339 }, "ToPrimitive: throw when skipping both valueOf and toString");
340 assert.throws(TypeError, function() {
341 0n >>> {
342 valueOf: function() {
343 return {};
344 },
345 toString: function() {
346 return {};
347 }
348 };
349 }, "ToPrimitive: throw when skipping both valueOf and toString");