| OLD | NEW |
|---|
| (Empty) |
| 1 <!DOCTYPE html> | |
| 2 <meta charset="utf-8"> | |
| 3 <meta name="timeout" content="long"> | |
| 4 <title>IDBCursor.continuePrimaryKey() - Exception Orders </title> | |
| 5 <link rel="author" title="Mozilla" href="https://www.mozilla.org"> | |
| 6 <link rel="help" href="http://w3c.github.io/IndexedDB/#dom-idbcursor-continuepri
marykey"> | |
| 7 <script src="/resources/testharness.js"></script> | |
| 8 <script src="/resources/testharnessreport.js"></script> | |
| 9 <script src="support.js"></script> | |
| 10 | |
| 11 <script> | |
| 12 function setup_test_store(db) { | |
| 13 var records = [ { iKey: "A", pKey: 1 }, | |
| 14 { iKey: "A", pKey: 2 }, | |
| 15 { iKey: "A", pKey: 3 }, | |
| 16 { iKey: "A", pKey: 4 }, | |
| 17 { iKey: "B", pKey: 5 }, | |
| 18 { iKey: "B", pKey: 6 }, | |
| 19 { iKey: "B", pKey: 7 }, | |
| 20 { iKey: "C", pKey: 8 }, | |
| 21 { iKey: "C", pKey: 9 }, | |
| 22 { iKey: "D", pKey: 10 } ]; | |
| 23 | |
| 24 var store = db.createObjectStore("test", { keyPath: "pKey" }); | |
| 25 var index = store.createIndex("idx", "iKey"); | |
| 26 | |
| 27 for(var i = 0; i < records.length; i++) { | |
| 28 store.add(records[i]); | |
| 29 } | |
| 30 | |
| 31 return store; | |
| 32 } | |
| 33 | |
| 34 indexeddb_test( | |
| 35 function(t, db, txn) { | |
| 36 var store = setup_test_store(db); | |
| 37 var index = store.index("idx"); | |
| 38 var cursor_rq = index.openCursor(); | |
| 39 var cursor; | |
| 40 | |
| 41 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 42 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 43 cursor = e.target.result; | |
| 44 assert_true(!!cursor, "acquire cursor"); | |
| 45 | |
| 46 store.deleteIndex("idx"); | |
| 47 }); | |
| 48 txn.oncomplete = function() { | |
| 49 assert_throws("TransactionInactiveError", function() { | |
| 50 cursor.continuePrimaryKey("A", 4); | |
| 51 }, "transaction-state check should precede deletion check"); | |
| 52 t.done(); | |
| 53 }; | |
| 54 }, | |
| 55 null, | |
| 56 "TransactionInactiveError v.s. InvalidStateError(deleted index)" | |
| 57 ); | |
| 58 | |
| 59 indexeddb_test( | |
| 60 function(t, db, txn) { | |
| 61 var store = setup_test_store(db); | |
| 62 var cursor_rq = store.openCursor(); | |
| 63 var cursor; | |
| 64 | |
| 65 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 66 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 67 cursor = e.target.result; | |
| 68 assert_true(!!cursor, "acquire cursor"); | |
| 69 | |
| 70 db.deleteObjectStore("test"); | |
| 71 | |
| 72 assert_throws("InvalidStateError", function() { | |
| 73 cursor.continuePrimaryKey("A", 4); | |
| 74 }, "deletion check should precede index source check"); | |
| 75 t.done(); | |
| 76 }); | |
| 77 }, | |
| 78 null, | |
| 79 "InvalidStateError(deleted source) v.s. InvalidAccessError(incorrect source)
" | |
| 80 ); | |
| 81 | |
| 82 indexeddb_test( | |
| 83 function(t, db, txn) { | |
| 84 var store = setup_test_store(db); | |
| 85 var index = store.index("idx"); | |
| 86 var cursor_rq = index.openCursor(null, "nextunique"); | |
| 87 var cursor; | |
| 88 | |
| 89 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 90 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 91 cursor = e.target.result; | |
| 92 assert_true(!!cursor, "acquire cursor"); | |
| 93 | |
| 94 store.deleteIndex("idx"); | |
| 95 | |
| 96 assert_throws("InvalidStateError", function() { | |
| 97 cursor.continuePrimaryKey("A", 4); | |
| 98 }, "deletion check should precede cursor direction check"); | |
| 99 t.done(); | |
| 100 }); | |
| 101 }, | |
| 102 null, | |
| 103 "InvalidStateError(deleted source) v.s. InvalidAccessError(incorrect directi
on)" | |
| 104 ); | |
| 105 | |
| 106 indexeddb_test( | |
| 107 function(t, db, txn) { | |
| 108 var store = db.createObjectStore("test", {keyPath:"pKey"}); | |
| 109 var index = store.createIndex("idx", "iKey"); | |
| 110 | |
| 111 store.add({ iKey: "A", pKey: 1 }); | |
| 112 | |
| 113 var cursor_rq = index.openCursor(null, "nextunique"); | |
| 114 var cursor; | |
| 115 | |
| 116 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 117 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 118 if (e.target.result) { | |
| 119 cursor = e.target.result; | |
| 120 cursor.continue(); | |
| 121 return; | |
| 122 } | |
| 123 | |
| 124 assert_throws("InvalidAccessError", function() { | |
| 125 cursor.continuePrimaryKey("A", 4); | |
| 126 }, "direction check should precede got_value_flag check"); | |
| 127 t.done(); | |
| 128 }); | |
| 129 }, | |
| 130 null, | |
| 131 "InvalidAccessError(incorrect direction) v.s. InvalidStateError(iteration co
mplete)" | |
| 132 ); | |
| 133 | |
| 134 indexeddb_test( | |
| 135 function(t, db, txn) { | |
| 136 var store = db.createObjectStore("test", {keyPath:"pKey"}); | |
| 137 var index = store.createIndex("idx", "iKey"); | |
| 138 | |
| 139 store.add({ iKey: "A", pKey: 1 }); | |
| 140 | |
| 141 var cursor_rq = index.openCursor(null, "nextunique"); | |
| 142 var cursor; | |
| 143 | |
| 144 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 145 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 146 if (!cursor) { | |
| 147 cursor = e.target.result; | |
| 148 assert_true(!!cursor, "acquire cursor"); | |
| 149 | |
| 150 cursor.continue(); | |
| 151 | |
| 152 assert_throws("InvalidAccessError", function() { | |
| 153 cursor.continuePrimaryKey("A", 4); | |
| 154 }, "direction check should precede iteration ongoing check"); | |
| 155 t.done(); | |
| 156 } | |
| 157 }); | |
| 158 }, | |
| 159 null, | |
| 160 "InvalidAccessError(incorrect direction) v.s. InvalidStateError(iteration on
going)" | |
| 161 ); | |
| 162 | |
| 163 indexeddb_test( | |
| 164 function(t, db, txn) { | |
| 165 var store = setup_test_store(db); | |
| 166 var cursor_rq = store.openCursor(); | |
| 167 var cursor; | |
| 168 | |
| 169 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 170 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 171 if (!cursor) { | |
| 172 cursor = e.target.result; | |
| 173 assert_true(!!cursor, "acquire cursor"); | |
| 174 | |
| 175 cursor.continue(); | |
| 176 | |
| 177 assert_throws("InvalidAccessError", function() { | |
| 178 cursor.continuePrimaryKey("A", 4); | |
| 179 }, "index source check should precede iteration ongoing check"); | |
| 180 t.done(); | |
| 181 } | |
| 182 }); | |
| 183 }, | |
| 184 null, | |
| 185 "InvalidAccessError(incorrect source) v.s. InvalidStateError(iteration ongoi
ng)" | |
| 186 ); | |
| 187 | |
| 188 indexeddb_test( | |
| 189 function(t, db, txn) { | |
| 190 var store = db.createObjectStore("test", {keyPath:"pKey"}); | |
| 191 | |
| 192 store.add({ iKey: "A", pKey: 1 }); | |
| 193 | |
| 194 var cursor_rq = store.openCursor(); | |
| 195 var cursor; | |
| 196 | |
| 197 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 198 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 199 if (e.target.result) { | |
| 200 cursor = e.target.result; | |
| 201 cursor.continue(); | |
| 202 return; | |
| 203 } | |
| 204 | |
| 205 assert_throws("InvalidAccessError", function() { | |
| 206 cursor.continuePrimaryKey("A", 4); | |
| 207 }, "index source check should precede got_value_flag check"); | |
| 208 t.done(); | |
| 209 }); | |
| 210 }, | |
| 211 null, | |
| 212 "InvalidAccessError(incorrect source) v.s. InvalidStateError(iteration compl
ete)" | |
| 213 ); | |
| 214 | |
| 215 indexeddb_test( | |
| 216 function(t, db, txn) { | |
| 217 var store = setup_test_store(db); | |
| 218 var index = store.index("idx"); | |
| 219 var cursor_rq = index.openCursor(); | |
| 220 var cursor; | |
| 221 | |
| 222 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 223 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 224 if (!cursor) { | |
| 225 cursor = e.target.result; | |
| 226 assert_true(!!cursor, "acquire cursor"); | |
| 227 | |
| 228 cursor.continue(); | |
| 229 | |
| 230 assert_throws("InvalidStateError", function() { | |
| 231 cursor.continuePrimaryKey(null, 4); | |
| 232 }, "iteration ongoing check should precede unset key check"); | |
| 233 t.done(); | |
| 234 } | |
| 235 }); | |
| 236 }, | |
| 237 null, | |
| 238 "InvalidStateError(iteration ongoing) v.s. DataError(unset key)" | |
| 239 ); | |
| 240 | |
| 241 indexeddb_test( | |
| 242 function(t, db, txn) { | |
| 243 var store = db.createObjectStore("test", {keyPath:"pKey"}); | |
| 244 var index = store.createIndex("idx", "iKey"); | |
| 245 | |
| 246 store.add({ iKey: "A", pKey: 1 }); | |
| 247 | |
| 248 var cursor_rq = index.openCursor(); | |
| 249 var cursor; | |
| 250 | |
| 251 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 252 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 253 if (e.target.result) { | |
| 254 cursor = e.target.result; | |
| 255 cursor.continue(); | |
| 256 return; | |
| 257 } | |
| 258 | |
| 259 assert_throws("InvalidStateError", function() { | |
| 260 cursor.continuePrimaryKey(null, 4); | |
| 261 }, "got_value_flag check should precede unset key check"); | |
| 262 t.done(); | |
| 263 }); | |
| 264 }, | |
| 265 null, | |
| 266 "InvalidStateError(iteration complete) v.s. DataError(unset key)" | |
| 267 ); | |
| 268 | |
| 269 indexeddb_test( | |
| 270 function(t, db, txn) { | |
| 271 var store = setup_test_store(db); | |
| 272 var index = store.index("idx"); | |
| 273 var cursor_rq = index.openCursor(); | |
| 274 var cursor; | |
| 275 | |
| 276 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 277 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 278 cursor = e.target.result; | |
| 279 assert_true(!!cursor, "acquire cursor"); | |
| 280 | |
| 281 assert_throws("DataError", function() { | |
| 282 cursor.continuePrimaryKey(null, 4); | |
| 283 }, "DataError is expected if key is unset."); | |
| 284 t.done(); | |
| 285 }); | |
| 286 }, | |
| 287 null, | |
| 288 "DataError(unset key)" | |
| 289 ); | |
| 290 | |
| 291 indexeddb_test( | |
| 292 function(t, db, txn) { | |
| 293 var store = setup_test_store(db); | |
| 294 var index = store.index("idx"); | |
| 295 var cursor_rq = index.openCursor(); | |
| 296 var cursor; | |
| 297 | |
| 298 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 299 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 300 cursor = e.target.result; | |
| 301 assert_true(!!cursor, "acquire cursor"); | |
| 302 | |
| 303 assert_throws("DataError", function() { | |
| 304 cursor.continuePrimaryKey("A", null); | |
| 305 }, "DataError is expected if primary key is unset."); | |
| 306 t.done(); | |
| 307 }); | |
| 308 }, | |
| 309 null, | |
| 310 "DataError(unset primary key)" | |
| 311 ); | |
| 312 | |
| 313 indexeddb_test( | |
| 314 function(t, db, txn) { | |
| 315 var store = setup_test_store(db); | |
| 316 var index = store.index("idx"); | |
| 317 var cursor_rq = index.openCursor(IDBKeyRange.lowerBound("B")); | |
| 318 var cursor; | |
| 319 | |
| 320 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 321 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 322 cursor = e.target.result; | |
| 323 assert_true(!!cursor, "acquire cursor"); | |
| 324 | |
| 325 assert_equals(cursor.key, "B", "expected key"); | |
| 326 assert_equals(cursor.primaryKey, 5, "expected primary key"); | |
| 327 | |
| 328 assert_throws("DataError", function() { | |
| 329 cursor.continuePrimaryKey("A", 6); | |
| 330 }, "DataError is expected if key is lower then current one."); | |
| 331 | |
| 332 assert_throws("DataError", function() { | |
| 333 cursor.continuePrimaryKey("B", 5); | |
| 334 }, "DataError is expected if primary key is equal to current one."); | |
| 335 | |
| 336 assert_throws("DataError", function() { | |
| 337 cursor.continuePrimaryKey("B", 4); | |
| 338 }, "DataError is expected if primary key is lower than current one."
); | |
| 339 | |
| 340 t.done(); | |
| 341 }); | |
| 342 }, | |
| 343 null, | |
| 344 "DataError(keys are lower then current one) in 'next' direction" | |
| 345 ); | |
| 346 | |
| 347 indexeddb_test( | |
| 348 function(t, db, txn) { | |
| 349 var store = setup_test_store(db); | |
| 350 var index = store.index("idx"); | |
| 351 var cursor_rq = index.openCursor(IDBKeyRange.upperBound("B"), "prev"); | |
| 352 var cursor; | |
| 353 | |
| 354 cursor_rq.onerror = t.unreached_func('openCursor should succeed'); | |
| 355 cursor_rq.onsuccess = t.step_func(function(e) { | |
| 356 cursor = e.target.result; | |
| 357 assert_true(!!cursor, "acquire cursor"); | |
| 358 | |
| 359 assert_equals(cursor.key, "B", "expected key"); | |
| 360 assert_equals(cursor.primaryKey, 7, "expected primary key"); | |
| 361 | |
| 362 assert_throws("DataError", function() { | |
| 363 cursor.continuePrimaryKey("C", 6); | |
| 364 }, "DataError is expected if key is larger then current one."); | |
| 365 | |
| 366 assert_throws("DataError", function() { | |
| 367 cursor.continuePrimaryKey("B", 7); | |
| 368 }, "DataError is expected if primary key is equal to current one."); | |
| 369 | |
| 370 assert_throws("DataError", function() { | |
| 371 cursor.continuePrimaryKey("B", 8); | |
| 372 }, "DataError is expected if primary key is larger than current one.
"); | |
| 373 | |
| 374 t.done(); | |
| 375 }); | |
| 376 }, | |
| 377 null, | |
| 378 "DataError(keys are larger then current one) in 'prev' direction" | |
| 379 ); | |
| 380 </script> | |
| 381 | |
| 382 <div id="log"></div> | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2408083002:
Revert of Import wpt@357b83b809e3cbc7a1805e7c3ca108a7980d782f (Closed)
