The Tor Browser: dom/indexedDB/test/unit/test_keys.js@6474c204b198 (annotated)

dom/indexedDB/test/unit/test_keys.js@6474c204b198 (annotated)

dom/indexedDB/test/unit/test_keys.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /**
  * Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 var testGenerator = testSteps();
 function testSteps()
 {
   const dbname = this.window ? window.location.pathname : "Splendid Test";
   const RW = "readwrite"
   let c1 = 1;
   let c2 = 1;
   let openRequest = indexedDB.open(dbname, 1);
   openRequest.onerror = errorHandler;
   openRequest.onupgradeneeded = grabEventAndContinueHandler;
   openRequest.onsuccess = unexpectedSuccessHandler;
   let event = yield undefined;
   let db = event.target.result;
   let trans = event.target.transaction;
   // Create test stores
   let store = db.createObjectStore("store");
     // Test simple inserts
   var keys = [
     -1/0,
     -1.7e308,
     -10000,
     -2,
     -1.5,
     -1,
     -1.00001e-200,
     -1e-200,
 ,
 e-200,
 .00001e-200,
 ,
 ,
 ,
 .7e308,
 /0,
     new Date("1750-01-02"),
     new Date("1800-12-31T12:34:56.001"),
     new Date(-1000),
     new Date(-10),
     new Date(-1),
     new Date(0),
     new Date(1),
     new Date(2),
     new Date(1000),
     new Date("1971-01-01"),
     new Date("1971-01-01T01:01:01Z"),
     new Date("1971-01-01T01:01:01.001Z"),
     new Date("1971-01-01T01:01:01.01Z"),
     new Date("1971-01-01T01:01:01.1Z"),
     new Date("1980-02-02"),
     new Date("3333-03-19T03:33:33.333"),
     "",
     "\x00",
     "\x00\x00",
     "\x00\x01",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x07",
     "\x08",
     "\x0F",
     "\x10",
     "\x1F",
     "\x20",
     "01234",
     "\x3F",
     "\x40",
     "A",
     "A\x00",
     "A1",
     "ZZZZ",
     "a",
     "a\x00",
     "aa",
     "azz",
     "}",
     "\x7E",
     "\x7F",
     "\x80",
     "\xFF",
     "\u0100",
     "\u01FF",
     "\u0200",
     "\u03FF",
     "\u0400",
     "\u07FF",
     "\u0800",
     "\u0FFF",
     "\u1000",
     "\u1FFF",
     "\u2000",
     "\u3FFF",
     "\u4000",
     "\u7FFF",
     "\u8000",
     "\uD800",
     "\uD800a",
     "\uD800\uDC01",
     "\uDBFF",
     "\uDC00",
     "\uDFFF\uD800",
     "\uFFFE",
     "\uFFFF",
      "\uFFFF\x00",
     "\uFFFFZZZ",
     [],
     [-1/0],
     [-1],
     [0],
     [1],
     [1, "a"],
     [1, []],
     [1, [""]],
     [2, 3],
     [2, 3.0000000000001],
     [12, [[]]],
     [12, [[[]]]],
     [12, [[[""]]]],
     [12, [[["foo"]]]],
     [12, [[[[[3]]]]]],
     [12, [[[[[[3]]]]]]],
     [new Date(-1)],
     [new Date(1)],
     [""],
     ["", [[]]],
     ["", [[[]]]],
     ["abc"],
     ["abc", "def"],
     ["abc\x00"],
     ["abc\x00", "\x00\x01"],
     ["abc\x00", "\x00def"],
     ["abc\x00\x00def"],
     ["x", [[]]],
     ["x", [[[]]]],
     [[]],
     [[],"foo"],
     [[],[]],
     [[[]]],
     [[[]], []],
     [[[]], [[]]],
     [[[]], [[1]]],
     [[[]], [[[]]]],
     [[[1]]],
     [[[[]], []]],
     ];
   for (var i = 0; i < keys.length; ++i) {
     let keyI = keys[i];
     is(indexedDB.cmp(keyI, keyI), 0, i + " compared to self");
     function doCompare(keyI) {
       for (var j = i-1; j >= i-10 && j >= 0; --j) {
         is(indexedDB.cmp(keyI, keys[j]), 1, i + " compared to " + j);
         is(indexedDB.cmp(keys[j], keyI), -1, j + " compared to " + i);
       }
     }
     doCompare(keyI);
     store.add(i, keyI).onsuccess = function(e) {
       is(indexedDB.cmp(e.target.result, keyI), 0,
          "Returned key should cmp as equal");
       ok(compareKeys(e.target.result, keyI),
          "Returned key should actually be equal");
     };
     // Test that -0 compares the same as 0
     if (keyI === 0) {
       doCompare(-0);
       let req = store.add(i, -0);
       req.addEventListener("error", new ExpectError("ConstraintError", true));
       req.onsuccess = unexpectedSuccessHandler;
       yield undefined;
     }
     else if (Array.isArray(keyI) && keyI.length === 1 && keyI[0] === 0) {
       doCompare([-0]);
       let req = store.add(i, [-0]);
       req.addEventListener("error", new ExpectError("ConstraintError", true));
       req.onsuccess = unexpectedSuccessHandler;
       yield undefined;
     }
   }
   store.openCursor().onsuccess = grabEventAndContinueHandler;
   for (i = 0; i < keys.length; ++i) {
     event = yield undefined;
     let cursor = event.target.result;
     is(indexedDB.cmp(cursor.key, keys[i]), 0,
        "Read back key should cmp as equal");
     ok(compareKeys(cursor.key, keys[i]),
        "Read back key should actually be equal");
     is(cursor.value, i, "Stored with right value");
     cursor.continue();
   }
   event = yield undefined;
   is(event.target.result, undefined, "no more results expected");
   var nan = 0/0;
   var invalidKeys = [
     nan,
     undefined,
     null,
     /x/,
     {},
     new Date(NaN),
     new Date("foopy"),
     [nan],
     [undefined],
     [null],
     [/x/],
     [{}],
     [new Date(NaN)],
     [1, nan],
     [1, undefined],
     [1, null],
     [1, /x/],
     [1, {}],
     [1, [nan]],
     [1, [undefined]],
     [1, [null]],
     [1, [/x/]],
     [1, [{}]],
     ];
   for (i = 0; i < invalidKeys.length; ++i) {
     try {
       indexedDB.cmp(invalidKeys[i], 1);
       ok(false, "didn't throw");
     }
     catch(ex) {
       ok(ex instanceof DOMException, "Threw DOMException");
       is(ex.name, "DataError", "Threw right DOMException");
       is(ex.code, 0, "Threw with right code");
     }
     try {
       indexedDB.cmp(1, invalidKeys[i]);
       ok(false, "didn't throw2");
     }
     catch(ex) {
       ok(ex instanceof DOMException, "Threw DOMException2");
       is(ex.name, "DataError", "Threw right DOMException2");
       is(ex.code, 0, "Threw with right code2");
     }
     try {
       store.put(1, invalidKeys[i]);
       ok(false, "didn't throw3");
     }
     catch(ex) {
       ok(ex instanceof DOMException, "Threw DOMException3");
       is(ex.name, "DataError", "Threw right DOMException3");
       is(ex.code, 0, "Threw with right code3");
     }
   }
   openRequest.onsuccess = grabEventAndContinueHandler;
   yield undefined;
   finishTest();
   yield undefined;
 }