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