dom/indexedDB/test/unit/test_optionalArguments.js

   1 /**
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/publicdomain/zero/1.0/
   4  */
   5
   6 var testGenerator = testSteps();
   7
   8 function* testSteps() {
   9   const osName = "people";
  10   const indexName = "weight";
  11
  12   const data = [
  13     { ssn: "237-23-7732", name: "Bob", height: 60, weight: 120 },
  14     { ssn: "237-23-7733", name: "Ann", height: 52, weight: 110 },
  15     { ssn: "237-23-7734", name: "Ron", height: 73, weight: 180 },
  16     { ssn: "237-23-7735", name: "Sue", height: 58, weight: 130 },
  17     { ssn: "237-23-7736", name: "Joe", height: 65, weight: 150 },
  18     { ssn: "237-23-7737", name: "Pat", height: 65 },
  19     { ssn: "237-23-7738", name: "Mel", height: 66, weight: {} },
  20     { ssn: "237-23-7739", name: "Tom", height: 62, weight: 130 },
  21   ];
  22
  23   const weightSort = [1, 0, 3, 7, 4, 2];
  24
  25   let request = indexedDB.open(
  26     this.window ? window.location.pathname : "Splendid Test",
  27     1
  28   );
  29   request.onerror = errorHandler;
  30   request.onupgradeneeded = grabEventAndContinueHandler;
  31   request.onsuccess = grabEventAndContinueHandler;
  32   let event = yield undefined;
  33
  34   is(event.type, "upgradeneeded", "Got upgradeneeded event");
  35
  36   let db = event.target.result;
  37   db.onerror = errorHandler;
  38
  39   let objectStore = db.createObjectStore(osName, { keyPath: "ssn" });
  40   objectStore.createIndex(indexName, "weight", { unique: false });
  41
  42   for (let i of data) {
  43     objectStore.add(i);
  44   }
  45
  46   event = yield undefined;
  47
  48   is(event.type, "success", "Got success event");
  49
  50   try {
  51     IDBKeyRange.bound(1, -1);
  52     ok(false, "Bound keyRange with backwards args should throw!");
  53   } catch (e) {
  54     is(e.name, "DataError", "Threw correct exception");
  55     is(e.code, 0, "Threw with correct code");
  56   }
  57
  58   try {
  59     IDBKeyRange.bound(1, 1);
  60     ok(true, "Bound keyRange with same arg should be ok");
  61   } catch (e) {
  62     ok(false, "Bound keyRange with same arg should have been ok");
  63   }
  64
  65   try {
  66     IDBKeyRange.bound(1, 1, true);
  67     ok(false, "Bound keyRange with same arg and open should throw!");
  68   } catch (e) {
  69     is(e.name, "DataError", "Threw correct exception");
  70     is(e.code, 0, "Threw with correct code");
  71   }
  72
  73   try {
  74     IDBKeyRange.bound(1, 1, true, true);
  75     ok(false, "Bound keyRange with same arg and open should throw!");
  76   } catch (e) {
  77     is(e.name, "DataError", "Threw correct exception");
  78     is(e.code, 0, "Threw with correct code");
  79   }
  80
  81   objectStore = db.transaction(osName).objectStore(osName);
  82
  83   try {
  84     objectStore.get();
  85     ok(false, "Get with unspecified arg should have thrown");
  86   } catch (e) {
  87     ok(true, "Get with unspecified arg should have thrown");
  88   }
  89
  90   try {
  91     objectStore.get(undefined);
  92     ok(false, "Get with undefined should have thrown");
  93   } catch (e) {
  94     ok(true, "Get with undefined arg should have thrown");
  95   }
  96
  97   try {
  98     objectStore.get(null);
  99     ok(false, "Get with null should have thrown");
 100   } catch (e) {
 101     is(e instanceof DOMException, true, "Got right kind of exception");
 102     is(e.name, "DataError", "Correct error.");
 103     is(e.code, 0, "Correct code.");
 104   }
 105
 106   objectStore.get(data[2].ssn).onsuccess = grabEventAndContinueHandler;
 107   event = yield undefined;
 108
 109   is(event.target.result.name, data[2].name, "Correct data");
 110
 111   let keyRange = IDBKeyRange.only(data[2].ssn);
 112
 113   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 114   event = yield undefined;
 115
 116   is(event.target.result.name, data[2].name, "Correct data");
 117
 118   keyRange = IDBKeyRange.lowerBound(data[2].ssn);
 119
 120   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 121   event = yield undefined;
 122
 123   is(event.target.result.name, data[2].name, "Correct data");
 124
 125   keyRange = IDBKeyRange.lowerBound(data[2].ssn, true);
 126
 127   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 128   event = yield undefined;
 129
 130   is(event.target.result.name, data[3].name, "Correct data");
 131
 132   keyRange = IDBKeyRange.upperBound(data[2].ssn);
 133
 134   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 135   event = yield undefined;
 136
 137   is(event.target.result.name, data[0].name, "Correct data");
 138
 139   keyRange = IDBKeyRange.bound(data[2].ssn, data[4].ssn);
 140
 141   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 142   event = yield undefined;
 143
 144   is(event.target.result.name, data[2].name, "Correct data");
 145
 146   keyRange = IDBKeyRange.bound(data[2].ssn, data[4].ssn, true);
 147
 148   objectStore.get(keyRange).onsuccess = grabEventAndContinueHandler;
 149   event = yield undefined;
 150
 151   is(event.target.result.name, data[3].name, "Correct data");
 152
 153   objectStore = db.transaction(osName, "readwrite").objectStore(osName);
 154
 155   try {
 156     objectStore.delete();
 157     ok(false, "Delete with unspecified arg should have thrown");
 158   } catch (e) {
 159     ok(true, "Delete with unspecified arg should have thrown");
 160   }
 161
 162   try {
 163     objectStore.delete(undefined);
 164     ok(false, "Delete with undefined should have thrown");
 165   } catch (e) {
 166     ok(true, "Delete with undefined arg should have thrown");
 167   }
 168
 169   try {
 170     objectStore.delete(null);
 171     ok(false, "Delete with null should have thrown");
 172   } catch (e) {
 173     is(e instanceof DOMException, true, "Got right kind of exception");
 174     is(e.name, "DataError", "Correct error.");
 175     is(e.code, 0, "Correct code.");
 176   }
 177
 178   objectStore.count().onsuccess = grabEventAndContinueHandler;
 179   event = yield undefined;
 180
 181   is(event.target.result, data.length, "Correct count");
 182
 183   objectStore.delete(data[2].ssn).onsuccess = grabEventAndContinueHandler;
 184   event = yield undefined;
 185
 186   ok(event.target.result === undefined, "Correct result");
 187
 188   objectStore.count().onsuccess = grabEventAndContinueHandler;
 189   event = yield undefined;
 190
 191   is(event.target.result, data.length - 1, "Correct count");
 192
 193   keyRange = IDBKeyRange.bound(data[3].ssn, data[5].ssn);
 194
 195   objectStore.delete(keyRange).onsuccess = grabEventAndContinueHandler;
 196   event = yield undefined;
 197
 198   ok(event.target.result === undefined, "Correct result");
 199
 200   objectStore.count().onsuccess = grabEventAndContinueHandler;
 201   event = yield undefined;
 202
 203   is(event.target.result, data.length - 4, "Correct count");
 204
 205   keyRange = IDBKeyRange.lowerBound(10);
 206
 207   objectStore.delete(keyRange).onsuccess = grabEventAndContinueHandler;
 208   event = yield undefined;
 209
 210   ok(event.target.result === undefined, "Correct result");
 211
 212   objectStore.count().onsuccess = grabEventAndContinueHandler;
 213   event = yield undefined;
 214
 215   is(event.target.result, 0, "Correct count");
 216
 217   event.target.transaction.oncomplete = grabEventAndContinueHandler;
 218
 219   for (let i of data) {
 220     objectStore.add(i);
 221   }
 222
 223   yield undefined;
 224
 225   objectStore = db.transaction(osName).objectStore(osName);
 226
 227   objectStore.count().onsuccess = grabEventAndContinueHandler;
 228   event = yield undefined;
 229
 230   is(event.target.result, data.length, "Correct count");
 231
 232   let count = 0;
 233
 234   objectStore.openCursor().onsuccess = function(event) {
 235     let cursor = event.target.result;
 236     if (cursor) {
 237       count++;
 238       cursor.continue();
 239     } else {
 240       testGenerator.next();
 241     }
 242   };
 243   yield undefined;
 244
 245   is(count, data.length, "Correct count for no arg to openCursor");
 246
 247   count = 0;
 248
 249   objectStore.openCursor(null).onsuccess = function(event) {
 250     let cursor = event.target.result;
 251     if (cursor) {
 252       count++;
 253       cursor.continue();
 254     } else {
 255       testGenerator.next();
 256     }
 257   };
 258   yield undefined;
 259
 260   is(count, data.length, "Correct count for null arg to openCursor");
 261
 262   count = 0;
 263
 264   objectStore.openCursor(undefined).onsuccess = function(event) {
 265     let cursor = event.target.result;
 266     if (cursor) {
 267       count++;
 268       cursor.continue();
 269     } else {
 270       testGenerator.next();
 271     }
 272   };
 273   yield undefined;
 274
 275   is(count, data.length, "Correct count for undefined arg to openCursor");
 276
 277   count = 0;
 278
 279   objectStore.openCursor(data[2].ssn).onsuccess = function(event) {
 280     let cursor = event.target.result;
 281     if (cursor) {
 282       count++;
 283       cursor.continue();
 284     } else {
 285       testGenerator.next();
 286     }
 287   };
 288   yield undefined;
 289
 290   is(count, 1, "Correct count for single key arg to openCursor");
 291
 292   count = 0;
 293
 294   objectStore.openCursor("foo").onsuccess = function(event) {
 295     let cursor = event.target.result;
 296     if (cursor) {
 297       count++;
 298       cursor.continue();
 299     } else {
 300       testGenerator.next();
 301     }
 302   };
 303   yield undefined;
 304
 305   is(count, 0, "Correct count for non-existent single key arg to openCursor");
 306
 307   count = 0;
 308   keyRange = IDBKeyRange.only(data[2].ssn);
 309
 310   objectStore.openCursor(keyRange).onsuccess = function(event) {
 311     let cursor = event.target.result;
 312     if (cursor) {
 313       count++;
 314       cursor.continue();
 315     } else {
 316       testGenerator.next();
 317     }
 318   };
 319   yield undefined;
 320
 321   is(count, 1, "Correct count for only keyRange arg to openCursor");
 322
 323   count = 0;
 324   keyRange = IDBKeyRange.lowerBound(data[2].ssn);
 325
 326   objectStore.openCursor(keyRange).onsuccess = function(event) {
 327     let cursor = event.target.result;
 328     if (cursor) {
 329       count++;
 330       cursor.continue();
 331     } else {
 332       testGenerator.next();
 333     }
 334   };
 335   yield undefined;
 336
 337   is(count, data.length - 2, "Correct count for lowerBound arg to openCursor");
 338
 339   count = 0;
 340   keyRange = IDBKeyRange.lowerBound(data[2].ssn, true);
 341
 342   objectStore.openCursor(keyRange).onsuccess = function(event) {
 343     let cursor = event.target.result;
 344     if (cursor) {
 345       count++;
 346       cursor.continue();
 347     } else {
 348       testGenerator.next();
 349     }
 350   };
 351   yield undefined;
 352
 353   is(count, data.length - 3, "Correct count for lowerBound arg to openCursor");
 354
 355   count = 0;
 356   keyRange = IDBKeyRange.lowerBound("foo");
 357
 358   objectStore.openCursor(keyRange).onsuccess = function(event) {
 359     let cursor = event.target.result;
 360     if (cursor) {
 361       count++;
 362       cursor.continue();
 363     } else {
 364       testGenerator.next();
 365     }
 366   };
 367   yield undefined;
 368
 369   is(count, 0, "Correct count for non-existent lowerBound arg to openCursor");
 370
 371   count = 0;
 372   keyRange = IDBKeyRange.bound(data[2].ssn, data[3].ssn);
 373
 374   objectStore.openCursor(keyRange).onsuccess = function(event) {
 375     let cursor = event.target.result;
 376     if (cursor) {
 377       count++;
 378       cursor.continue();
 379     } else {
 380       testGenerator.next();
 381     }
 382   };
 383   yield undefined;
 384
 385   is(count, 2, "Correct count for bound arg to openCursor");
 386
 387   count = 0;
 388   keyRange = IDBKeyRange.bound(data[2].ssn, data[3].ssn, true);
 389
 390   objectStore.openCursor(keyRange).onsuccess = function(event) {
 391     let cursor = event.target.result;
 392     if (cursor) {
 393       count++;
 394       cursor.continue();
 395     } else {
 396       testGenerator.next();
 397     }
 398   };
 399   yield undefined;
 400
 401   is(count, 1, "Correct count for bound arg to openCursor");
 402
 403   count = 0;
 404   keyRange = IDBKeyRange.bound(data[2].ssn, data[3].ssn, true, true);
 405
 406   objectStore.openCursor(keyRange).onsuccess = function(event) {
 407     let cursor = event.target.result;
 408     if (cursor) {
 409       count++;
 410       cursor.continue();
 411     } else {
 412       testGenerator.next();
 413     }
 414   };
 415   yield undefined;
 416
 417   is(count, 0, "Correct count for bound arg to openCursor");
 418
 419   let index = objectStore.index(indexName);
 420
 421   count = 0;
 422
 423   index.openKeyCursor().onsuccess = function(event) {
 424     let cursor = event.target.result;
 425     if (cursor) {
 426       count++;
 427       cursor.continue();
 428     } else {
 429       testGenerator.next();
 430     }
 431   };
 432   yield undefined;
 433
 434   is(
 435     count,
 436     weightSort.length,
 437     "Correct count for unspecified arg to index.openKeyCursor"
 438   );
 439
 440   count = 0;
 441
 442   index.openKeyCursor(null).onsuccess = function(event) {
 443     let cursor = event.target.result;
 444     if (cursor) {
 445       count++;
 446       cursor.continue();
 447     } else {
 448       testGenerator.next();
 449     }
 450   };
 451   yield undefined;
 452
 453   is(
 454     count,
 455     weightSort.length,
 456     "Correct count for null arg to index.openKeyCursor"
 457   );
 458
 459   count = 0;
 460
 461   index.openKeyCursor(undefined).onsuccess = function(event) {
 462     let cursor = event.target.result;
 463     if (cursor) {
 464       count++;
 465       cursor.continue();
 466     } else {
 467       testGenerator.next();
 468     }
 469   };
 470   yield undefined;
 471
 472   is(
 473     count,
 474     weightSort.length,
 475     "Correct count for undefined arg to index.openKeyCursor"
 476   );
 477
 478   count = 0;
 479
 480   index.openKeyCursor(data[0].weight).onsuccess = function(event) {
 481     let cursor = event.target.result;
 482     if (cursor) {
 483       count++;
 484       cursor.continue();
 485     } else {
 486       testGenerator.next();
 487     }
 488   };
 489   yield undefined;
 490
 491   is(count, 1, "Correct count for single key arg to index.openKeyCursor");
 492
 493   count = 0;
 494
 495   index.openKeyCursor("foo").onsuccess = function(event) {
 496     let cursor = event.target.result;
 497     if (cursor) {
 498       count++;
 499       cursor.continue();
 500     } else {
 501       testGenerator.next();
 502     }
 503   };
 504   yield undefined;
 505
 506   is(count, 0, "Correct count for non-existent key arg to index.openKeyCursor");
 507
 508   count = 0;
 509   keyRange = IDBKeyRange.only("foo");
 510
 511   index.openKeyCursor(keyRange).onsuccess = function(event) {
 512     let cursor = event.target.result;
 513     if (cursor) {
 514       count++;
 515       cursor.continue();
 516     } else {
 517       testGenerator.next();
 518     }
 519   };
 520   yield undefined;
 521
 522   is(
 523     count,
 524     0,
 525     "Correct count for non-existent keyRange arg to index.openKeyCursor"
 526   );
 527
 528   count = 0;
 529   keyRange = IDBKeyRange.only(data[0].weight);
 530
 531   index.openKeyCursor(keyRange).onsuccess = function(event) {
 532     let cursor = event.target.result;
 533     if (cursor) {
 534       count++;
 535       cursor.continue();
 536     } else {
 537       testGenerator.next();
 538     }
 539   };
 540   yield undefined;
 541
 542   is(count, 1, "Correct count for only keyRange arg to index.openKeyCursor");
 543
 544   count = 0;
 545   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight);
 546
 547   index.openKeyCursor(keyRange).onsuccess = function(event) {
 548     let cursor = event.target.result;
 549     if (cursor) {
 550       count++;
 551       cursor.continue();
 552     } else {
 553       testGenerator.next();
 554     }
 555   };
 556   yield undefined;
 557
 558   is(
 559     count,
 560     weightSort.length,
 561     "Correct count for lowerBound keyRange arg to index.openKeyCursor"
 562   );
 563
 564   count = 0;
 565   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight, true);
 566
 567   index.openKeyCursor(keyRange).onsuccess = function(event) {
 568     let cursor = event.target.result;
 569     if (cursor) {
 570       count++;
 571       cursor.continue();
 572     } else {
 573       testGenerator.next();
 574     }
 575   };
 576   yield undefined;
 577
 578   is(
 579     count,
 580     weightSort.length - 1,
 581     "Correct count for lowerBound keyRange arg to index.openKeyCursor"
 582   );
 583
 584   count = 0;
 585   keyRange = IDBKeyRange.lowerBound("foo");
 586
 587   index.openKeyCursor(keyRange).onsuccess = function(event) {
 588     let cursor = event.target.result;
 589     if (cursor) {
 590       count++;
 591       cursor.continue();
 592     } else {
 593       testGenerator.next();
 594     }
 595   };
 596   yield undefined;
 597
 598   is(
 599     count,
 600     0,
 601     "Correct count for lowerBound keyRange arg to index.openKeyCursor"
 602   );
 603
 604   count = 0;
 605   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight);
 606
 607   index.openKeyCursor(keyRange).onsuccess = function(event) {
 608     let cursor = event.target.result;
 609     if (cursor) {
 610       count++;
 611       cursor.continue();
 612     } else {
 613       testGenerator.next();
 614     }
 615   };
 616   yield undefined;
 617
 618   is(
 619     count,
 620     1,
 621     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 622   );
 623
 624   count = 0;
 625   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight, true);
 626
 627   index.openKeyCursor(keyRange).onsuccess = function(event) {
 628     let cursor = event.target.result;
 629     if (cursor) {
 630       count++;
 631       cursor.continue();
 632     } else {
 633       testGenerator.next();
 634     }
 635   };
 636   yield undefined;
 637
 638   is(
 639     count,
 640     0,
 641     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 642   );
 643
 644   count = 0;
 645   keyRange = IDBKeyRange.upperBound(
 646     data[weightSort[weightSort.length - 1]].weight
 647   );
 648
 649   index.openKeyCursor(keyRange).onsuccess = function(event) {
 650     let cursor = event.target.result;
 651     if (cursor) {
 652       count++;
 653       cursor.continue();
 654     } else {
 655       testGenerator.next();
 656     }
 657   };
 658   yield undefined;
 659
 660   is(
 661     count,
 662     weightSort.length,
 663     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 664   );
 665
 666   count = 0;
 667   keyRange = IDBKeyRange.upperBound(
 668     data[weightSort[weightSort.length - 1]].weight,
 669     true
 670   );
 671
 672   index.openKeyCursor(keyRange).onsuccess = function(event) {
 673     let cursor = event.target.result;
 674     if (cursor) {
 675       count++;
 676       cursor.continue();
 677     } else {
 678       testGenerator.next();
 679     }
 680   };
 681   yield undefined;
 682
 683   is(
 684     count,
 685     weightSort.length - 1,
 686     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 687   );
 688
 689   count = 0;
 690   keyRange = IDBKeyRange.upperBound("foo");
 691
 692   index.openKeyCursor(keyRange).onsuccess = function(event) {
 693     let cursor = event.target.result;
 694     if (cursor) {
 695       count++;
 696       cursor.continue();
 697     } else {
 698       testGenerator.next();
 699     }
 700   };
 701   yield undefined;
 702
 703   is(
 704     count,
 705     weightSort.length,
 706     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 707   );
 708
 709   count = 0;
 710   keyRange = IDBKeyRange.upperBound(0);
 711
 712   index.openKeyCursor(keyRange).onsuccess = function(event) {
 713     let cursor = event.target.result;
 714     if (cursor) {
 715       count++;
 716       cursor.continue();
 717     } else {
 718       testGenerator.next();
 719     }
 720   };
 721   yield undefined;
 722
 723   is(
 724     count,
 725     0,
 726     "Correct count for upperBound keyRange arg to index.openKeyCursor"
 727   );
 728
 729   count = 0;
 730   keyRange = IDBKeyRange.bound(
 731     data[weightSort[0]].weight,
 732     data[weightSort[weightSort.length - 1]].weight
 733   );
 734
 735   index.openKeyCursor(keyRange).onsuccess = function(event) {
 736     let cursor = event.target.result;
 737     if (cursor) {
 738       count++;
 739       cursor.continue();
 740     } else {
 741       testGenerator.next();
 742     }
 743   };
 744   yield undefined;
 745
 746   is(
 747     count,
 748     weightSort.length,
 749     "Correct count for bound keyRange arg to index.openKeyCursor"
 750   );
 751
 752   count = 0;
 753   keyRange = IDBKeyRange.bound(
 754     data[weightSort[0]].weight,
 755     data[weightSort[weightSort.length - 1]].weight,
 756     true
 757   );
 758
 759   index.openKeyCursor(keyRange).onsuccess = function(event) {
 760     let cursor = event.target.result;
 761     if (cursor) {
 762       count++;
 763       cursor.continue();
 764     } else {
 765       testGenerator.next();
 766     }
 767   };
 768   yield undefined;
 769
 770   is(
 771     count,
 772     weightSort.length - 1,
 773     "Correct count for bound keyRange arg to index.openKeyCursor"
 774   );
 775
 776   count = 0;
 777   keyRange = IDBKeyRange.bound(
 778     data[weightSort[0]].weight,
 779     data[weightSort[weightSort.length - 1]].weight,
 780     true,
 781     true
 782   );
 783
 784   index.openKeyCursor(keyRange).onsuccess = function(event) {
 785     let cursor = event.target.result;
 786     if (cursor) {
 787       count++;
 788       cursor.continue();
 789     } else {
 790       testGenerator.next();
 791     }
 792   };
 793   yield undefined;
 794
 795   is(
 796     count,
 797     weightSort.length - 2,
 798     "Correct count for bound keyRange arg to index.openKeyCursor"
 799   );
 800
 801   count = 0;
 802   keyRange = IDBKeyRange.bound(
 803     data[weightSort[0]].weight - 1,
 804     data[weightSort[weightSort.length - 1]].weight + 1
 805   );
 806
 807   index.openKeyCursor(keyRange).onsuccess = function(event) {
 808     let cursor = event.target.result;
 809     if (cursor) {
 810       count++;
 811       cursor.continue();
 812     } else {
 813       testGenerator.next();
 814     }
 815   };
 816   yield undefined;
 817
 818   is(
 819     count,
 820     weightSort.length,
 821     "Correct count for bound keyRange arg to index.openKeyCursor"
 822   );
 823
 824   count = 0;
 825   keyRange = IDBKeyRange.bound(
 826     data[weightSort[0]].weight - 2,
 827     data[weightSort[0]].weight - 1
 828   );
 829
 830   index.openKeyCursor(keyRange).onsuccess = function(event) {
 831     let cursor = event.target.result;
 832     if (cursor) {
 833       count++;
 834       cursor.continue();
 835     } else {
 836       testGenerator.next();
 837     }
 838   };
 839   yield undefined;
 840
 841   is(count, 0, "Correct count for bound keyRange arg to index.openKeyCursor");
 842
 843   count = 0;
 844   keyRange = IDBKeyRange.bound(
 845     data[weightSort[1]].weight,
 846     data[weightSort[2]].weight
 847   );
 848
 849   index.openKeyCursor(keyRange).onsuccess = function(event) {
 850     let cursor = event.target.result;
 851     if (cursor) {
 852       count++;
 853       cursor.continue();
 854     } else {
 855       testGenerator.next();
 856     }
 857   };
 858   yield undefined;
 859
 860   is(count, 3, "Correct count for bound keyRange arg to index.openKeyCursor");
 861
 862   count = 0;
 863
 864   index.openCursor().onsuccess = function(event) {
 865     let cursor = event.target.result;
 866     if (cursor) {
 867       count++;
 868       cursor.continue();
 869     } else {
 870       testGenerator.next();
 871     }
 872   };
 873   yield undefined;
 874
 875   is(
 876     count,
 877     weightSort.length,
 878     "Correct count for unspecified arg to index.openCursor"
 879   );
 880
 881   count = 0;
 882
 883   index.openCursor(null).onsuccess = function(event) {
 884     let cursor = event.target.result;
 885     if (cursor) {
 886       count++;
 887       cursor.continue();
 888     } else {
 889       testGenerator.next();
 890     }
 891   };
 892   yield undefined;
 893
 894   is(
 895     count,
 896     weightSort.length,
 897     "Correct count for null arg to index.openCursor"
 898   );
 899
 900   count = 0;
 901
 902   index.openCursor(undefined).onsuccess = function(event) {
 903     let cursor = event.target.result;
 904     if (cursor) {
 905       count++;
 906       cursor.continue();
 907     } else {
 908       testGenerator.next();
 909     }
 910   };
 911   yield undefined;
 912
 913   is(
 914     count,
 915     weightSort.length,
 916     "Correct count for undefined arg to index.openCursor"
 917   );
 918
 919   count = 0;
 920
 921   index.openCursor(data[0].weight).onsuccess = function(event) {
 922     let cursor = event.target.result;
 923     if (cursor) {
 924       count++;
 925       cursor.continue();
 926     } else {
 927       testGenerator.next();
 928     }
 929   };
 930   yield undefined;
 931
 932   is(count, 1, "Correct count for single key arg to index.openCursor");
 933
 934   count = 0;
 935
 936   index.openCursor("foo").onsuccess = function(event) {
 937     let cursor = event.target.result;
 938     if (cursor) {
 939       count++;
 940       cursor.continue();
 941     } else {
 942       testGenerator.next();
 943     }
 944   };
 945   yield undefined;
 946
 947   is(count, 0, "Correct count for non-existent key arg to index.openCursor");
 948
 949   count = 0;
 950   keyRange = IDBKeyRange.only("foo");
 951
 952   index.openCursor(keyRange).onsuccess = function(event) {
 953     let cursor = event.target.result;
 954     if (cursor) {
 955       count++;
 956       cursor.continue();
 957     } else {
 958       testGenerator.next();
 959     }
 960   };
 961   yield undefined;
 962
 963   is(
 964     count,
 965     0,
 966     "Correct count for non-existent keyRange arg to index.openCursor"
 967   );
 968
 969   count = 0;
 970   keyRange = IDBKeyRange.only(data[0].weight);
 971
 972   index.openCursor(keyRange).onsuccess = function(event) {
 973     let cursor = event.target.result;
 974     if (cursor) {
 975       count++;
 976       cursor.continue();
 977     } else {
 978       testGenerator.next();
 979     }
 980   };
 981   yield undefined;
 982
 983   is(count, 1, "Correct count for only keyRange arg to index.openCursor");
 984
 985   count = 0;
 986   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight);
 987
 988   index.openCursor(keyRange).onsuccess = function(event) {
 989     let cursor = event.target.result;
 990     if (cursor) {
 991       count++;
 992       cursor.continue();
 993     } else {
 994       testGenerator.next();
 995     }
 996   };
 997   yield undefined;
 998
 999   is(
1000     count,
1001     weightSort.length,
1002     "Correct count for lowerBound keyRange arg to index.openCursor"
1003   );
1004
1005   count = 0;
1006   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight, true);
1007
1008   index.openCursor(keyRange).onsuccess = function(event) {
1009     let cursor = event.target.result;
1010     if (cursor) {
1011       count++;
1012       cursor.continue();
1013     } else {
1014       testGenerator.next();
1015     }
1016   };
1017   yield undefined;
1018
1019   is(
1020     count,
1021     weightSort.length - 1,
1022     "Correct count for lowerBound keyRange arg to index.openCursor"
1023   );
1024
1025   count = 0;
1026   keyRange = IDBKeyRange.lowerBound("foo");
1027
1028   index.openCursor(keyRange).onsuccess = function(event) {
1029     let cursor = event.target.result;
1030     if (cursor) {
1031       count++;
1032       cursor.continue();
1033     } else {
1034       testGenerator.next();
1035     }
1036   };
1037   yield undefined;
1038
1039   is(count, 0, "Correct count for lowerBound keyRange arg to index.openCursor");
1040
1041   count = 0;
1042   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight);
1043
1044   index.openCursor(keyRange).onsuccess = function(event) {
1045     let cursor = event.target.result;
1046     if (cursor) {
1047       count++;
1048       cursor.continue();
1049     } else {
1050       testGenerator.next();
1051     }
1052   };
1053   yield undefined;
1054
1055   is(count, 1, "Correct count for upperBound keyRange arg to index.openCursor");
1056
1057   count = 0;
1058   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight, true);
1059
1060   index.openCursor(keyRange).onsuccess = function(event) {
1061     let cursor = event.target.result;
1062     if (cursor) {
1063       count++;
1064       cursor.continue();
1065     } else {
1066       testGenerator.next();
1067     }
1068   };
1069   yield undefined;
1070
1071   is(count, 0, "Correct count for upperBound keyRange arg to index.openCursor");
1072
1073   count = 0;
1074   keyRange = IDBKeyRange.upperBound(
1075     data[weightSort[weightSort.length - 1]].weight
1076   );
1077
1078   index.openCursor(keyRange).onsuccess = function(event) {
1079     let cursor = event.target.result;
1080     if (cursor) {
1081       count++;
1082       cursor.continue();
1083     } else {
1084       testGenerator.next();
1085     }
1086   };
1087   yield undefined;
1088
1089   is(
1090     count,
1091     weightSort.length,
1092     "Correct count for upperBound keyRange arg to index.openCursor"
1093   );
1094
1095   count = 0;
1096   keyRange = IDBKeyRange.upperBound(
1097     data[weightSort[weightSort.length - 1]].weight,
1098     true
1099   );
1100
1101   index.openCursor(keyRange).onsuccess = function(event) {
1102     let cursor = event.target.result;
1103     if (cursor) {
1104       count++;
1105       cursor.continue();
1106     } else {
1107       testGenerator.next();
1108     }
1109   };
1110   yield undefined;
1111
1112   is(
1113     count,
1114     weightSort.length - 1,
1115     "Correct count for upperBound keyRange arg to index.openCursor"
1116   );
1117
1118   count = 0;
1119   keyRange = IDBKeyRange.upperBound("foo");
1120
1121   index.openCursor(keyRange).onsuccess = function(event) {
1122     let cursor = event.target.result;
1123     if (cursor) {
1124       count++;
1125       cursor.continue();
1126     } else {
1127       testGenerator.next();
1128     }
1129   };
1130   yield undefined;
1131
1132   is(
1133     count,
1134     weightSort.length,
1135     "Correct count for upperBound keyRange arg to index.openCursor"
1136   );
1137
1138   count = 0;
1139   keyRange = IDBKeyRange.upperBound(0);
1140
1141   index.openCursor(keyRange).onsuccess = function(event) {
1142     let cursor = event.target.result;
1143     if (cursor) {
1144       count++;
1145       cursor.continue();
1146     } else {
1147       testGenerator.next();
1148     }
1149   };
1150   yield undefined;
1151
1152   is(count, 0, "Correct count for upperBound keyRange arg to index.openCursor");
1153
1154   count = 0;
1155   keyRange = IDBKeyRange.bound(
1156     data[weightSort[0]].weight,
1157     data[weightSort[weightSort.length - 1]].weight
1158   );
1159
1160   index.openCursor(keyRange).onsuccess = function(event) {
1161     let cursor = event.target.result;
1162     if (cursor) {
1163       count++;
1164       cursor.continue();
1165     } else {
1166       testGenerator.next();
1167     }
1168   };
1169   yield undefined;
1170
1171   is(
1172     count,
1173     weightSort.length,
1174     "Correct count for bound keyRange arg to index.openCursor"
1175   );
1176
1177   count = 0;
1178   keyRange = IDBKeyRange.bound(
1179     data[weightSort[0]].weight,
1180     data[weightSort[weightSort.length - 1]].weight,
1181     true
1182   );
1183
1184   index.openCursor(keyRange).onsuccess = function(event) {
1185     let cursor = event.target.result;
1186     if (cursor) {
1187       count++;
1188       cursor.continue();
1189     } else {
1190       testGenerator.next();
1191     }
1192   };
1193   yield undefined;
1194
1195   is(
1196     count,
1197     weightSort.length - 1,
1198     "Correct count for bound keyRange arg to index.openCursor"
1199   );
1200
1201   count = 0;
1202   keyRange = IDBKeyRange.bound(
1203     data[weightSort[0]].weight,
1204     data[weightSort[weightSort.length - 1]].weight,
1205     true,
1206     true
1207   );
1208
1209   index.openCursor(keyRange).onsuccess = function(event) {
1210     let cursor = event.target.result;
1211     if (cursor) {
1212       count++;
1213       cursor.continue();
1214     } else {
1215       testGenerator.next();
1216     }
1217   };
1218   yield undefined;
1219
1220   is(
1221     count,
1222     weightSort.length - 2,
1223     "Correct count for bound keyRange arg to index.openCursor"
1224   );
1225
1226   count = 0;
1227   keyRange = IDBKeyRange.bound(
1228     data[weightSort[0]].weight - 1,
1229     data[weightSort[weightSort.length - 1]].weight + 1
1230   );
1231
1232   index.openCursor(keyRange).onsuccess = function(event) {
1233     let cursor = event.target.result;
1234     if (cursor) {
1235       count++;
1236       cursor.continue();
1237     } else {
1238       testGenerator.next();
1239     }
1240   };
1241   yield undefined;
1242
1243   is(
1244     count,
1245     weightSort.length,
1246     "Correct count for bound keyRange arg to index.openCursor"
1247   );
1248
1249   count = 0;
1250   keyRange = IDBKeyRange.bound(
1251     data[weightSort[0]].weight - 2,
1252     data[weightSort[0]].weight - 1
1253   );
1254
1255   index.openCursor(keyRange).onsuccess = function(event) {
1256     let cursor = event.target.result;
1257     if (cursor) {
1258       count++;
1259       cursor.continue();
1260     } else {
1261       testGenerator.next();
1262     }
1263   };
1264   yield undefined;
1265
1266   is(count, 0, "Correct count for bound keyRange arg to index.openCursor");
1267
1268   count = 0;
1269   keyRange = IDBKeyRange.bound(
1270     data[weightSort[1]].weight,
1271     data[weightSort[2]].weight
1272   );
1273
1274   index.openCursor(keyRange).onsuccess = function(event) {
1275     let cursor = event.target.result;
1276     if (cursor) {
1277       count++;
1278       cursor.continue();
1279     } else {
1280       testGenerator.next();
1281     }
1282   };
1283   yield undefined;
1284
1285   is(count, 3, "Correct count for bound keyRange arg to index.openCursor");
1286
1287   try {
1288     index.get();
1289     ok(false, "Get with unspecified arg should have thrown");
1290   } catch (e) {
1291     ok(true, "Get with unspecified arg should have thrown");
1292   }
1293
1294   try {
1295     index.get(undefined);
1296     ok(false, "Get with undefined should have thrown");
1297   } catch (e) {
1298     ok(true, "Get with undefined arg should have thrown");
1299   }
1300
1301   try {
1302     index.get(null);
1303     ok(false, "Get with null should have thrown");
1304   } catch (e) {
1305     is(e instanceof DOMException, true, "Got right kind of exception");
1306     is(e.name, "DataError", "Correct error.");
1307     is(e.code, 0, "Correct code.");
1308   }
1309
1310   index.get(data[0].weight).onsuccess = grabEventAndContinueHandler;
1311   event = yield undefined;
1312
1313   is(event.target.result.weight, data[0].weight, "Got correct result");
1314
1315   keyRange = IDBKeyRange.only(data[0].weight);
1316
1317   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1318   event = yield undefined;
1319
1320   is(event.target.result.weight, data[0].weight, "Got correct result");
1321
1322   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight);
1323
1324   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1325   event = yield undefined;
1326
1327   is(
1328     event.target.result.weight,
1329     data[weightSort[0]].weight,
1330     "Got correct result"
1331   );
1332
1333   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight - 1);
1334
1335   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1336   event = yield undefined;
1337
1338   is(
1339     event.target.result.weight,
1340     data[weightSort[0]].weight,
1341     "Got correct result"
1342   );
1343
1344   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight + 1);
1345
1346   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1347   event = yield undefined;
1348
1349   is(
1350     event.target.result.weight,
1351     data[weightSort[1]].weight,
1352     "Got correct result"
1353   );
1354
1355   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight, true);
1356
1357   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1358   event = yield undefined;
1359
1360   is(
1361     event.target.result.weight,
1362     data[weightSort[1]].weight,
1363     "Got correct result"
1364   );
1365
1366   keyRange = IDBKeyRange.bound(
1367     data[weightSort[0]].weight,
1368     data[weightSort[1]].weight
1369   );
1370
1371   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1372   event = yield undefined;
1373
1374   is(
1375     event.target.result.weight,
1376     data[weightSort[0]].weight,
1377     "Got correct result"
1378   );
1379
1380   keyRange = IDBKeyRange.bound(
1381     data[weightSort[0]].weight,
1382     data[weightSort[1]].weight,
1383     true
1384   );
1385
1386   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1387   event = yield undefined;
1388
1389   is(
1390     event.target.result.weight,
1391     data[weightSort[1]].weight,
1392     "Got correct result"
1393   );
1394
1395   keyRange = IDBKeyRange.bound(
1396     data[weightSort[0]].weight,
1397     data[weightSort[1]].weight,
1398     true,
1399     true
1400   );
1401
1402   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1403   event = yield undefined;
1404
1405   is(event.target.result, undefined, "Got correct result");
1406
1407   keyRange = IDBKeyRange.upperBound(data[weightSort[5]].weight);
1408
1409   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1410   event = yield undefined;
1411
1412   is(
1413     event.target.result.weight,
1414     data[weightSort[0]].weight,
1415     "Got correct result"
1416   );
1417
1418   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight, true);
1419
1420   index.get(keyRange).onsuccess = grabEventAndContinueHandler;
1421   event = yield undefined;
1422
1423   is(event.target.result, undefined, "Got correct result");
1424
1425   try {
1426     index.getKey();
1427     ok(false, "Get with unspecified arg should have thrown");
1428   } catch (e) {
1429     ok(true, "Get with unspecified arg should have thrown");
1430   }
1431
1432   try {
1433     index.getKey(undefined);
1434     ok(false, "Get with undefined should have thrown");
1435   } catch (e) {
1436     ok(true, "Get with undefined arg should have thrown");
1437   }
1438
1439   try {
1440     index.getKey(null);
1441     ok(false, "Get with null should have thrown");
1442   } catch (e) {
1443     is(e instanceof DOMException, true, "Got right kind of exception");
1444     is(e.name, "DataError", "Correct error.");
1445     is(e.code, 0, "Correct code.");
1446   }
1447
1448   index.getKey(data[0].weight).onsuccess = grabEventAndContinueHandler;
1449   event = yield undefined;
1450
1451   is(event.target.result, data[0].ssn, "Got correct result");
1452
1453   keyRange = IDBKeyRange.only(data[0].weight);
1454
1455   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1456   event = yield undefined;
1457
1458   is(event.target.result, data[0].ssn, "Got correct result");
1459
1460   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight);
1461
1462   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1463   event = yield undefined;
1464
1465   is(event.target.result, data[weightSort[0]].ssn, "Got correct result");
1466
1467   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight - 1);
1468
1469   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1470   event = yield undefined;
1471
1472   is(event.target.result, data[weightSort[0]].ssn, "Got correct result");
1473
1474   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight + 1);
1475
1476   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1477   event = yield undefined;
1478
1479   is(event.target.result, data[weightSort[1]].ssn, "Got correct result");
1480
1481   keyRange = IDBKeyRange.lowerBound(data[weightSort[0]].weight, true);
1482
1483   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1484   event = yield undefined;
1485
1486   is(event.target.result, data[weightSort[1]].ssn, "Got correct result");
1487
1488   keyRange = IDBKeyRange.bound(
1489     data[weightSort[0]].weight,
1490     data[weightSort[1]].weight
1491   );
1492
1493   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1494   event = yield undefined;
1495
1496   is(event.target.result, data[weightSort[0]].ssn, "Got correct result");
1497
1498   keyRange = IDBKeyRange.bound(
1499     data[weightSort[0]].weight,
1500     data[weightSort[1]].weight,
1501     true
1502   );
1503
1504   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1505   event = yield undefined;
1506
1507   is(event.target.result, data[weightSort[1]].ssn, "Got correct result");
1508
1509   keyRange = IDBKeyRange.bound(
1510     data[weightSort[0]].weight,
1511     data[weightSort[1]].weight,
1512     true,
1513     true
1514   );
1515
1516   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1517   event = yield undefined;
1518
1519   is(event.target.result, undefined, "Got correct result");
1520
1521   keyRange = IDBKeyRange.upperBound(data[weightSort[5]].weight);
1522
1523   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1524   event = yield undefined;
1525
1526   is(event.target.result, data[weightSort[0]].ssn, "Got correct result");
1527
1528   keyRange = IDBKeyRange.upperBound(data[weightSort[0]].weight, true);
1529
1530   index.getKey(keyRange).onsuccess = grabEventAndContinueHandler;
1531   event = yield undefined;
1532
1533   is(event.target.result, undefined, "Got correct result");
1534
1535   count = 0;
1536
1537   index.openKeyCursor().onsuccess = function(event) {
1538     let cursor = event.target.result;
1539     if (cursor) {
1540       count++;
1541       cursor.continue();
1542     } else {
1543       testGenerator.next();
1544     }
1545   };
1546   yield undefined;
1547
1548   is(
1549     count,
1550     weightSort.length,
1551     "Correct count for no arg to index.openKeyCursor"
1552   );
1553
1554   count = 0;
1555
1556   index.openKeyCursor(null).onsuccess = function(event) {
1557     let cursor = event.target.result;
1558     if (cursor) {
1559       count++;
1560       cursor.continue();
1561     } else {
1562       testGenerator.next();
1563     }
1564   };
1565   yield undefined;
1566
1567   is(
1568     count,
1569     weightSort.length,
1570     "Correct count for null arg to index.openKeyCursor"
1571   );
1572
1573   count = 0;
1574
1575   index.openKeyCursor(undefined).onsuccess = function(event) {
1576     let cursor = event.target.result;
1577     if (cursor) {
1578       count++;
1579       cursor.continue();
1580     } else {
1581       testGenerator.next();
1582     }
1583   };
1584   yield undefined;
1585
1586   is(
1587     count,
1588     weightSort.length,
1589     "Correct count for undefined arg to index.openKeyCursor"
1590   );
1591
1592   count = 0;
1593
1594   index.openKeyCursor(data[weightSort[0]].weight).onsuccess = function(event) {
1595     let cursor = event.target.result;
1596     if (cursor) {
1597       count++;
1598       cursor.continue();
1599     } else {
1600       testGenerator.next();
1601     }
1602   };
1603   yield undefined;
1604
1605   is(count, 1, "Correct count for single key arg to index.openKeyCursor");
1606
1607   count = 0;
1608
1609   index.openKeyCursor("foo").onsuccess = function(event) {
1610     let cursor = event.target.result;
1611     if (cursor) {
1612       count++;
1613       cursor.continue();
1614     } else {
1615       testGenerator.next();
1616     }
1617   };
1618   yield undefined;
1619
1620   is(
1621     count,
1622     0,
1623     "Correct count for non-existent single key arg to index.openKeyCursor"
1624   );
1625
1626   count = 0;
1627   keyRange = IDBKeyRange.only(data[weightSort[0]].weight);
1628
1629   index.openKeyCursor(keyRange).onsuccess = function(event) {
1630     let cursor = event.target.result;
1631     if (cursor) {
1632       count++;
1633       cursor.continue();
1634     } else {
1635       testGenerator.next();
1636     }
1637   };
1638   yield undefined;
1639
1640   is(count, 1, "Correct count for only keyRange arg to index.openKeyCursor");
1641
1642   objectStore.mozGetAll(data[1].ssn).onsuccess = grabEventAndContinueHandler;
1643   event = yield undefined;
1644
1645   is(event.target.result instanceof Array, true, "Got an array");
1646   is(event.target.result.length, 1, "Got correct length");
1647   is(event.target.result[0].ssn, data[1].ssn, "Got correct result");
1648
1649   objectStore.mozGetAll(null).onsuccess = grabEventAndContinueHandler;
1650   event = yield undefined;
1651
1652   is(event.target.result instanceof Array, true, "Got an array");
1653   is(event.target.result.length, data.length, "Got correct length");
1654   for (let i in event.target.result) {
1655     is(event.target.result[i].ssn, data[i].ssn, "Got correct value");
1656   }
1657
1658   objectStore.mozGetAll(undefined).onsuccess = grabEventAndContinueHandler;
1659   event = yield undefined;
1660
1661   is(event.target.result instanceof Array, true, "Got an array");
1662   is(event.target.result.length, data.length, "Got correct length");
1663   for (let i in event.target.result) {
1664     is(event.target.result[i].ssn, data[i].ssn, "Got correct value");
1665   }
1666
1667   objectStore.mozGetAll().onsuccess = grabEventAndContinueHandler;
1668   event = yield undefined;
1669
1670   is(event.target.result instanceof Array, true, "Got an array");
1671   is(event.target.result.length, data.length, "Got correct length");
1672   for (let i in event.target.result) {
1673     is(event.target.result[i].ssn, data[i].ssn, "Got correct value");
1674   }
1675
1676   keyRange = IDBKeyRange.lowerBound(0);
1677
1678   objectStore.mozGetAll(keyRange).onsuccess = grabEventAndContinueHandler;
1679   event = yield undefined;
1680
1681   is(event.target.result instanceof Array, true, "Got an array");
1682   is(event.target.result.length, data.length, "Got correct length");
1683   for (let i in event.target.result) {
1684     is(event.target.result[i].ssn, data[i].ssn, "Got correct value");
1685   }
1686
1687   index.mozGetAll().onsuccess = grabEventAndContinueHandler;
1688   event = yield undefined;
1689
1690   is(event.target.result instanceof Array, true, "Got an array");
1691   is(event.target.result.length, weightSort.length, "Got correct length");
1692   for (let i in event.target.result) {
1693     is(
1694       event.target.result[i].ssn,
1695       data[weightSort[i]].ssn,
1696       "Got correct value"
1697     );
1698   }
1699
1700   index.mozGetAll(undefined).onsuccess = grabEventAndContinueHandler;
1701   event = yield undefined;
1702
1703   is(event.target.result instanceof Array, true, "Got an array");
1704   is(event.target.result.length, weightSort.length, "Got correct length");
1705   for (let i in event.target.result) {
1706     is(
1707       event.target.result[i].ssn,
1708       data[weightSort[i]].ssn,
1709       "Got correct value"
1710     );
1711   }
1712
1713   index.mozGetAll(null).onsuccess = grabEventAndContinueHandler;
1714   event = yield undefined;
1715
1716   is(event.target.result instanceof Array, true, "Got an array");
1717   is(event.target.result.length, weightSort.length, "Got correct length");
1718   for (let i in event.target.result) {
1719     is(
1720       event.target.result[i].ssn,
1721       data[weightSort[i]].ssn,
1722       "Got correct value"
1723     );
1724   }
1725
1726   index.mozGetAll(
1727     data[weightSort[0]].weight
1728   ).onsuccess = grabEventAndContinueHandler;
1729   event = yield undefined;
1730
1731   is(event.target.result instanceof Array, true, "Got an array");
1732   is(event.target.result.length, 1, "Got correct length");
1733   is(event.target.result[0].ssn, data[weightSort[0]].ssn, "Got correct result");
1734
1735   keyRange = IDBKeyRange.lowerBound(0);
1736
1737   index.mozGetAll(keyRange).onsuccess = grabEventAndContinueHandler;
1738   event = yield undefined;
1739
1740   is(event.target.result instanceof Array, true, "Got an array");
1741   is(event.target.result.length, weightSort.length, "Got correct length");
1742   for (let i in event.target.result) {
1743     is(
1744       event.target.result[i].ssn,
1745       data[weightSort[i]].ssn,
1746       "Got correct value"
1747     );
1748   }
1749
1750   index.mozGetAllKeys().onsuccess = grabEventAndContinueHandler;
1751   event = yield undefined;
1752
1753   is(event.target.result instanceof Array, true, "Got an array");
1754   is(event.target.result.length, weightSort.length, "Got correct length");
1755   for (let i in event.target.result) {
1756     is(event.target.result[i], data[weightSort[i]].ssn, "Got correct value");
1757   }
1758
1759   index.mozGetAllKeys(undefined).onsuccess = grabEventAndContinueHandler;
1760   event = yield undefined;
1761
1762   is(event.target.result instanceof Array, true, "Got an array");
1763   is(event.target.result.length, weightSort.length, "Got correct length");
1764   for (let i in event.target.result) {
1765     is(event.target.result[i], data[weightSort[i]].ssn, "Got correct value");
1766   }
1767
1768   index.mozGetAllKeys(null).onsuccess = grabEventAndContinueHandler;
1769   event = yield undefined;
1770
1771   is(event.target.result instanceof Array, true, "Got an array");
1772   is(event.target.result.length, weightSort.length, "Got correct length");
1773   for (let i in event.target.result) {
1774     is(event.target.result[i], data[weightSort[i]].ssn, "Got correct value");
1775   }
1776
1777   index.mozGetAllKeys(
1778     data[weightSort[0]].weight
1779   ).onsuccess = grabEventAndContinueHandler;
1780   event = yield undefined;
1781
1782   is(event.target.result instanceof Array, true, "Got an array");
1783   is(event.target.result.length, 1, "Got correct length");
1784   is(event.target.result[0], data[weightSort[0]].ssn, "Got correct result");
1785
1786   keyRange = IDBKeyRange.lowerBound(0);
1787
1788   index.mozGetAllKeys(keyRange).onsuccess = grabEventAndContinueHandler;
1789   event = yield undefined;
1790
1791   is(event.target.result instanceof Array, true, "Got an array");
1792   is(event.target.result.length, weightSort.length, "Got correct length");
1793   for (let i in event.target.result) {
1794     is(event.target.result[i], data[weightSort[i]].ssn, "Got correct value");
1795   }
1796
1797   finishTest();
1798 }