test_builtin.js (24310B)
1 "use strict"; 2 3 var status = 0; 4 var throw_errors = true; 5 6 function throw_error(msg) { 7 if (throw_errors) 8 throw Error(msg); 9 console.log(msg); 10 status = 1; 11 } 12 13 function assert(actual, expected, message) { 14 function get_full_type(o) { 15 var type = typeof(o); 16 if (type === 'object') { 17 if (o === null) 18 return 'null'; 19 if (o.constructor && o.constructor.name) 20 return o.constructor.name; 21 } 22 return type; 23 } 24 25 if (arguments.length == 1) 26 expected = true; 27 28 if (typeof actual === typeof expected) { 29 if (actual === expected) { 30 if (actual !== 0 || (1 / actual) === (1 / expected)) 31 return; 32 } 33 if (typeof actual === 'number') { 34 if (isNaN(actual) && isNaN(expected)) 35 return true; 36 } 37 if (typeof actual === 'object') { 38 if (actual !== null && expected !== null 39 && actual.constructor === expected.constructor 40 && actual.toString() === expected.toString()) 41 return; 42 } 43 } 44 // Should output the source file and line number and extract 45 // the expression from the assert call 46 throw_error("assertion failed: got " + 47 get_full_type(actual) + ":|" + actual + "|, expected " + 48 get_full_type(expected) + ":|" + expected + "|" + 49 (message ? " (" + message + ")" : "")); 50 } 51 52 function assert_throws(expected_error, func) 53 { 54 var err = false; 55 try { 56 func(); 57 } catch(e) { 58 err = true; 59 if (!(e instanceof expected_error)) { 60 // Should output the source file and line number and extract 61 // the expression from the assert_throws() call 62 throw_error("unexpected exception type"); 63 return; 64 } 65 } 66 if (!err) { 67 // Should output the source file and line number and extract 68 // the expression from the assert_throws() call 69 throw_error("expected exception"); 70 } 71 } 72 73 // load more elaborate version of assert if available 74 try { __loadScript("test_assert.js"); } catch(e) {} 75 76 /*----------------*/ 77 78 function my_func(a, b) 79 { 80 return a + b; 81 } 82 83 function test_function() 84 { 85 function f(a, b) { 86 var i, tab = []; 87 tab.push(this); 88 for(i = 0; i < arguments.length; i++) 89 tab.push(arguments[i]); 90 return tab; 91 } 92 function constructor1(a) { 93 this.x = a; 94 } 95 96 var r, g; 97 98 r = my_func.call(null, 1, 2); 99 assert(r, 3, "call"); 100 101 r = my_func.apply(null, [1, 2]); 102 assert(r, 3, "apply"); 103 104 r = (function () { return 1; }).apply(null, undefined); 105 assert(r, 1); 106 107 assert_throws(TypeError, (function() { 108 Reflect.apply((function () { return 1; }), null, undefined); 109 })); 110 111 r = new Function("a", "b", "return a + b;"); 112 assert(r(2,3), 5, "function"); 113 114 g = f.bind(1, 2); 115 assert(g.length, 1); 116 assert(g.name, "bound f"); 117 assert(g(3), [1,2,3]); 118 119 g = constructor1.bind(null, 1); 120 r = new g(); 121 assert(r.x, 1); 122 } 123 124 function test() 125 { 126 var r, a, b, c, err; 127 128 r = Error("hello"); 129 assert(r.message, "hello", "Error"); 130 131 a = new Object(); 132 a.x = 1; 133 assert(a.x, 1, "Object"); 134 135 assert(Object.getPrototypeOf(a), Object.prototype, "getPrototypeOf"); 136 Object.defineProperty(a, "y", { value: 3, writable: true, configurable: true, enumerable: true }); 137 assert(a.y, 3, "defineProperty"); 138 139 Object.defineProperty(a, "z", { get: function () { return 4; }, set: function(val) { this.z_val = val; }, configurable: true, enumerable: true }); 140 assert(a.z, 4, "get"); 141 a.z = 5; 142 assert(a.z_val, 5, "set"); 143 144 a = { get z() { return 4; }, set z(val) { this.z_val = val; } }; 145 assert(a.z, 4, "get"); 146 a.z = 5; 147 assert(a.z_val, 5, "set"); 148 149 b = Object.create(a); 150 assert(Object.getPrototypeOf(b), a, "create"); 151 c = {u:2}; 152 /* XXX: refcount bug in 'b' instead of 'a' */ 153 Object.setPrototypeOf(a, c); 154 assert(Object.getPrototypeOf(a), c, "setPrototypeOf"); 155 156 a = {}; 157 assert(a.toString(), "[object Object]", "toString"); 158 159 a = {x:1}; 160 assert(Object.isExtensible(a), true, "extensible"); 161 Object.preventExtensions(a); 162 163 err = false; 164 try { 165 a.y = 2; 166 } catch(e) { 167 err = true; 168 } 169 assert(Object.isExtensible(a), false, "extensible"); 170 assert(typeof a.y, "undefined", "extensible"); 171 assert(err, true, "extensible"); 172 } 173 174 function test_enum() 175 { 176 var a, tab; 177 a = {x:1, 178 "18014398509481984": 1, 179 "9007199254740992": 1, 180 "9007199254740991": 1, 181 "4294967296": 1, 182 "4294967295": 1, 183 y:1, 184 "4294967294": 1, 185 "1": 2}; 186 tab = Object.keys(a); 187 // console.log("tab=" + tab.toString()); 188 assert(tab, ["1","4294967294","x","18014398509481984","9007199254740992","9007199254740991","4294967296","4294967295","y"], "keys"); 189 } 190 191 function test_array() 192 { 193 var a, err; 194 195 a = [1, 2, 3]; 196 assert(a.length, 3, "array"); 197 assert(a[2], 3, "array1"); 198 199 a = new Array(10); 200 assert(a.length, 10, "array2"); 201 202 a = new Array(1, 2); 203 assert(a.length === 2 && a[0] === 1 && a[1] === 2, true, "array3"); 204 205 a = [1, 2, 3]; 206 a.length = 2; 207 assert(a.length === 2 && a[0] === 1 && a[1] === 2, true, "array4"); 208 209 a = []; 210 a[1] = 10; 211 a[4] = 3; 212 assert(a.length, 5); 213 214 a = [1,2]; 215 a.length = 5; 216 a[4] = 1; 217 a.length = 4; 218 assert(a[4] !== 1, true, "array5"); 219 220 a = [1,2]; 221 a.push(3,4); 222 assert(a.join(), "1,2,3,4", "join"); 223 224 a = [1,2,3,4,5]; 225 Object.defineProperty(a, "3", { configurable: false }); 226 err = false; 227 try { 228 a.length = 2; 229 } catch(e) { 230 err = true; 231 } 232 assert(err && a.toString() === "1,2,3,4"); 233 } 234 235 function test_string() 236 { 237 var a; 238 a = String("abc"); 239 assert(a.length, 3, "string"); 240 assert(a[1], "b", "string"); 241 assert(a.charCodeAt(1), 0x62, "string"); 242 assert(String.fromCharCode(65), "A", "string"); 243 assert(String.fromCharCode.apply(null, [65, 66, 67]), "ABC", "string"); 244 assert(a.charAt(1), "b"); 245 assert(a.charAt(-1), ""); 246 assert(a.charAt(3), ""); 247 248 a = "abcd"; 249 assert(a.substring(1, 3), "bc", "substring"); 250 a = String.fromCharCode(0x20ac); 251 assert(a.charCodeAt(0), 0x20ac, "unicode"); 252 assert(a, "€", "unicode"); 253 assert(a, "\u20ac", "unicode"); 254 assert(a, "\u{20ac}", "unicode"); 255 assert("a", "\x61", "unicode"); 256 257 a = "\u{10ffff}"; 258 assert(a.length, 2, "unicode"); 259 assert(a, "\u{dbff}\u{dfff}", "unicode"); 260 assert(a.codePointAt(0), 0x10ffff); 261 assert(String.fromCodePoint(0x10ffff), a); 262 263 assert("a".concat("b", "c"), "abc"); 264 265 assert("abcabc".indexOf("cab"), 2); 266 assert("abcabc".indexOf("cab2"), -1); 267 assert("abc".indexOf("c"), 2); 268 269 assert("aaa".indexOf("a"), 0); 270 assert("aaa".indexOf("a", NaN), 0); 271 assert("aaa".indexOf("a", -Infinity), 0); 272 assert("aaa".indexOf("a", -1), 0); 273 assert("aaa".indexOf("a", -0), 0); 274 assert("aaa".indexOf("a", 0), 0); 275 assert("aaa".indexOf("a", 1), 1); 276 assert("aaa".indexOf("a", 2), 2); 277 assert("aaa".indexOf("a", 3), -1); 278 assert("aaa".indexOf("a", 4), -1); 279 assert("aaa".indexOf("a", Infinity), -1); 280 281 assert("aaa".indexOf(""), 0); 282 assert("aaa".indexOf("", NaN), 0); 283 assert("aaa".indexOf("", -Infinity), 0); 284 assert("aaa".indexOf("", -1), 0); 285 assert("aaa".indexOf("", -0), 0); 286 assert("aaa".indexOf("", 0), 0); 287 assert("aaa".indexOf("", 1), 1); 288 assert("aaa".indexOf("", 2), 2); 289 assert("aaa".indexOf("", 3), 3); 290 assert("aaa".indexOf("", 4), 3); 291 assert("aaa".indexOf("", Infinity), 3); 292 293 assert("aaa".lastIndexOf("a"), 2); 294 assert("aaa".lastIndexOf("a", NaN), 2); 295 assert("aaa".lastIndexOf("a", -Infinity), 0); 296 assert("aaa".lastIndexOf("a", -1), 0); 297 assert("aaa".lastIndexOf("a", -0), 0); 298 assert("aaa".lastIndexOf("a", 0), 0); 299 assert("aaa".lastIndexOf("a", 1), 1); 300 assert("aaa".lastIndexOf("a", 2), 2); 301 assert("aaa".lastIndexOf("a", 3), 2); 302 assert("aaa".lastIndexOf("a", 4), 2); 303 assert("aaa".lastIndexOf("a", Infinity), 2); 304 305 assert("aaa".lastIndexOf(""), 3); 306 assert("aaa".lastIndexOf("", NaN), 3); 307 assert("aaa".lastIndexOf("", -Infinity), 0); 308 assert("aaa".lastIndexOf("", -1), 0); 309 assert("aaa".lastIndexOf("", -0), 0); 310 assert("aaa".lastIndexOf("", 0), 0); 311 assert("aaa".lastIndexOf("", 1), 1); 312 assert("aaa".lastIndexOf("", 2), 2); 313 assert("aaa".lastIndexOf("", 3), 3); 314 assert("aaa".lastIndexOf("", 4), 3); 315 assert("aaa".lastIndexOf("", Infinity), 3); 316 317 assert("a,b,c".split(","), ["a","b","c"]); 318 assert(",b,c".split(","), ["","b","c"]); 319 assert("a,b,".split(","), ["a","b",""]); 320 321 assert("aaaa".split(), [ "aaaa" ]); 322 assert("aaaa".split(undefined, 0), [ ]); 323 assert("aaaa".split(""), [ "a", "a", "a", "a" ]); 324 assert("aaaa".split("", 0), [ ]); 325 assert("aaaa".split("", 1), [ "a" ]); 326 assert("aaaa".split("", 2), [ "a", "a" ]); 327 assert("aaaa".split("a"), [ "", "", "", "", "" ]); 328 assert("aaaa".split("a", 2), [ "", "" ]); 329 assert("aaaa".split("aa"), [ "", "", "" ]); 330 assert("aaaa".split("aa", 0), [ ]); 331 assert("aaaa".split("aa", 1), [ "" ]); 332 assert("aaaa".split("aa", 2), [ "", "" ]); 333 assert("aaaa".split("aaa"), [ "", "a" ]); 334 assert("aaaa".split("aaaa"), [ "", "" ]); 335 assert("aaaa".split("aaaaa"), [ "aaaa" ]); 336 assert("aaaa".split("aaaaa", 0), [ ]); 337 assert("aaaa".split("aaaaa", 1), [ "aaaa" ]); 338 339 assert(eval('"\0"'), "\0"); 340 341 assert("abc".padStart(Infinity, ""), "abc"); 342 } 343 344 function test_math() 345 { 346 var a; 347 a = 1.4; 348 assert(Math.floor(a), 1); 349 assert(Math.ceil(a), 2); 350 assert(Math.imul(0x12345678, 123), -1088058456); 351 assert(Math.imul(0xB505, 0xB504), 2147441940); 352 assert(Math.imul(0xB505, 0xB505), -2147479015); 353 assert(Math.imul((-2)**31, (-2)**31), 0); 354 assert(Math.imul(2**31-1, 2**31-1), 1); 355 assert(Math.fround(0.1), 0.10000000149011612); 356 assert(Math.hypot(), 0); 357 assert(Math.hypot(-2), 2); 358 assert(Math.hypot(3, 4), 5); 359 assert(Math.abs(Math.hypot(3, 4, 5) - 7.0710678118654755) <= 1e-15); 360 } 361 362 function test_number() 363 { 364 assert(parseInt("123"), 123); 365 assert(parseInt(" 123r"), 123); 366 assert(parseInt("0x123"), 0x123); 367 assert(parseInt("0o123"), 0); 368 assert(+" 123 ", 123); 369 assert(+"0b111", 7); 370 assert(+"0o123", 83); 371 assert(parseFloat("2147483647"), 2147483647); 372 assert(parseFloat("2147483648"), 2147483648); 373 assert(parseFloat("-2147483647"), -2147483647); 374 assert(parseFloat("-2147483648"), -2147483648); 375 assert(parseFloat("0x1234"), 0); 376 assert(parseFloat("Infinity"), Infinity); 377 assert(parseFloat("-Infinity"), -Infinity); 378 assert(parseFloat("123.2"), 123.2); 379 assert(parseFloat("123.2e3"), 123200); 380 assert(Number.isNaN(Number("+"))); 381 assert(Number.isNaN(Number("-"))); 382 assert(Number.isNaN(Number("\x00a"))); 383 384 // TODO: Fix rounding errors on Windows/Cygwin. 385 if (typeof os !== 'undefined' && ['win32', 'cygwin'].includes(os.platform)) { 386 return; 387 } 388 389 assert((25).toExponential(0), "3e+1"); 390 assert((-25).toExponential(0), "-3e+1"); 391 assert((2.5).toPrecision(1), "3"); 392 assert((-2.5).toPrecision(1), "-3"); 393 assert((1.125).toFixed(2), "1.13"); 394 assert((-1.125).toFixed(2), "-1.13"); 395 } 396 397 function test_eval2() 398 { 399 var g_call_count = 0; 400 /* force non strict mode for f1 and f2 */ 401 var f1 = new Function("eval", "eval(1, 2)"); 402 var f2 = new Function("eval", "eval(...[1, 2])"); 403 function g(a, b) { 404 assert(a, 1); 405 assert(b, 2); 406 g_call_count++; 407 } 408 f1(g); 409 f2(g); 410 assert(g_call_count, 2); 411 } 412 413 function test_eval() 414 { 415 function f(b) { 416 var x = 1; 417 return eval(b); 418 } 419 var r, a; 420 421 r = eval("1+1;"); 422 assert(r, 2, "eval"); 423 424 r = eval("var my_var=2; my_var;"); 425 assert(r, 2, "eval"); 426 assert(typeof my_var, "undefined"); 427 428 assert(eval("if (1) 2; else 3;"), 2); 429 assert(eval("if (0) 2; else 3;"), 3); 430 431 assert(f.call(1, "this"), 1); 432 433 a = 2; 434 assert(eval("a"), 2); 435 436 eval("a = 3"); 437 assert(a, 3); 438 439 assert(f("arguments.length", 1), 2); 440 assert(f("arguments[1]", 1), 1); 441 442 a = 4; 443 assert(f("a"), 4); 444 f("a=3"); 445 assert(a, 3); 446 447 test_eval2(); 448 } 449 450 function test_typed_array() 451 { 452 var buffer, a, i, str; 453 454 a = new Uint8Array(4); 455 assert(a.length, 4); 456 for(i = 0; i < a.length; i++) 457 a[i] = i; 458 assert(a.join(","), "0,1,2,3"); 459 a[0] = -1; 460 assert(a[0], 255); 461 462 a = new Int8Array(3); 463 a[0] = 255; 464 assert(a[0], -1); 465 466 a = new Int32Array(3); 467 a[0] = Math.pow(2, 32) - 1; 468 assert(a[0], -1); 469 assert(a.BYTES_PER_ELEMENT, 4); 470 471 a = new Uint8ClampedArray(4); 472 a[0] = -100; 473 a[1] = 1.5; 474 a[2] = 0.5; 475 a[3] = 1233.5; 476 assert(a.toString(), "0,2,0,255"); 477 478 buffer = new ArrayBuffer(16); 479 assert(buffer.byteLength, 16); 480 a = new Uint32Array(buffer, 12, 1); 481 assert(a.length, 1); 482 a[0] = -1; 483 484 a = new Uint16Array(buffer, 2); 485 a[0] = -1; 486 487 a = new Float32Array(buffer, 8, 1); 488 a[0] = 1; 489 490 a = new Uint8Array(buffer); 491 492 str = a.toString(); 493 /* test little and big endian cases */ 494 if (str !== "0,0,255,255,0,0,0,0,0,0,128,63,255,255,255,255" && 495 str !== "0,0,255,255,0,0,0,0,63,128,0,0,255,255,255,255") { 496 assert(false); 497 } 498 499 assert(a.buffer, buffer); 500 501 a = new Uint8Array([1, 2, 3, 4]); 502 assert(a.toString(), "1,2,3,4"); 503 a.set([10, 11], 2); 504 assert(a.toString(), "1,2,10,11"); 505 } 506 507 function test_json() 508 { 509 var a, s; 510 s = '{"x":1,"y":true,"z":null,"a":[1,2,3],"s":"str"}'; 511 a = JSON.parse(s); 512 assert(a.x, 1); 513 assert(a.y, true); 514 assert(a.z, null); 515 assert(JSON.stringify(a), s); 516 517 /* indentation test */ 518 assert(JSON.stringify([[{x:1,y:{},z:[]},2,3]],undefined,1), 519 `[ 520 [ 521 { 522 "x": 1, 523 "y": {}, 524 "z": [] 525 }, 526 2, 527 3 528 ] 529 ]`); 530 } 531 532 function test_date() 533 { 534 // Date Time String format is YYYY-MM-DDTHH:mm:ss.sssZ 535 // accepted date formats are: YYYY, YYYY-MM and YYYY-MM-DD 536 // accepted time formats are: THH:mm, THH:mm:ss, THH:mm:ss.sss 537 // expanded years are represented with 6 digits prefixed by + or - 538 // -000000 is invalid. 539 // A string containing out-of-bounds or nonconforming elements 540 // is not a valid instance of this format. 541 // Hence the fractional part after . should have 3 digits and how 542 // a different number of digits is handled is implementation defined. 543 assert(Date.parse(""), NaN); 544 assert(Date.parse("2000"), 946684800000); 545 assert(Date.parse("2000-01"), 946684800000); 546 assert(Date.parse("2000-01-01"), 946684800000); 547 //assert(Date.parse("2000-01-01T"), NaN); 548 //assert(Date.parse("2000-01-01T00Z"), NaN); 549 assert(Date.parse("2000-01-01T00:00Z"), 946684800000); 550 assert(Date.parse("2000-01-01T00:00:00Z"), 946684800000); 551 assert(Date.parse("2000-01-01T00:00:00.1Z"), 946684800100); 552 assert(Date.parse("2000-01-01T00:00:00.10Z"), 946684800100); 553 assert(Date.parse("2000-01-01T00:00:00.100Z"), 946684800100); 554 assert(Date.parse("2000-01-01T00:00:00.1000Z"), 946684800100); 555 assert(Date.parse("2000-01-01T00:00:00+00:00"), 946684800000); 556 //assert(Date.parse("2000-01-01T00:00:00+00:30"), 946686600000); 557 var d = new Date("2000T00:00"); // Jan 1st 2000, 0:00:00 local time 558 assert(typeof d === 'object' && d.toString() != 'Invalid Date'); 559 assert((new Date('Jan 1 2000')).toISOString(), 560 d.toISOString()); 561 assert((new Date('Jan 1 2000 00:00')).toISOString(), 562 d.toISOString()); 563 assert((new Date('Jan 1 2000 00:00:00')).toISOString(), 564 d.toISOString()); 565 assert((new Date('Jan 1 2000 00:00:00 GMT+0100')).toISOString(), 566 '1999-12-31T23:00:00.000Z'); 567 assert((new Date('Jan 1 2000 00:00:00 GMT+0200')).toISOString(), 568 '1999-12-31T22:00:00.000Z'); 569 assert((new Date('Sat Jan 1 2000')).toISOString(), 570 d.toISOString()); 571 assert((new Date('Sat Jan 1 2000 00:00')).toISOString(), 572 d.toISOString()); 573 assert((new Date('Sat Jan 1 2000 00:00:00')).toISOString(), 574 d.toISOString()); 575 assert((new Date('Sat Jan 1 2000 00:00:00 GMT+0100')).toISOString(), 576 '1999-12-31T23:00:00.000Z'); 577 assert((new Date('Sat Jan 1 2000 00:00:00 GMT+0200')).toISOString(), 578 '1999-12-31T22:00:00.000Z'); 579 580 var d = new Date(1506098258091); 581 assert(d.toISOString(), "2017-09-22T16:37:38.091Z"); 582 d.setUTCHours(18, 10, 11); 583 assert(d.toISOString(), "2017-09-22T18:10:11.091Z"); 584 var a = Date.parse(d.toISOString()); 585 assert((new Date(a)).toISOString(), d.toISOString()); 586 587 assert((new Date("2020-01-01T01:01:01.123Z")).toISOString(), 588 "2020-01-01T01:01:01.123Z"); 589 /* implementation defined behavior */ 590 assert((new Date("2020-01-01T01:01:01.1Z")).toISOString(), 591 "2020-01-01T01:01:01.100Z"); 592 assert((new Date("2020-01-01T01:01:01.12Z")).toISOString(), 593 "2020-01-01T01:01:01.120Z"); 594 assert((new Date("2020-01-01T01:01:01.1234Z")).toISOString(), 595 "2020-01-01T01:01:01.123Z"); 596 assert((new Date("2020-01-01T01:01:01.12345Z")).toISOString(), 597 "2020-01-01T01:01:01.123Z"); 598 assert((new Date("2020-01-01T01:01:01.1235Z")).toISOString(), 599 "2020-01-01T01:01:01.123Z"); 600 assert((new Date("2020-01-01T01:01:01.9999Z")).toISOString(), 601 "2020-01-01T01:01:01.999Z"); 602 603 assert(Date.UTC(2017), 1483228800000); 604 assert(Date.UTC(2017, 9), 1506816000000); 605 assert(Date.UTC(2017, 9, 22), 1508630400000); 606 assert(Date.UTC(2017, 9, 22, 18), 1508695200000); 607 assert(Date.UTC(2017, 9, 22, 18, 10), 1508695800000); 608 assert(Date.UTC(2017, 9, 22, 18, 10, 11), 1508695811000); 609 assert(Date.UTC(2017, 9, 22, 18, 10, 11, 91), 1508695811091); 610 611 assert(Date.UTC(NaN), NaN); 612 assert(Date.UTC(2017, NaN), NaN); 613 assert(Date.UTC(2017, 9, NaN), NaN); 614 assert(Date.UTC(2017, 9, 22, NaN), NaN); 615 assert(Date.UTC(2017, 9, 22, 18, NaN), NaN); 616 assert(Date.UTC(2017, 9, 22, 18, 10, NaN), NaN); 617 assert(Date.UTC(2017, 9, 22, 18, 10, 11, NaN), NaN); 618 assert(Date.UTC(2017, 9, 22, 18, 10, 11, 91, NaN), 1508695811091); 619 620 // TODO: Fix rounding errors on Windows/Cygwin. 621 if (!(typeof os !== 'undefined' && ['win32', 'cygwin'].includes(os.platform))) { 622 // from test262/test/built-ins/Date/UTC/fp-evaluation-order.js 623 assert(Date.UTC(1970, 0, 1, 80063993375, 29, 1, -288230376151711740), 29312, 624 'order of operations / precision in MakeTime'); 625 assert(Date.UTC(1970, 0, 213503982336, 0, 0, 0, -18446744073709552000), 34447360, 626 'precision in MakeDate'); 627 } 628 //assert(Date.UTC(2017 - 1e9, 9 + 12e9), 1506816000000); // node fails this 629 assert(Date.UTC(2017, 9, 22 - 1e10, 18 + 24e10), 1508695200000); 630 assert(Date.UTC(2017, 9, 22, 18 - 1e10, 10 + 60e10), 1508695800000); 631 assert(Date.UTC(2017, 9, 22, 18, 10 - 1e10, 11 + 60e10), 1508695811000); 632 assert(Date.UTC(2017, 9, 22, 18, 10, 11 - 1e12, 91 + 1000e12), 1508695811091); 633 } 634 635 function test_regexp() 636 { 637 var a, str; 638 str = "abbbbbc"; 639 a = /(b+)c/.exec(str); 640 assert(a[0], "bbbbbc"); 641 assert(a[1], "bbbbb"); 642 assert(a.index, 1); 643 assert(a.input, str); 644 a = /(b+)c/.test(str); 645 assert(a, true); 646 assert(/\x61/.exec("a")[0], "a"); 647 assert(/\u0061/.exec("a")[0], "a"); 648 assert(/\ca/.exec("\x01")[0], "\x01"); 649 assert(/\\a/.exec("\\a")[0], "\\a"); 650 assert(/\c0/.exec("\\c0")[0], "\\c0"); 651 652 a = /(\.(?=com|org)|\/)/.exec("ah.com"); 653 assert(a.index === 2 && a[0] === "."); 654 655 a = /(\.(?!com|org)|\/)/.exec("ah.com"); 656 assert(a, null); 657 658 a = /(?=(a+))/.exec("baaabac"); 659 assert(a.index === 1 && a[0] === "" && a[1] === "aaa"); 660 661 a = /(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac"); 662 assert(a, ["zaacbbbcac","z","ac","a",,"c"]); 663 664 a = eval("/\0a/"); 665 assert(a.toString(), "/\0a/"); 666 assert(a.exec("\0a")[0], "\0a"); 667 668 assert(/{1a}/.toString(), "/{1a}/"); 669 a = /a{1+/.exec("a{11"); 670 assert(a, ["a{11"]); 671 672 /* test zero length matches */ 673 a = /(?:(?=(abc)))a/.exec("abc"); 674 assert(a, ["a", "abc"]); 675 a = /(?:(?=(abc)))?a/.exec("abc"); 676 assert(a, ["a", undefined]); 677 a = /(?:(?=(abc))){0,2}a/.exec("abc"); 678 assert(a, ["a", undefined]); 679 a = /(?:|[\w])+([0-9])/.exec("123a23"); 680 assert(a, ["123a23", "3"]); 681 a = /()*?a/.exec(","); 682 assert(a, null); 683 } 684 685 function test_symbol() 686 { 687 var a, b, obj, c; 688 a = Symbol("abc"); 689 obj = {}; 690 obj[a] = 2; 691 assert(obj[a], 2); 692 assert(typeof obj["abc"], "undefined"); 693 assert(String(a), "Symbol(abc)"); 694 b = Symbol("abc"); 695 assert(a == a); 696 assert(a === a); 697 assert(a != b); 698 assert(a !== b); 699 700 b = Symbol.for("abc"); 701 c = Symbol.for("abc"); 702 assert(b === c); 703 assert(b !== a); 704 705 assert(Symbol.keyFor(b), "abc"); 706 assert(Symbol.keyFor(a), undefined); 707 708 a = Symbol("aaa"); 709 assert(a.valueOf(), a); 710 assert(a.toString(), "Symbol(aaa)"); 711 712 b = Object(a); 713 assert(b.valueOf(), a); 714 assert(b.toString(), "Symbol(aaa)"); 715 } 716 717 function test_map() 718 { 719 var a, i, n, tab, o, v; 720 n = 1000; 721 722 a = new Map(); 723 for (var i = 0; i < n; i++) { 724 a.set(i, i); 725 } 726 a.set(-2147483648, 1); 727 assert(a.get(-2147483648), 1); 728 assert(a.get(-2147483647 - 1), 1); 729 assert(a.get(-2147483647.5 - 0.5), 1); 730 731 a.set(1n, 1n); 732 assert(a.get(1n), 1n); 733 assert(a.get(2n**1000n - (2n**1000n - 1n)), 1n); 734 735 a = new Map(); 736 tab = []; 737 for(i = 0; i < n; i++) { 738 v = { }; 739 o = { id: i }; 740 tab[i] = [o, v]; 741 a.set(o, v); 742 } 743 744 assert(a.size, n); 745 for(i = 0; i < n; i++) { 746 assert(a.get(tab[i][0]), tab[i][1]); 747 } 748 749 i = 0; 750 a.forEach(function (v, o) { 751 assert(o, tab[i++][0]); 752 assert(a.has(o)); 753 assert(a.delete(o)); 754 assert(!a.has(o)); 755 }); 756 757 assert(a.size, 0); 758 } 759 760 function test_weak_map() 761 { 762 var a, i, n, tab, o, v, n2; 763 a = new WeakMap(); 764 n = 10; 765 tab = []; 766 for(i = 0; i < n; i++) { 767 v = { }; 768 o = { id: i }; 769 tab[i] = [o, v]; 770 a.set(o, v); 771 } 772 o = null; 773 774 n2 = n >> 1; 775 for(i = 0; i < n2; i++) { 776 a.delete(tab[i][0]); 777 } 778 for(i = n2; i < n; i++) { 779 tab[i][0] = null; /* should remove the object from the WeakMap too */ 780 } 781 /* the WeakMap should be empty here */ 782 } 783 784 function test_generator() 785 { 786 function *f() { 787 var ret; 788 yield 1; 789 ret = yield 2; 790 assert(ret, "next_arg"); 791 return 3; 792 } 793 function *f2() { 794 yield 1; 795 yield 2; 796 return "ret_val"; 797 } 798 function *f1() { 799 var ret = yield *f2(); 800 assert(ret, "ret_val"); 801 return 3; 802 } 803 function *f3() { 804 var ret; 805 /* test stack consistency with nip_n to handle yield return + 806 * finally clause */ 807 try { 808 ret = 2 + (yield 1); 809 } catch(e) { 810 } finally { 811 ret++; 812 } 813 return ret; 814 } 815 var g, v; 816 g = f(); 817 v = g.next(); 818 assert(v.value === 1 && v.done === false); 819 v = g.next(); 820 assert(v.value === 2 && v.done === false); 821 v = g.next("next_arg"); 822 assert(v.value === 3 && v.done === true); 823 v = g.next(); 824 assert(v.value === undefined && v.done === true); 825 826 g = f1(); 827 v = g.next(); 828 assert(v.value === 1 && v.done === false); 829 v = g.next(); 830 assert(v.value === 2 && v.done === false); 831 v = g.next(); 832 assert(v.value === 3 && v.done === true); 833 v = g.next(); 834 assert(v.value === undefined && v.done === true); 835 836 g = f3(); 837 v = g.next(); 838 assert(v.value === 1 && v.done === false); 839 v = g.next(3); 840 assert(v.value === 6 && v.done === true); 841 } 842 843 test(); 844 test_function(); 845 test_enum(); 846 test_array(); 847 test_string(); 848 test_math(); 849 test_number(); 850 test_eval(); 851 test_typed_array(); 852 test_json(); 853 test_date(); 854 test_regexp(); 855 test_symbol(); 856 test_map(); 857 test_weak_map(); 858 test_generator();