The Tor Browser / file comparison
comparison: dom/indexedDB/test/unit/test_multientry.js
dom/indexedDB/test/unit/test_multientry.js
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:35ed7d396ae4 |
|---|---|
| 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 { | |
| 10 // Test object stores | |
| 11 | |
| 12 let name = this.window ? window.location.pathname : "Splendid Test"; | |
| 13 let openRequest = indexedDB.open(name, 1); | |
| 14 openRequest.onerror = errorHandler; | |
| 15 openRequest.onupgradeneeded = grabEventAndContinueHandler; | |
| 16 openRequest.onsuccess = unexpectedSuccessHandler; | |
| 17 let event = yield undefined; | |
| 18 let db = event.target.result; | |
| 19 db.onerror = errorHandler; | |
| 20 let tests = | |
| 21 [{ add: { x: 1, id: 1 }, | |
| 22 indexes:[{ v: 1, k: 1 }] }, | |
| 23 { add: { x: [2, 3], id: 2 }, | |
| 24 indexes:[{ v: 1, k: 1 }, | |
| 25 { v: 2, k: 2 }, | |
| 26 { v: 3, k: 2 }] }, | |
| 27 { put: { x: [2, 4], id: 1 }, | |
| 28 indexes:[{ v: 2, k: 1 }, | |
| 29 { v: 2, k: 2 }, | |
| 30 { v: 3, k: 2 }, | |
| 31 { v: 4, k: 1 }] }, | |
| 32 { add: { x: [5, 6, 5, -2, 3], id: 3 }, | |
| 33 indexes:[{ v:-2, k: 3 }, | |
| 34 { v: 2, k: 1 }, | |
| 35 { v: 2, k: 2 }, | |
| 36 { v: 3, k: 2 }, | |
| 37 { v: 3, k: 3 }, | |
| 38 { v: 4, k: 1 }, | |
| 39 { v: 5, k: 3 }, | |
| 40 { v: 6, k: 3 }] }, | |
| 41 { delete: IDBKeyRange.bound(1, 3), | |
| 42 indexes:[] }, | |
| 43 { put: { x: ["food", {}, false, undefined, /x/, [73, false]], id: 2 }, | |
| 44 indexes:[{ v: "food", k: 2 }] }, | |
| 45 { add: { x: [{}, /x/, -12, "food", null, [false], undefined], id: 3 }, | |
| 46 indexes:[{ v: -12, k: 3 }, | |
| 47 { v: "food", k: 2 }, | |
| 48 { v: "food", k: 3 }] }, | |
| 49 { put: { x: [], id: 2 }, | |
| 50 indexes:[{ v: -12, k: 3 }, | |
| 51 { v: "food", k: 3 }] }, | |
| 52 { put: { x: { y: 3 }, id: 3 }, | |
| 53 indexes:[] }, | |
| 54 { add: { x: false, id: 7 }, | |
| 55 indexes:[] }, | |
| 56 { delete: IDBKeyRange.lowerBound(0), | |
| 57 indexes:[] }, | |
| 58 ]; | |
| 59 | |
| 60 let store = db.createObjectStore("mystore", { keyPath: "id" }); | |
| 61 let index = store.createIndex("myindex", "x", { multiEntry: true }); | |
| 62 is(index.multiEntry, true, "index created with multiEntry"); | |
| 63 | |
| 64 let i; | |
| 65 for (i = 0; i < tests.length; ++i) { | |
| 66 let test = tests[i]; | |
| 67 let testName = " for " + JSON.stringify(test); | |
| 68 let req; | |
| 69 if (test.add) { | |
| 70 req = store.add(test.add); | |
| 71 } | |
| 72 else if (test.put) { | |
| 73 req = store.put(test.put); | |
| 74 } | |
| 75 else if (test.delete) { | |
| 76 req = store.delete(test.delete); | |
| 77 } | |
| 78 else { | |
| 79 ok(false, "borked test"); | |
| 80 } | |
| 81 req.onsuccess = grabEventAndContinueHandler; | |
| 82 let e = yield undefined; | |
| 83 | |
| 84 req = index.openKeyCursor(); | |
| 85 req.onsuccess = grabEventAndContinueHandler; | |
| 86 for (let j = 0; j < test.indexes.length; ++j) { | |
| 87 e = yield undefined; | |
| 88 is(req.result.key, test.indexes[j].v, "found expected index key at index " + j + testName); | |
| 89 is(req.result.primaryKey, test.indexes[j].k, "found expected index primary key at index " + j + testName); | |
| 90 req.result.continue(); | |
| 91 } | |
| 92 e = yield undefined; | |
| 93 is(req.result, undefined, "exhausted indexes"); | |
| 94 | |
| 95 let tempIndex = store.createIndex("temp index", "x", { multiEntry: true }); | |
| 96 req = tempIndex.openKeyCursor(); | |
| 97 req.onsuccess = grabEventAndContinueHandler; | |
| 98 for (let j = 0; j < test.indexes.length; ++j) { | |
| 99 e = yield undefined; | |
| 100 is(req.result.key, test.indexes[j].v, "found expected temp index key at index " + j + testName); | |
| 101 is(req.result.primaryKey, test.indexes[j].k, "found expected temp index primary key at index " + j + testName); | |
| 102 req.result.continue(); | |
| 103 } | |
| 104 e = yield undefined; | |
| 105 is(req.result, undefined, "exhausted temp index"); | |
| 106 store.deleteIndex("temp index"); | |
| 107 } | |
| 108 | |
| 109 // Unique indexes | |
| 110 tests = | |
| 111 [{ add: { x: 1, id: 1 }, | |
| 112 indexes:[{ v: 1, k: 1 }] }, | |
| 113 { add: { x: [2, 3], id: 2 }, | |
| 114 indexes:[{ v: 1, k: 1 }, | |
| 115 { v: 2, k: 2 }, | |
| 116 { v: 3, k: 2 }] }, | |
| 117 { put: { x: [2, 4], id: 3 }, | |
| 118 fail: true }, | |
| 119 { put: { x: [1, 4], id: 1 }, | |
| 120 indexes:[{ v: 1, k: 1 }, | |
| 121 { v: 2, k: 2 }, | |
| 122 { v: 3, k: 2 }, | |
| 123 { v: 4, k: 1 }] }, | |
| 124 { add: { x: [5, 0, 5, 5, 5], id: 3 }, | |
| 125 indexes:[{ v: 0, k: 3 }, | |
| 126 { v: 1, k: 1 }, | |
| 127 { v: 2, k: 2 }, | |
| 128 { v: 3, k: 2 }, | |
| 129 { v: 4, k: 1 }, | |
| 130 { v: 5, k: 3 }] }, | |
| 131 { delete: IDBKeyRange.bound(1, 2), | |
| 132 indexes:[{ v: 0, k: 3 }, | |
| 133 { v: 5, k: 3 }] }, | |
| 134 { add: { x: [0, 6], id: 8 }, | |
| 135 fail: true }, | |
| 136 { add: { x: 5, id: 8 }, | |
| 137 fail: true }, | |
| 138 { put: { x: 0, id: 8 }, | |
| 139 fail: true }, | |
| 140 ]; | |
| 141 | |
| 142 store.deleteIndex("myindex"); | |
| 143 index = store.createIndex("myindex", "x", { multiEntry: true, unique: true }); | |
| 144 is(index.multiEntry, true, "index created with multiEntry"); | |
| 145 | |
| 146 let i; | |
| 147 let indexes; | |
| 148 for (i = 0; i < tests.length; ++i) { | |
| 149 let test = tests[i]; | |
| 150 let testName = " for " + JSON.stringify(test); | |
| 151 let req; | |
| 152 if (test.add) { | |
| 153 req = store.add(test.add); | |
| 154 } | |
| 155 else if (test.put) { | |
| 156 req = store.put(test.put); | |
| 157 } | |
| 158 else if (test.delete) { | |
| 159 req = store.delete(test.delete); | |
| 160 } | |
| 161 else { | |
| 162 ok(false, "borked test"); | |
| 163 } | |
| 164 | |
| 165 if (!test.fail) { | |
| 166 req.onsuccess = grabEventAndContinueHandler; | |
| 167 let e = yield undefined; | |
| 168 indexes = test.indexes; | |
| 169 } | |
| 170 else { | |
| 171 req.onsuccess = unexpectedSuccessHandler; | |
| 172 req.onerror = grabEventAndContinueHandler; | |
| 173 ok(true, "waiting for error"); | |
| 174 let e = yield undefined; | |
| 175 ok(true, "got error: " + e.type); | |
| 176 e.preventDefault(); | |
| 177 e.stopPropagation(); | |
| 178 } | |
| 179 | |
| 180 let e; | |
| 181 req = index.openKeyCursor(); | |
| 182 req.onsuccess = grabEventAndContinueHandler; | |
| 183 for (let j = 0; j < indexes.length; ++j) { | |
| 184 e = yield undefined; | |
| 185 is(req.result.key, indexes[j].v, "found expected index key at index " + j + testName); | |
| 186 is(req.result.primaryKey, indexes[j].k, "found expected index primary key at index " + j + testName); | |
| 187 req.result.continue(); | |
| 188 } | |
| 189 e = yield undefined; | |
| 190 is(req.result, undefined, "exhausted indexes"); | |
| 191 | |
| 192 let tempIndex = store.createIndex("temp index", "x", { multiEntry: true, unique: true }); | |
| 193 req = tempIndex.openKeyCursor(); | |
| 194 req.onsuccess = grabEventAndContinueHandler; | |
| 195 for (let j = 0; j < indexes.length; ++j) { | |
| 196 e = yield undefined; | |
| 197 is(req.result.key, indexes[j].v, "found expected temp index key at index " + j + testName); | |
| 198 is(req.result.primaryKey, indexes[j].k, "found expected temp index primary key at index " + j + testName); | |
| 199 req.result.continue(); | |
| 200 } | |
| 201 e = yield undefined; | |
| 202 is(req.result, undefined, "exhausted temp index"); | |
| 203 store.deleteIndex("temp index"); | |
| 204 } | |
| 205 | |
| 206 | |
| 207 openRequest.onsuccess = grabEventAndContinueHandler; | |
| 208 yield undefined; | |
| 209 | |
| 210 let trans = db.transaction(["mystore"], "readwrite"); | |
| 211 store = trans.objectStore("mystore"); | |
| 212 index = store.index("myindex"); | |
| 213 is(index.multiEntry, true, "index still is multiEntry"); | |
| 214 trans.oncomplete = grabEventAndContinueHandler; | |
| 215 yield undefined; | |
| 216 | |
| 217 finishTest(); | |
| 218 yield undefined; | |
| 219 } |
