no-such-property-getprop.js (26068B)
1 ///////////////////////////////////////// 2 // This is a generated file! 3 // See jit-tests/etc/generate-nosuchproperty-tests.js for the code 4 // that generated this code! 5 ///////////////////////////////////////// 6 7 ///////////////////////////////////////// 8 // PRELUDE // 9 ///////////////////////////////////////// 10 11 function createTower(n) { 12 var result = Object.create(null); 13 for (var i = 0; i < n; i++) 14 result = Object.create(result); 15 return result; 16 } 17 function updateChain(obj, depth, prop, value) { 18 // Walk down the proto chain |depth| iterations and set |prop| to |value|. 19 var cur = obj; 20 for (var i = 0; i < depth; i++) 21 cur = Object.getPrototypeOf(cur); 22 23 var desc = {value:value, writable:true, configurable:true, enumerable:true}; 24 Object.defineProperty(cur, prop, desc); 25 } 26 27 ///////////////////////////////////////// 28 // TEST CASES // 29 ///////////////////////////////////////// 30 31 //// Test chain of length 0 with late-property-addition at depth 0 32 function runChain_0_0(obj) { 33 var sum = 0; 34 for (var i = 0; i < 100; i++) 35 sum += obj.foo; 36 return sum; 37 } 38 function testChain_0_0() { 39 var obj = createTower(0); 40 assertEq(runChain_0_0(obj), NaN); 41 updateChain(obj, 0, 'foo', 9); 42 assertEq(runChain_0_0(obj), 900); 43 } 44 45 //// Test chain of length 1 with late-property-addition at depth 0 46 function runChain_1_0(obj) { 47 var sum = 0; 48 for (var i = 0; i < 100; i++) 49 sum += obj.foo; 50 return sum; 51 } 52 function testChain_1_0() { 53 var obj = createTower(1); 54 assertEq(runChain_1_0(obj), NaN); 55 updateChain(obj, 0, 'foo', 9); 56 assertEq(runChain_1_0(obj), 900); 57 } 58 59 //// Test chain of length 1 with late-property-addition at depth 1 60 function runChain_1_1(obj) { 61 var sum = 0; 62 for (var i = 0; i < 100; i++) 63 sum += obj.foo; 64 return sum; 65 } 66 function testChain_1_1() { 67 var obj = createTower(1); 68 assertEq(runChain_1_1(obj), NaN); 69 updateChain(obj, 1, 'foo', 9); 70 assertEq(runChain_1_1(obj), 900); 71 } 72 73 //// Test chain of length 2 with late-property-addition at depth 0 74 function runChain_2_0(obj) { 75 var sum = 0; 76 for (var i = 0; i < 100; i++) 77 sum += obj.foo; 78 return sum; 79 } 80 function testChain_2_0() { 81 var obj = createTower(2); 82 assertEq(runChain_2_0(obj), NaN); 83 updateChain(obj, 0, 'foo', 9); 84 assertEq(runChain_2_0(obj), 900); 85 } 86 87 //// Test chain of length 2 with late-property-addition at depth 1 88 function runChain_2_1(obj) { 89 var sum = 0; 90 for (var i = 0; i < 100; i++) 91 sum += obj.foo; 92 return sum; 93 } 94 function testChain_2_1() { 95 var obj = createTower(2); 96 assertEq(runChain_2_1(obj), NaN); 97 updateChain(obj, 1, 'foo', 9); 98 assertEq(runChain_2_1(obj), 900); 99 } 100 101 //// Test chain of length 2 with late-property-addition at depth 2 102 function runChain_2_2(obj) { 103 var sum = 0; 104 for (var i = 0; i < 100; i++) 105 sum += obj.foo; 106 return sum; 107 } 108 function testChain_2_2() { 109 var obj = createTower(2); 110 assertEq(runChain_2_2(obj), NaN); 111 updateChain(obj, 2, 'foo', 9); 112 assertEq(runChain_2_2(obj), 900); 113 } 114 115 //// Test chain of length 3 with late-property-addition at depth 0 116 function runChain_3_0(obj) { 117 var sum = 0; 118 for (var i = 0; i < 100; i++) 119 sum += obj.foo; 120 return sum; 121 } 122 function testChain_3_0() { 123 var obj = createTower(3); 124 assertEq(runChain_3_0(obj), NaN); 125 updateChain(obj, 0, 'foo', 9); 126 assertEq(runChain_3_0(obj), 900); 127 } 128 129 //// Test chain of length 3 with late-property-addition at depth 1 130 function runChain_3_1(obj) { 131 var sum = 0; 132 for (var i = 0; i < 100; i++) 133 sum += obj.foo; 134 return sum; 135 } 136 function testChain_3_1() { 137 var obj = createTower(3); 138 assertEq(runChain_3_1(obj), NaN); 139 updateChain(obj, 1, 'foo', 9); 140 assertEq(runChain_3_1(obj), 900); 141 } 142 143 //// Test chain of length 3 with late-property-addition at depth 2 144 function runChain_3_2(obj) { 145 var sum = 0; 146 for (var i = 0; i < 100; i++) 147 sum += obj.foo; 148 return sum; 149 } 150 function testChain_3_2() { 151 var obj = createTower(3); 152 assertEq(runChain_3_2(obj), NaN); 153 updateChain(obj, 2, 'foo', 9); 154 assertEq(runChain_3_2(obj), 900); 155 } 156 157 //// Test chain of length 3 with late-property-addition at depth 3 158 function runChain_3_3(obj) { 159 var sum = 0; 160 for (var i = 0; i < 100; i++) 161 sum += obj.foo; 162 return sum; 163 } 164 function testChain_3_3() { 165 var obj = createTower(3); 166 assertEq(runChain_3_3(obj), NaN); 167 updateChain(obj, 3, 'foo', 9); 168 assertEq(runChain_3_3(obj), 900); 169 } 170 171 //// Test chain of length 4 with late-property-addition at depth 0 172 function runChain_4_0(obj) { 173 var sum = 0; 174 for (var i = 0; i < 100; i++) 175 sum += obj.foo; 176 return sum; 177 } 178 function testChain_4_0() { 179 var obj = createTower(4); 180 assertEq(runChain_4_0(obj), NaN); 181 updateChain(obj, 0, 'foo', 9); 182 assertEq(runChain_4_0(obj), 900); 183 } 184 185 //// Test chain of length 4 with late-property-addition at depth 1 186 function runChain_4_1(obj) { 187 var sum = 0; 188 for (var i = 0; i < 100; i++) 189 sum += obj.foo; 190 return sum; 191 } 192 function testChain_4_1() { 193 var obj = createTower(4); 194 assertEq(runChain_4_1(obj), NaN); 195 updateChain(obj, 1, 'foo', 9); 196 assertEq(runChain_4_1(obj), 900); 197 } 198 199 //// Test chain of length 4 with late-property-addition at depth 2 200 function runChain_4_2(obj) { 201 var sum = 0; 202 for (var i = 0; i < 100; i++) 203 sum += obj.foo; 204 return sum; 205 } 206 function testChain_4_2() { 207 var obj = createTower(4); 208 assertEq(runChain_4_2(obj), NaN); 209 updateChain(obj, 2, 'foo', 9); 210 assertEq(runChain_4_2(obj), 900); 211 } 212 213 //// Test chain of length 4 with late-property-addition at depth 3 214 function runChain_4_3(obj) { 215 var sum = 0; 216 for (var i = 0; i < 100; i++) 217 sum += obj.foo; 218 return sum; 219 } 220 function testChain_4_3() { 221 var obj = createTower(4); 222 assertEq(runChain_4_3(obj), NaN); 223 updateChain(obj, 3, 'foo', 9); 224 assertEq(runChain_4_3(obj), 900); 225 } 226 227 //// Test chain of length 4 with late-property-addition at depth 4 228 function runChain_4_4(obj) { 229 var sum = 0; 230 for (var i = 0; i < 100; i++) 231 sum += obj.foo; 232 return sum; 233 } 234 function testChain_4_4() { 235 var obj = createTower(4); 236 assertEq(runChain_4_4(obj), NaN); 237 updateChain(obj, 4, 'foo', 9); 238 assertEq(runChain_4_4(obj), 900); 239 } 240 241 //// Test chain of length 5 with late-property-addition at depth 0 242 function runChain_5_0(obj) { 243 var sum = 0; 244 for (var i = 0; i < 100; i++) 245 sum += obj.foo; 246 return sum; 247 } 248 function testChain_5_0() { 249 var obj = createTower(5); 250 assertEq(runChain_5_0(obj), NaN); 251 updateChain(obj, 0, 'foo', 9); 252 assertEq(runChain_5_0(obj), 900); 253 } 254 255 //// Test chain of length 5 with late-property-addition at depth 1 256 function runChain_5_1(obj) { 257 var sum = 0; 258 for (var i = 0; i < 100; i++) 259 sum += obj.foo; 260 return sum; 261 } 262 function testChain_5_1() { 263 var obj = createTower(5); 264 assertEq(runChain_5_1(obj), NaN); 265 updateChain(obj, 1, 'foo', 9); 266 assertEq(runChain_5_1(obj), 900); 267 } 268 269 //// Test chain of length 5 with late-property-addition at depth 2 270 function runChain_5_2(obj) { 271 var sum = 0; 272 for (var i = 0; i < 100; i++) 273 sum += obj.foo; 274 return sum; 275 } 276 function testChain_5_2() { 277 var obj = createTower(5); 278 assertEq(runChain_5_2(obj), NaN); 279 updateChain(obj, 2, 'foo', 9); 280 assertEq(runChain_5_2(obj), 900); 281 } 282 283 //// Test chain of length 5 with late-property-addition at depth 3 284 function runChain_5_3(obj) { 285 var sum = 0; 286 for (var i = 0; i < 100; i++) 287 sum += obj.foo; 288 return sum; 289 } 290 function testChain_5_3() { 291 var obj = createTower(5); 292 assertEq(runChain_5_3(obj), NaN); 293 updateChain(obj, 3, 'foo', 9); 294 assertEq(runChain_5_3(obj), 900); 295 } 296 297 //// Test chain of length 5 with late-property-addition at depth 4 298 function runChain_5_4(obj) { 299 var sum = 0; 300 for (var i = 0; i < 100; i++) 301 sum += obj.foo; 302 return sum; 303 } 304 function testChain_5_4() { 305 var obj = createTower(5); 306 assertEq(runChain_5_4(obj), NaN); 307 updateChain(obj, 4, 'foo', 9); 308 assertEq(runChain_5_4(obj), 900); 309 } 310 311 //// Test chain of length 5 with late-property-addition at depth 5 312 function runChain_5_5(obj) { 313 var sum = 0; 314 for (var i = 0; i < 100; i++) 315 sum += obj.foo; 316 return sum; 317 } 318 function testChain_5_5() { 319 var obj = createTower(5); 320 assertEq(runChain_5_5(obj), NaN); 321 updateChain(obj, 5, 'foo', 9); 322 assertEq(runChain_5_5(obj), 900); 323 } 324 325 //// Test chain of length 6 with late-property-addition at depth 0 326 function runChain_6_0(obj) { 327 var sum = 0; 328 for (var i = 0; i < 100; i++) 329 sum += obj.foo; 330 return sum; 331 } 332 function testChain_6_0() { 333 var obj = createTower(6); 334 assertEq(runChain_6_0(obj), NaN); 335 updateChain(obj, 0, 'foo', 9); 336 assertEq(runChain_6_0(obj), 900); 337 } 338 339 //// Test chain of length 6 with late-property-addition at depth 1 340 function runChain_6_1(obj) { 341 var sum = 0; 342 for (var i = 0; i < 100; i++) 343 sum += obj.foo; 344 return sum; 345 } 346 function testChain_6_1() { 347 var obj = createTower(6); 348 assertEq(runChain_6_1(obj), NaN); 349 updateChain(obj, 1, 'foo', 9); 350 assertEq(runChain_6_1(obj), 900); 351 } 352 353 //// Test chain of length 6 with late-property-addition at depth 2 354 function runChain_6_2(obj) { 355 var sum = 0; 356 for (var i = 0; i < 100; i++) 357 sum += obj.foo; 358 return sum; 359 } 360 function testChain_6_2() { 361 var obj = createTower(6); 362 assertEq(runChain_6_2(obj), NaN); 363 updateChain(obj, 2, 'foo', 9); 364 assertEq(runChain_6_2(obj), 900); 365 } 366 367 //// Test chain of length 6 with late-property-addition at depth 3 368 function runChain_6_3(obj) { 369 var sum = 0; 370 for (var i = 0; i < 100; i++) 371 sum += obj.foo; 372 return sum; 373 } 374 function testChain_6_3() { 375 var obj = createTower(6); 376 assertEq(runChain_6_3(obj), NaN); 377 updateChain(obj, 3, 'foo', 9); 378 assertEq(runChain_6_3(obj), 900); 379 } 380 381 //// Test chain of length 6 with late-property-addition at depth 4 382 function runChain_6_4(obj) { 383 var sum = 0; 384 for (var i = 0; i < 100; i++) 385 sum += obj.foo; 386 return sum; 387 } 388 function testChain_6_4() { 389 var obj = createTower(6); 390 assertEq(runChain_6_4(obj), NaN); 391 updateChain(obj, 4, 'foo', 9); 392 assertEq(runChain_6_4(obj), 900); 393 } 394 395 //// Test chain of length 6 with late-property-addition at depth 5 396 function runChain_6_5(obj) { 397 var sum = 0; 398 for (var i = 0; i < 100; i++) 399 sum += obj.foo; 400 return sum; 401 } 402 function testChain_6_5() { 403 var obj = createTower(6); 404 assertEq(runChain_6_5(obj), NaN); 405 updateChain(obj, 5, 'foo', 9); 406 assertEq(runChain_6_5(obj), 900); 407 } 408 409 //// Test chain of length 6 with late-property-addition at depth 6 410 function runChain_6_6(obj) { 411 var sum = 0; 412 for (var i = 0; i < 100; i++) 413 sum += obj.foo; 414 return sum; 415 } 416 function testChain_6_6() { 417 var obj = createTower(6); 418 assertEq(runChain_6_6(obj), NaN); 419 updateChain(obj, 6, 'foo', 9); 420 assertEq(runChain_6_6(obj), 900); 421 } 422 423 //// Test chain of length 7 with late-property-addition at depth 0 424 function runChain_7_0(obj) { 425 var sum = 0; 426 for (var i = 0; i < 100; i++) 427 sum += obj.foo; 428 return sum; 429 } 430 function testChain_7_0() { 431 var obj = createTower(7); 432 assertEq(runChain_7_0(obj), NaN); 433 updateChain(obj, 0, 'foo', 9); 434 assertEq(runChain_7_0(obj), 900); 435 } 436 437 //// Test chain of length 7 with late-property-addition at depth 1 438 function runChain_7_1(obj) { 439 var sum = 0; 440 for (var i = 0; i < 100; i++) 441 sum += obj.foo; 442 return sum; 443 } 444 function testChain_7_1() { 445 var obj = createTower(7); 446 assertEq(runChain_7_1(obj), NaN); 447 updateChain(obj, 1, 'foo', 9); 448 assertEq(runChain_7_1(obj), 900); 449 } 450 451 //// Test chain of length 7 with late-property-addition at depth 2 452 function runChain_7_2(obj) { 453 var sum = 0; 454 for (var i = 0; i < 100; i++) 455 sum += obj.foo; 456 return sum; 457 } 458 function testChain_7_2() { 459 var obj = createTower(7); 460 assertEq(runChain_7_2(obj), NaN); 461 updateChain(obj, 2, 'foo', 9); 462 assertEq(runChain_7_2(obj), 900); 463 } 464 465 //// Test chain of length 7 with late-property-addition at depth 3 466 function runChain_7_3(obj) { 467 var sum = 0; 468 for (var i = 0; i < 100; i++) 469 sum += obj.foo; 470 return sum; 471 } 472 function testChain_7_3() { 473 var obj = createTower(7); 474 assertEq(runChain_7_3(obj), NaN); 475 updateChain(obj, 3, 'foo', 9); 476 assertEq(runChain_7_3(obj), 900); 477 } 478 479 //// Test chain of length 7 with late-property-addition at depth 4 480 function runChain_7_4(obj) { 481 var sum = 0; 482 for (var i = 0; i < 100; i++) 483 sum += obj.foo; 484 return sum; 485 } 486 function testChain_7_4() { 487 var obj = createTower(7); 488 assertEq(runChain_7_4(obj), NaN); 489 updateChain(obj, 4, 'foo', 9); 490 assertEq(runChain_7_4(obj), 900); 491 } 492 493 //// Test chain of length 7 with late-property-addition at depth 5 494 function runChain_7_5(obj) { 495 var sum = 0; 496 for (var i = 0; i < 100; i++) 497 sum += obj.foo; 498 return sum; 499 } 500 function testChain_7_5() { 501 var obj = createTower(7); 502 assertEq(runChain_7_5(obj), NaN); 503 updateChain(obj, 5, 'foo', 9); 504 assertEq(runChain_7_5(obj), 900); 505 } 506 507 //// Test chain of length 7 with late-property-addition at depth 6 508 function runChain_7_6(obj) { 509 var sum = 0; 510 for (var i = 0; i < 100; i++) 511 sum += obj.foo; 512 return sum; 513 } 514 function testChain_7_6() { 515 var obj = createTower(7); 516 assertEq(runChain_7_6(obj), NaN); 517 updateChain(obj, 6, 'foo', 9); 518 assertEq(runChain_7_6(obj), 900); 519 } 520 521 //// Test chain of length 7 with late-property-addition at depth 7 522 function runChain_7_7(obj) { 523 var sum = 0; 524 for (var i = 0; i < 100; i++) 525 sum += obj.foo; 526 return sum; 527 } 528 function testChain_7_7() { 529 var obj = createTower(7); 530 assertEq(runChain_7_7(obj), NaN); 531 updateChain(obj, 7, 'foo', 9); 532 assertEq(runChain_7_7(obj), 900); 533 } 534 535 //// Test chain of length 8 with late-property-addition at depth 0 536 function runChain_8_0(obj) { 537 var sum = 0; 538 for (var i = 0; i < 100; i++) 539 sum += obj.foo; 540 return sum; 541 } 542 function testChain_8_0() { 543 var obj = createTower(8); 544 assertEq(runChain_8_0(obj), NaN); 545 updateChain(obj, 0, 'foo', 9); 546 assertEq(runChain_8_0(obj), 900); 547 } 548 549 //// Test chain of length 8 with late-property-addition at depth 1 550 function runChain_8_1(obj) { 551 var sum = 0; 552 for (var i = 0; i < 100; i++) 553 sum += obj.foo; 554 return sum; 555 } 556 function testChain_8_1() { 557 var obj = createTower(8); 558 assertEq(runChain_8_1(obj), NaN); 559 updateChain(obj, 1, 'foo', 9); 560 assertEq(runChain_8_1(obj), 900); 561 } 562 563 //// Test chain of length 8 with late-property-addition at depth 2 564 function runChain_8_2(obj) { 565 var sum = 0; 566 for (var i = 0; i < 100; i++) 567 sum += obj.foo; 568 return sum; 569 } 570 function testChain_8_2() { 571 var obj = createTower(8); 572 assertEq(runChain_8_2(obj), NaN); 573 updateChain(obj, 2, 'foo', 9); 574 assertEq(runChain_8_2(obj), 900); 575 } 576 577 //// Test chain of length 8 with late-property-addition at depth 3 578 function runChain_8_3(obj) { 579 var sum = 0; 580 for (var i = 0; i < 100; i++) 581 sum += obj.foo; 582 return sum; 583 } 584 function testChain_8_3() { 585 var obj = createTower(8); 586 assertEq(runChain_8_3(obj), NaN); 587 updateChain(obj, 3, 'foo', 9); 588 assertEq(runChain_8_3(obj), 900); 589 } 590 591 //// Test chain of length 8 with late-property-addition at depth 4 592 function runChain_8_4(obj) { 593 var sum = 0; 594 for (var i = 0; i < 100; i++) 595 sum += obj.foo; 596 return sum; 597 } 598 function testChain_8_4() { 599 var obj = createTower(8); 600 assertEq(runChain_8_4(obj), NaN); 601 updateChain(obj, 4, 'foo', 9); 602 assertEq(runChain_8_4(obj), 900); 603 } 604 605 //// Test chain of length 8 with late-property-addition at depth 5 606 function runChain_8_5(obj) { 607 var sum = 0; 608 for (var i = 0; i < 100; i++) 609 sum += obj.foo; 610 return sum; 611 } 612 function testChain_8_5() { 613 var obj = createTower(8); 614 assertEq(runChain_8_5(obj), NaN); 615 updateChain(obj, 5, 'foo', 9); 616 assertEq(runChain_8_5(obj), 900); 617 } 618 619 //// Test chain of length 8 with late-property-addition at depth 6 620 function runChain_8_6(obj) { 621 var sum = 0; 622 for (var i = 0; i < 100; i++) 623 sum += obj.foo; 624 return sum; 625 } 626 function testChain_8_6() { 627 var obj = createTower(8); 628 assertEq(runChain_8_6(obj), NaN); 629 updateChain(obj, 6, 'foo', 9); 630 assertEq(runChain_8_6(obj), 900); 631 } 632 633 //// Test chain of length 8 with late-property-addition at depth 7 634 function runChain_8_7(obj) { 635 var sum = 0; 636 for (var i = 0; i < 100; i++) 637 sum += obj.foo; 638 return sum; 639 } 640 function testChain_8_7() { 641 var obj = createTower(8); 642 assertEq(runChain_8_7(obj), NaN); 643 updateChain(obj, 7, 'foo', 9); 644 assertEq(runChain_8_7(obj), 900); 645 } 646 647 //// Test chain of length 8 with late-property-addition at depth 8 648 function runChain_8_8(obj) { 649 var sum = 0; 650 for (var i = 0; i < 100; i++) 651 sum += obj.foo; 652 return sum; 653 } 654 function testChain_8_8() { 655 var obj = createTower(8); 656 assertEq(runChain_8_8(obj), NaN); 657 updateChain(obj, 8, 'foo', 9); 658 assertEq(runChain_8_8(obj), 900); 659 } 660 661 //// Test chain of length 9 with late-property-addition at depth 0 662 function runChain_9_0(obj) { 663 var sum = 0; 664 for (var i = 0; i < 100; i++) 665 sum += obj.foo; 666 return sum; 667 } 668 function testChain_9_0() { 669 var obj = createTower(9); 670 assertEq(runChain_9_0(obj), NaN); 671 updateChain(obj, 0, 'foo', 9); 672 assertEq(runChain_9_0(obj), 900); 673 } 674 675 //// Test chain of length 9 with late-property-addition at depth 1 676 function runChain_9_1(obj) { 677 var sum = 0; 678 for (var i = 0; i < 100; i++) 679 sum += obj.foo; 680 return sum; 681 } 682 function testChain_9_1() { 683 var obj = createTower(9); 684 assertEq(runChain_9_1(obj), NaN); 685 updateChain(obj, 1, 'foo', 9); 686 assertEq(runChain_9_1(obj), 900); 687 } 688 689 //// Test chain of length 9 with late-property-addition at depth 2 690 function runChain_9_2(obj) { 691 var sum = 0; 692 for (var i = 0; i < 100; i++) 693 sum += obj.foo; 694 return sum; 695 } 696 function testChain_9_2() { 697 var obj = createTower(9); 698 assertEq(runChain_9_2(obj), NaN); 699 updateChain(obj, 2, 'foo', 9); 700 assertEq(runChain_9_2(obj), 900); 701 } 702 703 //// Test chain of length 9 with late-property-addition at depth 3 704 function runChain_9_3(obj) { 705 var sum = 0; 706 for (var i = 0; i < 100; i++) 707 sum += obj.foo; 708 return sum; 709 } 710 function testChain_9_3() { 711 var obj = createTower(9); 712 assertEq(runChain_9_3(obj), NaN); 713 updateChain(obj, 3, 'foo', 9); 714 assertEq(runChain_9_3(obj), 900); 715 } 716 717 //// Test chain of length 9 with late-property-addition at depth 4 718 function runChain_9_4(obj) { 719 var sum = 0; 720 for (var i = 0; i < 100; i++) 721 sum += obj.foo; 722 return sum; 723 } 724 function testChain_9_4() { 725 var obj = createTower(9); 726 assertEq(runChain_9_4(obj), NaN); 727 updateChain(obj, 4, 'foo', 9); 728 assertEq(runChain_9_4(obj), 900); 729 } 730 731 //// Test chain of length 9 with late-property-addition at depth 5 732 function runChain_9_5(obj) { 733 var sum = 0; 734 for (var i = 0; i < 100; i++) 735 sum += obj.foo; 736 return sum; 737 } 738 function testChain_9_5() { 739 var obj = createTower(9); 740 assertEq(runChain_9_5(obj), NaN); 741 updateChain(obj, 5, 'foo', 9); 742 assertEq(runChain_9_5(obj), 900); 743 } 744 745 //// Test chain of length 9 with late-property-addition at depth 6 746 function runChain_9_6(obj) { 747 var sum = 0; 748 for (var i = 0; i < 100; i++) 749 sum += obj.foo; 750 return sum; 751 } 752 function testChain_9_6() { 753 var obj = createTower(9); 754 assertEq(runChain_9_6(obj), NaN); 755 updateChain(obj, 6, 'foo', 9); 756 assertEq(runChain_9_6(obj), 900); 757 } 758 759 //// Test chain of length 9 with late-property-addition at depth 7 760 function runChain_9_7(obj) { 761 var sum = 0; 762 for (var i = 0; i < 100; i++) 763 sum += obj.foo; 764 return sum; 765 } 766 function testChain_9_7() { 767 var obj = createTower(9); 768 assertEq(runChain_9_7(obj), NaN); 769 updateChain(obj, 7, 'foo', 9); 770 assertEq(runChain_9_7(obj), 900); 771 } 772 773 //// Test chain of length 9 with late-property-addition at depth 8 774 function runChain_9_8(obj) { 775 var sum = 0; 776 for (var i = 0; i < 100; i++) 777 sum += obj.foo; 778 return sum; 779 } 780 function testChain_9_8() { 781 var obj = createTower(9); 782 assertEq(runChain_9_8(obj), NaN); 783 updateChain(obj, 8, 'foo', 9); 784 assertEq(runChain_9_8(obj), 900); 785 } 786 787 //// Test chain of length 9 with late-property-addition at depth 9 788 function runChain_9_9(obj) { 789 var sum = 0; 790 for (var i = 0; i < 100; i++) 791 sum += obj.foo; 792 return sum; 793 } 794 function testChain_9_9() { 795 var obj = createTower(9); 796 assertEq(runChain_9_9(obj), NaN); 797 updateChain(obj, 9, 'foo', 9); 798 assertEq(runChain_9_9(obj), 900); 799 } 800 801 //// Test chain of length 10 with late-property-addition at depth 0 802 function runChain_10_0(obj) { 803 var sum = 0; 804 for (var i = 0; i < 100; i++) 805 sum += obj.foo; 806 return sum; 807 } 808 function testChain_10_0() { 809 var obj = createTower(10); 810 assertEq(runChain_10_0(obj), NaN); 811 updateChain(obj, 0, 'foo', 9); 812 assertEq(runChain_10_0(obj), 900); 813 } 814 815 //// Test chain of length 10 with late-property-addition at depth 1 816 function runChain_10_1(obj) { 817 var sum = 0; 818 for (var i = 0; i < 100; i++) 819 sum += obj.foo; 820 return sum; 821 } 822 function testChain_10_1() { 823 var obj = createTower(10); 824 assertEq(runChain_10_1(obj), NaN); 825 updateChain(obj, 1, 'foo', 9); 826 assertEq(runChain_10_1(obj), 900); 827 } 828 829 //// Test chain of length 10 with late-property-addition at depth 2 830 function runChain_10_2(obj) { 831 var sum = 0; 832 for (var i = 0; i < 100; i++) 833 sum += obj.foo; 834 return sum; 835 } 836 function testChain_10_2() { 837 var obj = createTower(10); 838 assertEq(runChain_10_2(obj), NaN); 839 updateChain(obj, 2, 'foo', 9); 840 assertEq(runChain_10_2(obj), 900); 841 } 842 843 //// Test chain of length 10 with late-property-addition at depth 3 844 function runChain_10_3(obj) { 845 var sum = 0; 846 for (var i = 0; i < 100; i++) 847 sum += obj.foo; 848 return sum; 849 } 850 function testChain_10_3() { 851 var obj = createTower(10); 852 assertEq(runChain_10_3(obj), NaN); 853 updateChain(obj, 3, 'foo', 9); 854 assertEq(runChain_10_3(obj), 900); 855 } 856 857 //// Test chain of length 10 with late-property-addition at depth 4 858 function runChain_10_4(obj) { 859 var sum = 0; 860 for (var i = 0; i < 100; i++) 861 sum += obj.foo; 862 return sum; 863 } 864 function testChain_10_4() { 865 var obj = createTower(10); 866 assertEq(runChain_10_4(obj), NaN); 867 updateChain(obj, 4, 'foo', 9); 868 assertEq(runChain_10_4(obj), 900); 869 } 870 871 //// Test chain of length 10 with late-property-addition at depth 5 872 function runChain_10_5(obj) { 873 var sum = 0; 874 for (var i = 0; i < 100; i++) 875 sum += obj.foo; 876 return sum; 877 } 878 function testChain_10_5() { 879 var obj = createTower(10); 880 assertEq(runChain_10_5(obj), NaN); 881 updateChain(obj, 5, 'foo', 9); 882 assertEq(runChain_10_5(obj), 900); 883 } 884 885 //// Test chain of length 10 with late-property-addition at depth 6 886 function runChain_10_6(obj) { 887 var sum = 0; 888 for (var i = 0; i < 100; i++) 889 sum += obj.foo; 890 return sum; 891 } 892 function testChain_10_6() { 893 var obj = createTower(10); 894 assertEq(runChain_10_6(obj), NaN); 895 updateChain(obj, 6, 'foo', 9); 896 assertEq(runChain_10_6(obj), 900); 897 } 898 899 //// Test chain of length 10 with late-property-addition at depth 7 900 function runChain_10_7(obj) { 901 var sum = 0; 902 for (var i = 0; i < 100; i++) 903 sum += obj.foo; 904 return sum; 905 } 906 function testChain_10_7() { 907 var obj = createTower(10); 908 assertEq(runChain_10_7(obj), NaN); 909 updateChain(obj, 7, 'foo', 9); 910 assertEq(runChain_10_7(obj), 900); 911 } 912 913 //// Test chain of length 10 with late-property-addition at depth 8 914 function runChain_10_8(obj) { 915 var sum = 0; 916 for (var i = 0; i < 100; i++) 917 sum += obj.foo; 918 return sum; 919 } 920 function testChain_10_8() { 921 var obj = createTower(10); 922 assertEq(runChain_10_8(obj), NaN); 923 updateChain(obj, 8, 'foo', 9); 924 assertEq(runChain_10_8(obj), 900); 925 } 926 927 //// Test chain of length 10 with late-property-addition at depth 9 928 function runChain_10_9(obj) { 929 var sum = 0; 930 for (var i = 0; i < 100; i++) 931 sum += obj.foo; 932 return sum; 933 } 934 function testChain_10_9() { 935 var obj = createTower(10); 936 assertEq(runChain_10_9(obj), NaN); 937 updateChain(obj, 9, 'foo', 9); 938 assertEq(runChain_10_9(obj), 900); 939 } 940 941 //// Test chain of length 10 with late-property-addition at depth 10 942 function runChain_10_10(obj) { 943 var sum = 0; 944 for (var i = 0; i < 100; i++) 945 sum += obj.foo; 946 return sum; 947 } 948 function testChain_10_10() { 949 var obj = createTower(10); 950 assertEq(runChain_10_10(obj), NaN); 951 updateChain(obj, 10, 'foo', 9); 952 assertEq(runChain_10_10(obj), 900); 953 } 954 955 956 ///////////////////////////////////////// 957 // RUNNER // 958 ///////////////////////////////////////// 959 960 testChain_0_0(); 961 testChain_1_0(); 962 testChain_1_1(); 963 testChain_2_0(); 964 testChain_2_1(); 965 testChain_2_2(); 966 testChain_3_0(); 967 testChain_3_1(); 968 testChain_3_2(); 969 testChain_3_3(); 970 testChain_4_0(); 971 testChain_4_1(); 972 testChain_4_2(); 973 testChain_4_3(); 974 testChain_4_4(); 975 testChain_5_0(); 976 testChain_5_1(); 977 testChain_5_2(); 978 testChain_5_3(); 979 testChain_5_4(); 980 testChain_5_5(); 981 testChain_6_0(); 982 testChain_6_1(); 983 testChain_6_2(); 984 testChain_6_3(); 985 testChain_6_4(); 986 testChain_6_5(); 987 testChain_6_6(); 988 testChain_7_0(); 989 testChain_7_1(); 990 testChain_7_2(); 991 testChain_7_3(); 992 testChain_7_4(); 993 testChain_7_5(); 994 testChain_7_6(); 995 testChain_7_7(); 996 testChain_8_0(); 997 testChain_8_1(); 998 testChain_8_2(); 999 testChain_8_3(); 1000 testChain_8_4(); 1001 testChain_8_5(); 1002 testChain_8_6(); 1003 testChain_8_7(); 1004 testChain_8_8(); 1005 testChain_9_0(); 1006 testChain_9_1(); 1007 testChain_9_2(); 1008 testChain_9_3(); 1009 testChain_9_4(); 1010 testChain_9_5(); 1011 testChain_9_6(); 1012 testChain_9_7(); 1013 testChain_9_8(); 1014 testChain_9_9(); 1015 testChain_10_0(); 1016 testChain_10_1(); 1017 testChain_10_2(); 1018 testChain_10_3(); 1019 testChain_10_4(); 1020 testChain_10_5(); 1021 testChain_10_6(); 1022 testChain_10_7(); 1023 testChain_10_8(); 1024 testChain_10_9(); 1025 testChain_10_10();