Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-01 02:28:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision a46616a5b18e83587ddbbed756c7b96cbb4b015d

Browse source
This commit is contained in:
Josh Matthews 2017-06-19 19:07:14 -04:00 • committed by Ms2ger
parent 3f07cfec7c
commit 578498ba24
4001 changed files with 159517 additions and 30260 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tests/wpt/web-platform-tests/IndexedDB/idb_webworkers.htm
View file

@ -8,6 +8,7 @@
<script>
var db, count = 0,
t = async_test();
t.add_cleanup(function() { indexedDB.deleteDatabase('webworker101'); });
t.step(function() {
var worker = new Worker("idbworker.js");
@ -27,7 +28,4 @@
worker.postMessage(1);
})
</script>
<div id="log"></div>

297
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance-continue-async.htm
View file

@ -7,180 +7,175 @@
<script>
var db, open;
function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() {
open = indexedDB.open('testdb-' + new Date().getTime());
open.onupgradeneeded = function(e) {
db = e.target.result;
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("data", 1);
objStore.add("data2", 2);
}
objStore.add("data", 1);
objStore.add("data2", 2);
};
},
{ explicit_done: true });
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() {
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
cursor.advance(1)
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
cursor.advance(1)
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
async_test(document.title + " - advance").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
default:
assert_unreached("Unexpected count: " + count)
}
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - advance"
);
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
cursor.advance(1)
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
cursor.advance(1)
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
default:
assert_unreached("Unexpected count: " + count)
}
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
cursor.continue("data2")
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
break
count++;
});
rq.onerror = fail(this, "unexpected error")
});
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
cursor.continue()
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
default:
assert_unreached("Unexpected count: " + count)
}
async_test(document.title + " - continue").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - continue"
);
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
cursor.continue("data2")
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
break
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
cursor.advance(1)
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
cursor.continue()
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
break
default:
assert_unreached("Unexpected count: " + count)
}
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
count++;
});
rq.onerror = fail(this, "unexpected error")
});
default:
assert_unreached("Unexpected count: " + count)
}
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - fresh advance still async"
);
async_test(document.title + " - fresh advance still async").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
cursor.advance(1)
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
cursor.continue()
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, "data")
assert_equals(cursor.primaryKey, 1)
break
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, "data2")
assert_equals(cursor.primaryKey, 2)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
default:
assert_unreached("Unexpected count: " + count)
}
count++;
});
rq.onerror = fail(this, "unexpected error")
});
async_test(document.title + " - fresh continue still async").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
cursor.continue()
switch(count) {
case 0:
assert_equals(cursor.value, "data")
assert_equals(cursor.key, 1)
break
case 1:
assert_equals(cursor.value, "data2")
assert_equals(cursor.key, 2)
break
default:
assert_unreached("Unexpected count: " + count)
}
count++;
});
rq.onerror = fail(this, "unexpected error")
});
// Stop blocking the testing system from hereon
done();
}
default:
assert_unreached("Unexpected count: " + count)
}
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - fresh continue still async"
);
</script>
<div id=log></div>

226
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance-invalid.htm
View file

@ -13,176 +13,180 @@
<script>
var db, open;
function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() {
open = indexedDB.open('testdb-' + new Date().getTime());
open.onupgradeneeded = function(e) {
db = e.target.result;
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("data", 1);
objStore.add("data2", 2);
}
objStore.add("data", 1);
objStore.add("data2", 2);
};
},
{ explicit_done: true });
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() {
cursor.advance(1);
async_test(document.title + " - attempt to call advance twice").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
cursor.advance(1);
// Second try
assert_throws('InvalidStateError',
// Second try
assert_throws('InvalidStateError',
function() { cursor.advance(1); }, 'second advance');
assert_throws('InvalidStateError',
assert_throws('InvalidStateError',
function() { cursor.advance(3); }, 'third advance');
count++;
});
rq.onerror = fail(this, "unexpected error")
});
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - attempt to call advance twice"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - pass something other than number").step(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
rq.onsuccess = this.step_func(function(e) {
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(document); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance({}); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance([]); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(""); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance("1 2"); });
this.done();
});
rq.onerror = fail(this, "unexpected error")
});
t.done();
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - pass something other than number"
);
async_test(document.title + " - pass null/undefined").step(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) {
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(null); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(undefined); });
var myvar = null;
assert_throws({ name: "TypeError" },
var myvar = null;
assert_throws({ name: "TypeError" },
function() { cursor.advance(myvar); });
this.done();
});
rq.onerror = fail(this, "unexpected error")
});
t.done();
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - pass null/undefined"
);
async_test(document.title + " - missing argument").step(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = this.step_func(function(e) {
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(); });
this.done();
});
rq.onerror = fail(this, "unexpected error")
});
t.done();
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - missing argument"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - pass negative numbers").step(function(e) {
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
rq.onsuccess = this.step_func(function(e) {
var cursor = e.target.result;
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(-1); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(NaN); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(0); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(-0); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(Infinity); });
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(-Infinity); });
var myvar = -999999;
assert_throws({ name: "TypeError" },
var myvar = -999999;
assert_throws({ name: "TypeError" },
function() { cursor.advance(myvar); });
this.done();
});
rq.onerror = fail(this, "unexpected error")
});
t.done();
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - pass negative numbers"
);
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
async_test(document.title + " - got value not set on exception").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor)
{
assert_equals(count, 2, "count runs");
t.done();
return;
}
rq.onsuccess = this.step_func(function(e) {
var cursor = e.target.result;
if (!cursor)
{
assert_equals(count, 2, "count runs");
this.done();
return;
}
assert_throws({ name: "TypeError" },
assert_throws({ name: "TypeError" },
function() { cursor.advance(0); });
cursor.advance(1);
count++;
});
rq.onerror = fail(this, "unexpected error")
});
// Stop blocking the testing system from hereon
done();
}
cursor.advance(1);
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - got value not set on exception"
);
</script>
<div id=log></div>

394
tests/wpt/web-platform-tests/IndexedDB/idbcursor-advance.htm
View file

@ -7,237 +7,241 @@
<script>
var db, open;
function upgrade_func(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
setup(function() {
open = indexedDB.open("testdb-" + new Date().getTime());
open.onupgradeneeded = function(e) {
db = e.target.result;
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("cupcake", 5);
objStore.add("pancake", 3); // Yes, it is intended
objStore.add("pie", 1);
objStore.add("pie", 4);
objStore.add("taco", 2);
}
objStore.add("cupcake", 5);
objStore.add("pancake", 3); // Yes, it is intended
objStore.add("pie", 1);
objStore.add("pie", 4);
objStore.add("taco", 2);
};
},
{ explicit_done: true });
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, "count");
t.done();
return;
}
var cursor = e.target.result;
open.onsuccess = function() {
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
async_test(document.title + " - advances").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, "count");
this.done();
return;
}
var cursor = e.target.result;
case 2:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
break;
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
default:
assert_unreached("Unexpected count: " + count);
}
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
count++;
cursor.advance(2);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - advances"
);
case 2:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
break;
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor(null, "prev");
default:
assert_unreached("Unexpected count: " + count);
}
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, "count");
t.done();
return;
}
var cursor = e.target.result;
count++;
cursor.advance(2);
});
rq.onerror = fail(this, "unexpected error")
});
switch(count) {
case 0:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
break;
async_test(document.title + " - advances backwards").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor(null, "prev");
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, "count");
this.done();
return;
}
var cursor = e.target.result;
case 2:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
switch(count) {
case 0:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
break;
default:
assert_unreached("Unexpected count: " + count);
}
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
count++;
cursor.advance(2);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - advances backwards"
);
case 2:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
default:
assert_unreached("Unexpected count: " + count);
}
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, "count");
t.done();
return;
}
var cursor = e.target.result;
count++;
cursor.advance(2);
});
rq.onerror = fail(this, "unexpected error")
});
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
async_test(document.title + " - skip far forward").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
default:
assert_unreached("Unexpected count: " + count);
}
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, "count");
this.done();
return;
}
var cursor = e.target.result;
count++;
cursor.advance(100000);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - skip far forward"
);
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
default:
assert_unreached("Unexpected count: " + count);
}
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, "count");
t.done();
return;
}
var cursor = e.target.result;
count++;
cursor.advance(100000);
});
rq.onerror = fail(this, "unexpected error")
});
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
async_test(document.title + " - within range").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
default:
assert_unreached("Unexpected count: " + count);
}
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, "count");
this.done();
return;
}
var cursor = e.target.result;
count++;
cursor.advance(2);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - within range"
);
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
break;
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, "count");
t.done();
return;
}
var cursor = e.target.result;
default:
assert_unreached("Unexpected count: " + count);
}
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
break;
count++;
cursor.advance(2);
});
rq.onerror = fail(this, "unexpected error")
});
default:
assert_unreached("Unexpected count: " + count);
}
count++;
cursor.advance(1);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - within single key range"
);
async_test(document.title + " - within single key range").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, "count");
this.done();
return;
}
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, "count");
t.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
break;
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
default:
assert_unreached("Unexpected count: " + count);
}
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
count++;
cursor.advance(1);
});
rq.onerror = fail(this, "unexpected error")
});
default:
assert_unreached("Unexpected count: " + count);
}
async_test(document.title + " - within single key range, with several results").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, "count");
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
cursor.advance(1);
});
rq.onerror = fail(this, "unexpected error")
});
// Stop blocking the testing system from hereon
done();
}
count++;
cursor.advance(1);
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - within single key range, with several results"
);
</script>
<div id="log"></div>

404
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continue.htm
View file

@ -9,232 +9,240 @@
<script>
var db, open;
var store = [ { value: "cupcake", key: 5 },
{ value: "pancake", key: 3 },
{ value: "pie", key: 1 },
{ value: "pie", key: 4 },
{ value: "taco", key: 2 } ];
var store = [ { value: "cupcake", key: 5 },
{ value: "pancake", key: 3 },
{ value: "pie", key: 1 },
{ value: "pie", key: 4 },
{ value: "taco", key: 2 } ];
setup(function() {
open = indexedDB.open('testdb-' + new Date().getTime());
open.onupgradeneeded = function(e) {
var os, i;
db = e.target.result;
os = db.createObjectStore("test");
os.createIndex("index", "");
function upgrade_func(t, db, tx) {
var db, open;
for (i = 0; i < store.length; i++)
os.add(store[i].value, store[i].key);
};
},
{ explicit_done: true });
var os, i;
os = db.createObjectStore("test");
os.createIndex("index", "");
for (i = 0; i < store.length; i++)
os.add(store[i].value, store[i].key);
}
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 5, 'count');
t.done();
return;
}
var cursor = e.target.result;
assert_equals(cursor.value, store[count].value);
assert_equals(cursor.primaryKey, store[count].key);
cursor.continue();
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - continues"
);
open.onsuccess = function() {
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, 'count');
t.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
cursor.continue("pie");
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue("taco");
break;
case 2:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
cursor.continue();
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = t.unreached_func("unexpected error")
},
document.title + " - with given key"
);
async_test(document.title + " - continues").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 5, 'count');
this.done();
return;
}
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, 'count');
t.done();
return;
}
var cursor = e.target.result;
assert_equals(cursor.value, store[count].value);
assert_equals(cursor.primaryKey, store[count].key);
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
cursor.continue();
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error")
});
count++;
cursor.continue([]); // Arrays are always bigger than strings
});
rq.onerror = t.unreached_func("unexpected error2")
},
document.title + " - skip far forward"
);
async_test(document.title + " - with given key").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index").openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 3, 'count');
this.done();
return;
}
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
cursor.continue("pie");
break;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue("taco");
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue("zzz");
break;
case 2:
assert_equals(cursor.value, "taco");
assert_equals(cursor.primaryKey, 2);
cursor.continue();
break;
default:
assert_unreached("Unexpected count: " + count);
}
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error")
});
count++;
});
rq.onerror = t.unreached_func("unexpected error1")
},
document.title + " - within range"
);
async_test(document.title + " - skip far forward").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor();
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, 'count');
this.done();
return;
}
var cursor = e.target.result;
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, 'count');
t.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "cupcake");
assert_equals(cursor.primaryKey, 5);
break;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
default:
assert_unreached("Unexpected count: " + count);
}
default:
assert_unreached("Unexpected count: " + count);
}
count++;
cursor.continue([]); // Arrays are always bigger than strings
count++;
});
rq.onerror = t.unreached_func("unexpected error1")
},
document.title + " - within single key range"
);
});
rq.onerror = fail(this, "unexpected error2")
});
indexeddb_test(
upgrade_func,
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
t.done();
return;
}
var cursor = e.target.result;
async_test(document.title + " - within range").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor(IDBKeyRange.lowerBound("cupcake", true));
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue();
break;
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
cursor.continue();
break;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
default:
assert_unreached("Unexpected count: " + count);
}
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue("zzz");
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
async_test(document.title + " - within single key range").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pancake");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 1, 'count');
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pancake");
assert_equals(cursor.primaryKey, 3);
cursor.continue("pie");
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
async_test(document.title + " - within single key range, with several results").step(function(e) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("index")
.openCursor("pie");
rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
assert_equals(count, 2, 'count');
this.done();
return;
}
var cursor = e.target.result;
switch(count) {
case 0:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 1);
cursor.continue();
break;
case 1:
assert_equals(cursor.value, "pie");
assert_equals(cursor.primaryKey, 4);
cursor.continue();
break;
default:
assert_unreached("Unexpected count: " + count);
}
count++;
});
rq.onerror = fail(this, "unexpected error1")
});
// Stop blocking the testing system from hereon
done();
}
count++;
});
rq.onerror = t.unreached_func("unexpected error1")
},
document.title + " - within single key range, with several results"
);
</script>
<div id="log"></div>

6
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continuePrimaryKey-exception-order.htm
View file

@ -45,12 +45,12 @@ indexeddb_test(
store.deleteIndex("idx");
});
txn.oncomplete = function() {
txn.oncomplete = t.step_func(function() {
assert_throws("TransactionInactiveError", function() {
cursor.continuePrimaryKey("A", 4);
}, "transaction-state check should precede deletion check");
t.done();
};
});
},
null,
"TransactionInactiveError v.s. InvalidStateError(deleted index)"
@ -378,5 +378,3 @@ indexeddb_test(
"DataError(keys are larger then current one) in 'prev' direction"
);
</script>
<div id="log"></div>

8
tests/wpt/web-platform-tests/IndexedDB/idbcursor-continuePrimaryKey-exceptions.htm
View file

@ -16,6 +16,10 @@ async_test(function(t) {
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var store = db.createObjectStore('store');
store.put('a', 1).onerror = t.unreached_func('put should not fail');
var request = store.openCursor();
@ -60,6 +64,10 @@ async_test(function(t) {
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var store = db.createObjectStore('store', {keyPath: 'pk'});
var index = store.createIndex('index', 'ik', {multiEntry: true});
store.put({pk: 'a', ik: [1,2,3]}).onerror =

99
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-index-keyrange.htm
View file

@ -15,69 +15,46 @@
<script src="support.js"></script>
<script>
var records = [ 1337, "Alice", "Bob", "Bob", "Greg", "Åke", ["Anne"] ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {};
directions.forEach(function(dir) {
tests[dir] = async_test(document.title + ' - ' + dir);
});
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
objStore.createIndex("idx", "name");
for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
var records = [ 1337, "Alice", "Bob", "Bob", "Greg", "Åke", ["Anne"] ];
var cases = [
{dir: 'next', expect: ['Alice:1', 'Bob:2', 'Bob:3', 'Greg:4']},
{dir: 'prev', expect: ['Greg:4', 'Bob:3', 'Bob:2', 'Alice:1']},
{dir: 'nextunique', expect: ['Alice:1', 'Bob:2', 'Greg:4']},
{dir: 'prevunique', expect: ['Greg:4', 'Bob:2', 'Alice:1']}
];
// The tests
testdir('next', ['Alice:1', 'Bob:2', 'Bob:3', 'Greg:4']);
testdir('prev', ['Greg:4', 'Bob:3', 'Bob:2', 'Alice:1']);
testdir('nextunique', ['Alice:1', 'Bob:2', 'Greg:4']);
testdir('prevunique', ['Greg:4', 'Bob:2', 'Alice:1']);
cases.forEach(function(testcase) {
var dir = testcase.dir;
var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("idx", "name");
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
},
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
};
// Fail handling
function fail_helper(name) {
return function() {
directions.forEach(function(dir) {
tests[dir].step(function() { assert_unreached(name); });
});
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
},
document.title + ' - ' + dir
)
});
</script>
<div id=log> </div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-index.htm
View file

@ -13,69 +13,45 @@
<script src="support.js"></script>
<script>
var records = [ "Alice", "Bob", "Bob", "Greg" ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {};
var records = [ "Alice", "Bob", "Bob", "Greg" ];
var cases = [
{dir: 'next', expect: ['Alice:0', 'Bob:1', 'Bob:2', 'Greg:3']},
{dir: 'prev', expect: ['Greg:3', 'Bob:2', 'Bob:1', 'Alice:0']},
{dir: 'nextunique', expect: ['Alice:0', 'Bob:1', 'Greg:3']},
{dir: 'prevunique', expect: ['Greg:3', 'Bob:1', 'Alice:0']},
];
directions.forEach(function(dir) {
tests[dir] = async_test(document.title + ' - ' + dir);
});
cases.forEach(function(testcase) {
var dir = testcase.dir;
var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("idx", "name");
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
objStore.createIndex("idx", "name");
for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
// The tests
testdir('next', ['Alice:0', 'Bob:1', 'Bob:2', 'Greg:3']);
testdir('prev', ['Greg:3', 'Bob:2', 'Bob:1', 'Alice:0']);
testdir('nextunique', ['Alice:0', 'Bob:1', 'Greg:3']);
testdir('prevunique', ['Greg:3', 'Bob:1', 'Alice:0']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
for (var i = 0; i < records.length; i++)
objStore.add({ name: records[i] }, i);
},
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").index("idx").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
};
// Fail handling
function fail_helper(name) {
return function() {
directions.forEach(function(dir) {
tests[dir].step(function() { assert_unreached(name); });
});
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
assert_equals(cursor.value.name + ":" + cursor.primaryKey, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
},
document.title + ' - ' + dir
);
});
</script>
<div id=log> </div>

98
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-objectstore-keyrange.htm
View file

@ -11,68 +11,44 @@
<script src="support.js"></script>
<script>
var records = [ 1337, "Alice", "Bob", "Greg", "Åke", ["Anne"] ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {};
directions.forEach(function(dir) {
tests[dir] = async_test(document.title + ' - ' + dir);
});
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
var records = [ 1337, "Alice", "Bob", "Greg", "Åke", ["Anne"] ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var cases = [
{dir: 'next', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prev', expect: ['Greg', 'Bob', 'Alice']},
{dir: 'nextunique', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prevunique', expect: ['Greg', 'Bob', 'Alice']},
];
cases.forEach(function(testcase) {
var dir = testcase.dir;
var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
for (var i = 0; i < records.length; i++)
objStore.add(records[i], records[i]);
};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
// The tests
testdir('next', ['Alice', 'Bob', 'Greg']);
testdir('prev', ['Greg', 'Bob', 'Alice']);
testdir('nextunique', ['Alice', 'Bob', 'Greg']);
testdir('prevunique', ['Greg', 'Bob', 'Alice']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
objStore.add(records[i], records[i]);
},
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor(IDBKeyRange.bound("AA", "ZZ"), dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
};
// Fail handling
function fail_helper(name) {
return function() {
directions.forEach(function(dir) {
tests[dir].step(function() { assert_unreached(name); });
});
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
},
document.title + ' - ' + dir
);
});
</script>
<div id=log> </div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction-objectstore.htm
View file

@ -13,68 +13,44 @@
<script src="support.js"></script>
<script>
var records = [ "Alice", "Bob", "Greg" ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var tests = {};
var records = [ "Alice", "Bob", "Greg" ];
var directions = ["next", "prev", "nextunique", "prevunique"];
var cases = [
{dir: 'next', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prev', expect: ['Greg', 'Bob', 'Alice']},
{dir: 'nextunique', expect: ['Alice', 'Bob', 'Greg']},
{dir: 'prevunique', expect: ['Greg', 'Bob', 'Alice']},
];
directions.forEach(function(dir) {
tests[dir] = async_test(document.title + ' - ' + dir);
});
var open_rq = indexedDB.open("testdb-" + new Date().getTime() + Math.random());
open_rq.onupgradeneeded = function(e) {
var objStore = e.target.result.createObjectStore("test");
for (var i = 0; i < records.length; i++)
objStore.add(records[i], records[i]);
};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.onerror = fail_helper("db.onerror");
// The tests
testdir('next', ['Alice', 'Bob', 'Greg']);
testdir('prev', ['Greg', 'Bob', 'Alice']);
testdir('nextunique', ['Alice', 'Bob', 'Greg']);
testdir('prevunique', ['Greg', 'Bob', 'Alice']);
// Test function
function testdir(dir, expect) {
var count = 0;
var t = tests[dir];
var rq = db.transaction("test").objectStore("test").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
cases.forEach(function(testcase) {
var dir = testcase.dir;
var expect = testcase.expect;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
for (var i = 0; i < records.length; i++)
objStore.add(records[i], records[i]);
},
function(t, db) {
var count = 0;
var rq = db.transaction("test").objectStore("test").openCursor(undefined, dir);
rq.onsuccess = t.step_func(function(e) {
var cursor = e.target.result;
if (!cursor) {
assert_equals(count, expect.length, "cursor runs");
t.done();
}
};
// Fail handling
function fail_helper(name) {
return function() {
directions.forEach(function(dir) {
tests[dir].step(function() { assert_unreached(name); });
});
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
assert_equals(cursor.value, expect[count], "cursor.value");
count++;
cursor.continue();
});
rq.onerror = t.step_func(function(e) {
e.preventDefault();
e.stopPropagation();
assert_unreached("rq.onerror - " + e.message);
});
},
document.title + ' - ' + dir
);
});
</script>
<div id=log> </div>

7
tests/wpt/web-platform-tests/IndexedDB/idbcursor-direction.htm
View file

@ -17,6 +17,11 @@
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
t.add_cleanup(function() {
db.close();
indexedDB.deleteDatabase(db.name);
});
var objStore = db.createObjectStore("test");
objStore.add("data", "key");
@ -69,5 +74,3 @@
cursor_direction("prevunique", "prevunique");
</script>
<div id="log"></div>

100
tests/wpt/web-platform-tests/IndexedDB/idbcursor-source.htm
View file

@ -6,63 +6,61 @@
<script src="support.js"></script>
<script>
setup({ explicit_done: true });
function cursor_source_test(test_name, name, stringified_object, cursor_rq_func) {
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("my_objectstore");
objStore.createIndex("my_index", "");
var db;
var open_rq = indexedDB.open('testdb-' + new Date().getTime());
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
var objStore = db.createObjectStore("my_objectstore");
objStore.createIndex("my_index", "");
objStore.add("data", 1);
objStore.add("data2", 2);
},
function(t, db) {
var cursor_rq = cursor_rq_func(db);
objStore.add("data", 1);
objStore.add("data2", 2);
};
cursor_rq.onsuccess = t.step_func(function(e) {
if (!e.target.result) {
return;
}
var cursor = e.target.result;
assert_readonly(cursor, 'source');
function cursor_source(name, stringified_object, cursor_rq) {
var cursor;
// Direct try
assert_true(cursor.source instanceof Object, "source isobject");
assert_equals(cursor.source + "", stringified_object, "source");
assert_equals(cursor.source.name, name, "name");
cursor_rq.onsuccess = this.step_func(function(e) {
if (!e.target.result) {
return;
}
cursor = e.target.result;
assert_readonly(cursor, 'source');
cursor.continue();
});
// Direct try
assert_true(cursor.source instanceof Object, "source isobject");
assert_equals(cursor.source + "", stringified_object, "source");
assert_equals(cursor.source.name, name, "name");
cursor_rq.transaction.oncomplete = t.step_func(function(e) {
t.done();
});
cursor.continue();
});
cursor_rq.transaction.onerror = t.step_func(function(e) {
assert_unreached("Transaction got error. " + (e.target.error ? e.target.error.name : "unknown"));
});
},
test_name
);
}
cursor_rq.transaction.oncomplete = this.step_func(function(e) {
this.done();
});
cursor_rq.transaction.onerror = this.step_func(function(e) {
assert_unreached("Transaction got error. " + (e.target.error ? e.target.error.name : "unknown"));
});
}
open_rq.onsuccess = function() {
async_test(document.title + ' - IDBObjectStore').step(function() {
cursor_source.call(this, "my_objectstore", "[object IDBObjectStore]", db.transaction("my_objectstore")
.objectStore("my_objectstore")
.openCursor());
});
async_test(document.title + ' - IDBIndex').step(function() {
cursor_source.call(this, "my_index", "[object IDBIndex]", db.transaction("my_objectstore")
.objectStore("my_objectstore")
.index("my_index")
.openCursor());
});
done();
};
cursor_source_test(
document.title + ' - IDBObjectStore',
"my_objectstore",
"[object IDBObjectStore]",
function(db) { return db.transaction("my_objectstore")
.objectStore("my_objectstore")
.openCursor(); }
);
cursor_source_test(
document.title + ' - IDBIndex',
"my_index",
"[object IDBIndex]",
function(db) { return db.transaction("my_objectstore")
.objectStore("my_objectstore")
.index("my_index")
.openCursor(); }
);
</script>
<div id="log"></div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating.htm
View file

@ -13,6 +13,7 @@
var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", { keyPath: "key" });
for (var i = 0; i < 500; i++)
@ -106,5 +107,3 @@
});
};
</script>
<div id="log"> </div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating_objectstore.htm
View file

@ -18,6 +18,7 @@
var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", {keyPath:"pKey"});
for (var i = 0; i < records.length; i++)
@ -47,5 +48,3 @@
});
};
</script>
<div id="log"> </div>

3
tests/wpt/web-platform-tests/IndexedDB/idbcursor_iterating_objectstore2.htm
View file

@ -18,6 +18,7 @@
var open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
t.add_cleanup(function() { db.close(); indexedDB.deleteDatabase(db.name); });
var objStore = db.createObjectStore("test", {keyPath:"pKey"});
for (var i = 0; i < records.length; i++)
@ -47,5 +48,3 @@
});
};
</script>
<div id="log"> </div>

1
tests/wpt/web-platform-tests/IndexedDB/idbdatabase_close.htm
View file

@ -33,6 +33,7 @@ open_rq.onsuccess = function(e) {
assert_equals(blocked_fired, 1, 'block event fired #')
assert_equals(upgradeneeded_fired, 2, 'second upgradeneeded event fired #')
rq.result.close();
t.done();
});
rq.onerror = fail(t, 'Unexpected database deletion error');

28
tests/wpt/web-platform-tests/IndexedDB/idbfactory-deleteDatabase-request-success.html Normal file
View file

@ -0,0 +1,28 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory deleteDatabase(): request properties on success</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-deleteDatabase">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
async_test(t => {
const dbname = document.location + '-' + t.name;
const rq = indexedDB.deleteDatabase(dbname);
rq.onerror = t.unreached_func('deleteDatabase should succeed');
rq.onsuccess = t.step_func(() => {
assert_equals(
rq.readyState, 'done',
'request done flag should be set on success');
assert_equals(
rq.result, undefined,
'request result should still be set to undefined on success');
assert_equals(
rq.error, null,
'request error should be null on success');
t.done();
});
}, 'Properties of IDBOpenDBRequest during IDBFactory deleteDatabase()');
</script>

66
tests/wpt/web-platform-tests/IndexedDB/idbfactory-open-request-error.html Normal file
View file

@ -0,0 +1,66 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory open(): request properties on error</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-open">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
let saw_abort = false;
indexeddb_test(
(t, db, tx, rq) => {
const store = db.createObjectStore('store');
store.put({name: 'a'}, 1);
store.put({name: 'a'}, 2);
store.createIndex('index', 'name', {unique: true});
assert_equals(
rq.readyState, 'done',
'request done flag should be set during upgradeneeded');
assert_equals(
rq.result, db,
'request result should be set (to connection) during upgradeneeded');
assert_equals(
rq.error, null,
'request result should be null during upgradeneeded');
tx.oncomplete = t.unreached_func('transaction should abort');
tx.onabort = t.step_func(() => {
saw_abort = true;
assert_equals(
rq.readyState, 'done',
'request done flag should still be set during abort');
// Chrome is flaky here. See: https://crbug.com/723846
/*
assert_equals(
rq.result, db,
'request result should still be set (to connection) during abort');
assert_equals(
rq.error, null,
'request result should still be null during abort');
*/
});
rq.onerror = t.step_func(() => {
assert_true(saw_abort, 'abort event should fire before error');
assert_equals(
rq.readyState, 'done',
'request done flag should be set on error');
assert_equals(
rq.result, undefined,
'request result should be undefined on error');
assert_equals(
rq.error.name, 'AbortError',
'request error should be AbortError on error');
t.done();
});
},
(t, db) => {},
'Properties of IDBOpenDBRequest during failed IDBFactory open()',
{upgrade_will_abort: true});
</script>

54
tests/wpt/web-platform-tests/IndexedDB/idbfactory-open-request-success.html Normal file
View file

@ -0,0 +1,54 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>IDBFactory open(): request properties on success</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#dom-idbfactory-open">
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=support.js></script>
<script>
let saw_complete = false;
indexeddb_test(
(t, db, tx, rq) => {
assert_equals(
rq.readyState, 'done',
'request done flag should be set during upgradeneeded');
assert_equals(
rq.result, db,
'request result should be set (to connection) during upgradeneeded');
assert_equals(
rq.error, null,
'request result should be null during upgradeneeded');
tx.onabort = t.unreached_func('transaction should complete');
tx.oncomplete = t.step_func(() => {
saw_complete = true;
assert_equals(
rq.readyState, 'done',
'request done flag should still be set during complete');
assert_equals(
rq.result, db,
'request result should still be set (to connection) during complete');
assert_equals(
rq.error, null,
'request result should still be null during complete');
});
},
(t, db, rq) => {
assert_true(saw_complete, 'complete event should fire before success');
assert_equals(
rq.readyState, 'done',
'request done flag should be set on success');
assert_equals(
rq.result, db,
'request result should still be set (to connection) on success');
assert_equals(
rq.error, null,
'request error should be null on success');
t.done();
},
'Properties of IDBOpenDBRequest during successful IDBFactory open()');
</script>

2
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open10.htm
View file

@ -81,6 +81,8 @@
});
idx.getKey("Sicking").onsuccess = this.step_func(function(e) {
assert_equals(e.target.result, undefined, "getKey(Sicking)");
db3.close();
this.done();
});
});

2
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open11.htm
View file

@ -51,6 +51,8 @@
count_done++;
assert_equals(count_done, 3, "count_done");
db2.close();
this.done();
});
});

1
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open3.htm
View file

@ -17,6 +17,7 @@
var open_rq2 = window.indexedDB.open(db.name);
open_rq2.onsuccess = this.step_func(function(e) {
assert_equals(e.target.result.version, 13, "db.version")
e.target.result.close();
this.done();
});
open_rq2.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

4
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open6.htm
View file

@ -8,13 +8,14 @@
<script>
var open_rq = createdb(async_test(), undefined, 13);
var did_upgrade = false;
var open_rq2;
open_rq.onupgradeneeded = function() {};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.close();
var open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2.onupgradeneeded = function() {};
open_rq2.onsuccess = this.step_func(open_previous_db);
open_rq2.onerror = fail(this, 'Unexpected error')
@ -24,6 +25,7 @@
var open_rq3 = window.indexedDB.open(e.target.result.name, 13);
open_rq3.onerror = this.step_func(function(e) {
assert_equals(e.target.error.name, 'VersionError', 'e.target.error.name')
open_rq2.result.close();
this.done();
});
open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

5
tests/wpt/web-platform-tests/IndexedDB/idbfactory_open7.htm
View file

@ -8,13 +8,14 @@
<script>
var open_rq = createdb(async_test(), undefined, 13);
var did_upgrade = false;
var open_rq2;
open_rq.onupgradeneeded = function() {};
open_rq.onsuccess = function(e) {
var db = e.target.result;
db.close();
var open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2 = window.indexedDB.open(db.name, 14);
open_rq2.onupgradeneeded = function() {
did_upgrade = true;
};
@ -26,6 +27,8 @@
var open_rq3 = window.indexedDB.open(e.target.result.name);
open_rq3.onsuccess = this.step_func(function(e) {
assert_equals(e.target.result.version, 14, "db.version")
open_rq2.result.close();
open_rq3.result.close();
this.done();
});
open_rq3.onupgradeneeded = fail(this, 'Unexpected upgradeneeded')

58
tests/wpt/web-platform-tests/IndexedDB/idbindex_getAll.html
View file

@ -2,26 +2,14 @@
<title>IndexedDB: Test IDBIndex.getAll.</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
var ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
function doSetup(dbName, dbVersion, onsuccess) {
var delete_request = indexedDB.deleteDatabase(dbName);
delete_request.onerror = function() {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
function getall_test(func, name) {
indexeddb_test(
function(t, connection, tx) {
var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'});
var index = store.createIndex('test_idx', 'upper');
@ -61,8 +49,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
store = connection.createObjectStore('empty', null);
index = store.createIndex('test_idx', 'upper');
};
};
},
func,
name
);
}
function createGetAllRequest(t, storeName, connection, range, maxCount) {
@ -74,9 +64,7 @@ function createGetAllRequest(t, storeName, connection, range, maxCount) {
return req;
}
doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
var connection = evt.target.result;
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, 'C');
req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result;
@ -87,7 +75,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Single item get');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [],
@ -96,7 +84,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Empty object store');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result;
@ -107,7 +95,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get all keys');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined,
10);
req.onsuccess = t.step_func(function(evt) {
@ -119,7 +107,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'maxCount=10');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'));
req.onsuccess = t.step_func(function(evt) {
@ -130,7 +118,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get bound range');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'), 3);
req.onsuccess = t.step_func(function(evt) {
@ -142,7 +130,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get bound range with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', false, true));
req.onsuccess = t.step_func(function(evt) {
@ -154,7 +142,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get upper excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', true, false));
req.onsuccess = t.step_func(function(evt) {
@ -166,7 +154,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get lower excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated',
connection, IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) {
@ -177,7 +165,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Get bound range (generated) with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line',
connection, "Doesn't exist");
req.onsuccess = t.step_func(function(evt) {
@ -188,7 +176,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Non existent key');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
undefined, 0);
req.onsuccess = t.step_func(function(evt) {
@ -200,7 +188,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'maxCount=0');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line-not-unique', connection,
'first');
req.onsuccess = t.step_func(function(evt) {
@ -212,7 +200,7 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Retrieve multiEntry key');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line-multi', connection,
'vowel');
req.onsuccess = t.step_func(function(evt) {
@ -225,8 +213,4 @@ doSetup(location.pathname + '-IDBIndex.getAll', 1, function(evt) {
});
}, 'Retrieve one key multiple values');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script>

57
tests/wpt/web-platform-tests/IndexedDB/idbindex_getAllKeys.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBIndex.getAllKeys.</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) {
var delete_request = indexedDB.deleteDatabase(dbName);
delete_request.onerror = function() {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
function getall_test(func, name) {
indexeddb_test(
function(t, connection, tx) {
var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'});
var index = store.createIndex('test_idx', 'upper');
@ -51,8 +40,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
store = connection.createObjectStore('empty', null);
index = store.createIndex('test_idx', 'upper');
};
};
},
func,
name
);
}
function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
@ -64,9 +55,7 @@ function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
return req;
}
doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
var connection = evt.target.result;
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'C');
req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result;
@ -75,7 +64,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Single item get');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [],
@ -84,7 +73,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Empty object store');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, alphabet,
@ -93,7 +82,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get all keys');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result,
@ -104,7 +93,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get all generated keys');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
10);
req.onsuccess = t.step_func(function(evt) {
@ -115,7 +104,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'maxCount=10');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'));
req.onsuccess = t.step_func(function(evt) {
@ -126,7 +115,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get bound range');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'M'), 3);
req.onsuccess = t.step_func(function(evt) {
@ -137,7 +126,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get bound range with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', false, true));
req.onsuccess = t.step_func(function(evt) {
@ -148,7 +137,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get upper excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('G', 'K', true, false));
req.onsuccess = t.step_func(function(evt) {
@ -159,7 +148,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get lower excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated',
connection, IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) {
@ -169,7 +158,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Get bound range (generated) with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line',
connection, "Doesn't exist");
req.onsuccess = t.step_func(function(evt) {
@ -180,7 +169,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'Non existent key');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
undefined, 0);
req.onsuccess = t.step_func(function(evt) {
@ -190,7 +179,7 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
});
}, 'maxCount=0');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line-multi', connection,
'vowel');
req.onsuccess = t.step_func(function(evt) {
@ -200,8 +189,4 @@ doSetup(location.pathname + '-IDBIndex.getAllKeys', 1, function(evt) {
req.onerror = t.unreached_func('getAllKeys request should succeed');
}, 'Retrieve multiEntry keys');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script>

1
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_deleteIndex.htm
View file

@ -35,6 +35,7 @@
assert_throws('NotFoundError',
function() { index = objStore.index("index") });
assert_equals(index, undefined);
db.close();
t.done();
}
}

55
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getAll.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBObjectStore.getAll.</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) {
var delete_request = indexedDB.deleteDatabase(dbName);
delete_request.onerror = function() {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
function getall_test(func, name) {
indexeddb_test(
function(t, connection, tx) {
var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'});
alphabet.forEach(function(letter) {
@ -33,8 +22,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
});
store = connection.createObjectStore('empty', null);
};
};
},
func,
name
);
}
function createGetAllRequest(t, storeName, connection, range, maxCount) {
@ -45,9 +36,7 @@ function createGetAllRequest(t, storeName, connection, range, maxCount) {
return req;
}
doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
var connection = evt.target.result;
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, 'c');
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, ['value-c']);
@ -55,7 +44,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Single item get');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated', connection, 3);
req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result;
@ -67,7 +56,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Single item get (generated key)');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [],
@ -76,7 +65,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'getAll on empty object store');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result,
@ -85,7 +74,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get all values');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined,
10);
req.onsuccess = t.step_func(function(evt) {
@ -95,7 +84,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Test maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'));
req.onsuccess = t.step_func(function(evt) {
@ -105,7 +94,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get bound range');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'), 3);
req.onsuccess = t.step_func(function(evt) {
@ -115,7 +104,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get bound range with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', false, true));
req.onsuccess = t.step_func(function(evt) {
@ -125,7 +114,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get upper excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', true, false));
req.onsuccess = t.step_func(function(evt) {
@ -135,7 +124,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get lower excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'generated', connection,
IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) {
@ -147,7 +136,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'Get bound range (generated) with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection,
"Doesn't exist");
req.onsuccess = t.step_func(function(evt) {
@ -158,7 +147,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
req.onerror = t.unreached_func('getAll request should succeed');
}, 'Non existent key');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllRequest(t, 'out-of-line', connection, undefined, 0);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result,
@ -167,8 +156,4 @@ doSetup(location.pathname + '-IDBObjectStore.getAll', 1, function(evt) {
});
}, 'zero maxCount');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script>

55
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getAllKeys.html
View file

@ -2,25 +2,14 @@
<title>IndexedDB: Test IDBObjectStore.getAllKeys.</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
setup({explicit_done: true});
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
function doSetup(dbName, dbVersion, onsuccess) {
var delete_request = indexedDB.deleteDatabase(dbName);
delete_request.onerror = function() {
assert_unreached('deleteDatabase should not fail');
};
delete_request.onsuccess = function(e) {
var req = indexedDB.open(dbName, dbVersion);
req.onsuccess = onsuccess;
req.onerror = function() {
assert_unreached('open should not fail');
};
req.onupgradeneeded = function(evt) {
var connection = evt.target.result;
function getall_test(func, name) {
indexeddb_test(
function(t, connection, tx) {
var store = connection.createObjectStore('generated',
{autoIncrement: true, keyPath: 'id'});
alphabet.forEach(function(letter) {
@ -33,8 +22,10 @@ function doSetup(dbName, dbVersion, onsuccess) {
});
store = connection.createObjectStore('empty', null);
};
};
},
func,
name
);
}
function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
@ -45,9 +36,7 @@ function createGetAllKeysRequest(t, storeName, connection, range, maxCount) {
return req;
}
doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
var connection = evt.target.result;
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, 'c');
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, ['c']);
@ -55,7 +44,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Single item get');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection, 3);
req.onsuccess = t.step_func(function(evt) {
var data = evt.target.result;
@ -65,7 +54,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Single item get (generated key)');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'empty', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, [],
@ -75,7 +64,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'getAllKeys on empty object store');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection);
req.onsuccess = t.step_func(function(evt) {
assert_array_equals(evt.target.result, alphabet);
@ -83,7 +72,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get all values');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
10);
req.onsuccess = t.step_func(function(evt) {
@ -92,7 +81,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Test maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'));
req.onsuccess = t.step_func(function(evt) {
@ -101,7 +90,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get bound range');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'm'), 3);
req.onsuccess = t.step_func(function(evt) {
@ -110,7 +99,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get bound range with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', false, true));
req.onsuccess = t.step_func(function(evt) {
@ -119,7 +108,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get upper excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
IDBKeyRange.bound('g', 'k', true, false));
req.onsuccess = t.step_func(function(evt) {
@ -128,7 +117,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get lower excluded');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'generated', connection,
IDBKeyRange.bound(4, 15), 3);
req.onsuccess = t.step_func(function(evt) {
@ -139,7 +128,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'Get bound range (generated) with maxCount');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection,
"Doesn't exist");
req.onsuccess = t.step_func(function(evt) {
@ -151,7 +140,7 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
req.onerror = t.unreached_func('getAllKeys request should succeed');
}, 'Non existent key');
async_test(function(t) {
getall_test(function(t, connection) {
var req = createGetAllKeysRequest(t, 'out-of-line', connection, undefined,
0);
req.onsuccess = t.step_func(function(evt) {
@ -160,8 +149,4 @@ doSetup(location.pathname + '-IDBObjectStore.getAllKeys', 1, function(evt) {
});
}, 'zero maxCount');
// Explicit done needed in case async_test body fails synchronously.
done();
});
</script>

21
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_getKey.html
View file

@ -4,17 +4,12 @@
<meta name=timeout content=long>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
function getkey_test(func, name) {
return async_test(function(t) {
var del = indexedDB.deleteDatabase(name);
del.onerror = t.unreached_func('deleteDatabase failed');
var open = indexedDB.open(name);
open.onerror = t.unreached_func('open failed');
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
indexeddb_test(
function(t, db, tx) {
var basic = db.createObjectStore('basic');
var key_path_store = db.createObjectStore('key path',
{keyPath: 'id'});
@ -30,12 +25,10 @@ function getkey_test(func, name) {
key_generator_store.put('value: ' + i);
key_generator_and_path_store.put({});
}
});
open.onsuccess = t.step_func(function() {
var db = open.result;
func(t, db);
});
}, name);
},
func,
name
);
}
getkey_test(function(t, db) {

33
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_openCursor_invalid.htm
View file

@ -4,28 +4,17 @@
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
var db, open;
setup(function() {
open = indexedDB.open('testdb-' + new Date().getTime());
open.onupgradeneeded = function(e) {
db = e.target.result;
indexeddb_test(
function(t, db, tx) {
var objStore = db.createObjectStore("test");
objStore.createIndex("index", "");
objStore.add("data", 1);
objStore.add("data2", 2);
};
},
{ explicit_done: true });
open.onsuccess = function() {
async_test(document.title + " - pass something other than number").step(function(e) {
},
function(t, db, tx) {
var idx = db.transaction("test").objectStore("test").index("index");
assert_throws("DataError",
@ -37,14 +26,8 @@
assert_throws("DataError",
function() { idx.openCursor({ lower: "a", lowerOpen: false, upper: null, upperOpen: false }); });
this.done();
});
// Stop blocking the testing system from hereon
done();
}
t.done();
},
document.title + " - pass something other than number"
);
</script>
<div id="log"></div>

30
tests/wpt/web-platform-tests/IndexedDB/idbobjectstore_openKeyCursor.htm
View file

@ -2,26 +2,20 @@
<title>IDBObjectStore.openKeyCursor()</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support.js"></script>
<script>
function store_test(func, name) {
async_test(function(t) {
var del = indexedDB.deleteDatabase(name);
del.onerror = t.unreached_func("deleteDatabase failed");
var open = indexedDB.open(name);
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
var store = db.createObjectStore("store");
for (var i = 0; i < 10; ++i) {
store.put("value: " + i, i);
}
});
open.onsuccess = t.step_func(function() {
var db = open.result;
var tx = db.transaction("store");
var store = tx.objectStore("store");
func(t, db, tx, store);
});
indexeddb_test(
function(t, db, tx) {
var store = db.createObjectStore("store");
for (var i = 0; i < 10; ++i) {
store.put("value: " + i, i);
}
},
function(t, db) {
var tx = db.transaction("store");
var store = tx.objectStore("store");
func(t, db, tx, store);
}, name);
}

6
tests/wpt/web-platform-tests/IndexedDB/idbrequest-onupgradeneeded.htm
View file

@ -16,6 +16,12 @@ function upgradeneeded_test(upgrade_func, success_func, error_func, description)
var open_request = indexedDB.open(dbName);
open_request.onupgradeneeded = t.step_func(function() {
t.add_cleanup(function() {
if (open_request.result) {
open_request.result.close(),
indexedDB.deleteDatabase(dbName);
}
});
upgrade_func(t, open_request);
});
open_request.onsuccess = t.step_func(function() {

71
tests/wpt/web-platform-tests/IndexedDB/idbtransaction.htm
View file

@ -6,41 +6,54 @@
<script src="support.js"></script>
<script>
var db,
t = async_test(document.title + " - request gotten by the handler"),
open_t = async_test(document.title + " - request returned by open()"),
async_test(function(t) {
var open_rq = indexedDB.open("idbtransaction-" + document.location + t.name);
open_rq = indexedDB.open("idbtransaction-" + new Date().getTime() + Math.random());
open_rq.onblocked = t.unreached_func('open_rq.onblocked');
open_rq.onerror = t.unreached_func('open_rq.onerror');
open_t.step(function() {
assert_equals(open_rq.transaction, null, "IDBOpenDBRequest.transaction");
assert_equals(open_rq.source, null, "IDBOpenDBRequest.source");
assert_equals(open_rq.readyState, "pending", "IDBOpenDBRequest.readyState");
assert_true(open_rq instanceof IDBOpenDBRequest, "open_rq instanceof IDBOpenDBRequest");
assert_equals(open_rq + "", "[object IDBOpenDBRequest]", "IDBOpenDBRequest (open_rq)");
open_t.done();
open_rq.onupgradeneeded = t.step_func(function(e) {
t.add_cleanup(function() {
open_rq.onerror = function(e) {
e.preventDefault();
};
open_rq.result.close();
indexedDB.deleteDatabase(open_rq.result.name);
});
open_rq.onupgradeneeded = t.step_func(function(e) {
assert_equals(e.target, open_rq, "e.target is reusing the same IDBOpenDBRequest");
assert_equals(e.target.transaction, open_rq.transaction, "IDBOpenDBRequest.transaction");
assert_equals(e.target, open_rq, "e.target is reusing the same IDBOpenDBRequest");
assert_equals(e.target.transaction, open_rq.transaction, "IDBOpenDBRequest.transaction");
assert_true(e.target.transaction instanceof IDBTransaction, "transaction instanceof IDBTransaction");
t.done();
assert_true(e.target.transaction instanceof IDBTransaction, "transaction instanceof IDBTransaction");
t.done();
});
}, document.title + " - request gotten by the handler");
async_test(function(t) {
var open_rq = indexedDB.open("idbtransaction-" + document.location + t.name);
assert_equals(open_rq.transaction, null, "IDBOpenDBRequest.transaction");
assert_equals(open_rq.source, null, "IDBOpenDBRequest.source");
assert_equals(open_rq.readyState, "pending", "IDBOpenDBRequest.readyState");
assert_true(open_rq instanceof IDBOpenDBRequest, "open_rq instanceof IDBOpenDBRequest");
assert_equals(open_rq + "", "[object IDBOpenDBRequest]", "IDBOpenDBRequest (open_rq)");
open_rq.onblocked = t.unreached_func('open_rq.onblocked');
open_rq.onerror = t.unreached_func('open_rq.onerror');
open_rq.onupgradeneeded = t.step_func(function() {
t.add_cleanup(function() {
open_rq.onerror = function(e) {
e.preventDefault();
};
open_rq.result.close();
indexedDB.deleteDatabase(open_rq.result.name);
});
t.done();
});
}, document.title + " - request returned by open()");
// Not plausible conditions...
function fail_helper(name) {
return function() {
t.step(function() { assert_unreached(name); });
open_t.step(function() { assert_unreached(name); });
};
}
open_rq.onblocked = fail_helper('open_rq.onblocked');
open_rq.onerror = fail_helper('open_rq.onerror');
</script>
<div id="log"></div>

3
tests/wpt/web-platform-tests/IndexedDB/idbtransaction_objectStoreNames.html
View file

@ -73,7 +73,8 @@ indexeddb_test(function(t, db, tx) {
assert_array_equals(saved_tx.objectStoreNames, ['s2', 's3'],
'previous transaction objectStoreNames should be unchanged');
assert_array_equals(db.objectStoreNames, saved_tx.objectStoreNames,
'connection and transaction objectStoreNames should match');
'connection and transaction objectStoreNames should match');
db2.close();
t.done();
});
}, 'IDBTransaction.objectStoreNames - value after close');

288
tests/wpt/web-platform-tests/IndexedDB/large-nested-cloning.html Normal file
View file

@ -0,0 +1,288 @@
<!doctype html>
<meta charset="utf8">
<meta name="timeout" content="long">
<title>IndexedDB: large nested objects are cloned correctly</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#abort-transaction">
<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support-promises.js"></script>
<script>
'use strict';
// Should be large enough to trigger large value handling in the IndexedDB
// engines that have special code paths for large values.
const wrapThreshold = 128 * 1024;
// Returns an IndexedDB value created from a descriptor.
//
// See the bottom of the file for descriptor samples.
function createValue(descriptor) {
if (typeof(descriptor) != 'object')
return descriptor;
if (Array.isArray(descriptor))
return descriptor.map((element) => createValue(element));
if (!descriptor.hasOwnProperty('type')) {
const value = {};
for (let property of Object.getOwnPropertyNames(descriptor))
value[property] = createValue(descriptor[property]);
return value;
}
switch (descriptor.type) {
case 'blob':
return new Blob(
[largeValue(descriptor.size, descriptor.seed)],
{ type: descriptor.mimeType });
case 'buffer':
return largeValue(descriptor.size, descriptor.seed);
}
}
// Checks an IndexedDB value against a descriptor.
//
// Returns a Promise that resolves if the value passes the check.
//
// See the bottom of the file for descriptor samples.
function checkValue(testCase, value, descriptor) {
if (typeof(descriptor) != 'object') {
assert_equals(
descriptor, value,
'IndexedDB result should match put() argument');
return Promise.resolve();
}
if (Array.isArray(descriptor)) {
assert_true(
Array.isArray(value),
'IndexedDB result type should match put() argument');
assert_equals(
descriptor.length, value.length,
'IndexedDB result array size should match put() argument');
const subChecks = [];
for (let i = 0; i < descriptor.length; ++i)
subChecks.push(checkValue(testCase, value[i], descriptor[i]));
return Promise.all(subChecks);
}
if (!descriptor.hasOwnProperty('type')) {
assert_array_equals(
Object.getOwnPropertyNames(value).sort(),
Object.getOwnPropertyNames(descriptor).sort(),
'IndexedDB result object properties should match put() argument');
const subChecks = [];
return Promise.all(Object.getOwnPropertyNames(descriptor).map(property =>
checkValue(testCase, value[property], descriptor[property])));
}
switch (descriptor.type) {
case 'blob':
assert_class_string(
value, 'Blob',
'IndexedDB result class should match put() argument');
assert_equals(
descriptor.mimeType, value.type,
'IndexedDB result Blob MIME type should match put() argument');
assert_equals(descriptor.size, value.size, 'incorrect Blob size');
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onloadend = testCase.step_func(() => {
if (reader.error) {
reject(reader.error);
return;
}
const view = new Uint8Array(reader.result);
assert_equals(
view.join(','),
largeValue(descriptor.size, descriptor.seed).join(','),
'IndexedDB result Blob content should match put() argument');
resolve();
});
reader.readAsArrayBuffer(value);
});
case 'buffer':
assert_class_string(
value, 'Uint8Array',
'IndexedDB result type should match put() argument');
assert_equals(
value.join(','),
largeValue(descriptor.size, descriptor.seed).join(','),
'IndexedDB result typed array content should match put() argument');
return Promise.resolve();
}
}
// Performs a series of put()s and verifies that get()s and getAll() match.
//
// Each element of the valueDescriptors array is fed into createValue(), and the
// resulting value is written to IndexedDB via a put() request. After the writes
// complete, the values are read in the same order in which they were written.
// Last, all the results are read one more time via a getAll().
//
// The test verifies that the get() / getAll() results match the arguments to
// put() and that the order in which the get() result events are fired matches
// the order of the get() requests.
function cloningTest(label, valueDescriptors) {
promise_test(testCase => {
return createDatabase(testCase, (database, transaction) => {
const store = database.createObjectStore('test-store');
for (let i = 0; i < valueDescriptors.length; ++i) {
store.put(createValue(valueDescriptors[i]), i);
}
}).then(database => {
const transaction = database.transaction(['test-store'], 'readonly');
const store = transaction.objectStore('test-store');
const subChecks = [];
let resultIndex = 0;
for (let i = 0; i < valueDescriptors.length; ++i) {
subChecks.push(new Promise((resolve, reject) => {
const requestIndex = i;
const request = store.get(requestIndex);
request.onerror =
testCase.step_func(() => { reject(request.error); });
request.onsuccess = testCase.step_func(() => {
assert_equals(
resultIndex, requestIndex,
'IDBRequest success events should be fired in request order');
++resultIndex;
resolve(checkValue(
testCase, request.result, valueDescriptors[requestIndex]));
});
}));
}
subChecks.push(new Promise((resolve, reject) => {
const requestIndex = valueDescriptors.length;
const request = store.getAll();
request.onerror =
testCase.step_func(() => { reject(request.error); });
request.onsuccess = testCase.step_func(() => {
assert_equals(
resultIndex, requestIndex,
'IDBRequest success events should be fired in request order');
++resultIndex;
resolve(checkValue(
testCase, request.result, valueDescriptors));
});
}));
return Promise.all(subChecks);
});
}, label);
}
cloningTest('small typed array', [
{ type: 'buffer', size: 64, seed: 1 },
]);
cloningTest('large typed array', [
{ type: 'buffer', size: wrapThreshold, seed: 1 },
])
cloningTest('blob', [
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-1', seed: 1 },
]);
cloningTest('blob with small typed array', [
{
blob: { type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-01',
seed: 1 },
buffer: { type: 'buffer', size: 64, seed: 2 },
},
]);
cloningTest('blob with large typed array', [
{
blob: { type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-01',
seed: 1 },
buffer: { type: 'buffer', size: wrapThreshold, seed: 2 },
},
]);
cloningTest('blob array', [
[
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-1', seed: 1 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-2', seed: 2 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-3', seed: 3 },
],
]);
cloningTest('array of blobs and small typed arrays', [
[
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-01', seed: 1 },
{ type: 'buffer', size: 64, seed: 2 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-03', seed: 3 },
{ type: 'buffer', size: 64, seed: 4 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-05', seed: 5 },
],
]);
cloningTest('array of blobs and large typed arrays', [
[
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-01', seed: 1 },
{ type: 'buffer', size: wrapThreshold, seed: 2 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-03', seed: 3 },
{ type: 'buffer', size: wrapThreshold, seed: 4 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-05', seed: 5 },
],
]);
cloningTest('object with blobs and large typed arrays', [
{
blob: { type: 'blob', size: wrapThreshold,
mimeType: 'text/x-blink1', seed: 1 },
more: [
{ type: 'buffer', size: wrapThreshold, seed: 2 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink3', seed: 3 },
{ type: 'buffer', size: wrapThreshold, seed: 4 },
],
blob2: { type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink5',
seed: 5 },
},
]);
cloningTest('multiple requests of objects with blobs and large typed arrays', [
{
blob: { type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink1',
seed: 1 },
more: [
{ type: 'buffer', size: wrapThreshold, seed: 2 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink3', seed: 3 },
{ type: 'buffer', size: wrapThreshold, seed: 4 },
],
blob2: { type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink5',
seed: 5 },
},
[
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink06', seed: 6 },
{ type: 'buffer', size: wrapThreshold, seed: 7 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink08', seed: 8 },
{ type: 'buffer', size: wrapThreshold, seed: 9 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink10', seed: 10 },
],
{
data: [
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-11',
seed: 11 },
{ type: 'buffer', size: wrapThreshold, seed: 12 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-13',
seed: 13 },
{ type: 'buffer', size: wrapThreshold, seed: 14 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink-15',
seed: 15 },
],
},
[
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink16', seed: 16 },
{ type: 'buffer', size: wrapThreshold, seed: 17 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink18', seed: 18 },
{ type: 'buffer', size: wrapThreshold, seed: 19 },
{ type: 'blob', size: wrapThreshold, mimeType: 'text/x-blink20', seed: 20 },
],
]);
</script>

244
tests/wpt/web-platform-tests/IndexedDB/large-requests-abort.html Normal file
View file

@ -0,0 +1,244 @@
<!doctype html>
<meta charset="utf8">
<meta name="timeout" content="long">
<title>IndexedDB: transactions with large request results are aborted correctly</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#abort-transaction">
<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support-promises.js"></script>
<script>
'use strict';
// Should be large enough to trigger large value handling in the IndexedDB
// engines that have special code paths for large values.
const wrapThreshold = 128 * 1024;
function populateStore(store) {
store.put({id: 1, key: 'k1', value: largeValue(wrapThreshold, 1) });
store.put({id: 2, key: 'k2', value: ['small-2'] });
store.put({id: 3, key: 'k3', value: largeValue(wrapThreshold, 3) });
store.put({id: 4, key: 'k4', value: ['small-4'] });
}
// Opens index cursors for operations that require open cursors.
//
// onsuccess is called if all cursors are opened successfully. Otherwise,
// onerror will be called at least once.
function openCursors(testCase, index, operations, onerror, onsuccess) {
let pendingCursors = 0;
for (let operation of operations) {
const opcode = operation[0];
const primaryKey = operation[1];
let request;
switch (opcode) {
case 'continue':
request = index.openCursor(
IDBKeyRange.lowerBound(`k${primaryKey - 1}`));
break;
case 'continue-empty':
// k4 is the last key in the data set, so calling continue() will get
// the cursor past the end of the store.
request = index.openCursor(IDBKeyRange.lowerBound('k4'));
break;
default:
continue;
}
operation[2] = request;
++pendingCursors;
request.onsuccess = testCase.step_func(() => {
--pendingCursors;
if (!pendingCursors)
onsuccess();
});
request.onerror = testCase.step_func(onerror);
}
if (!pendingCursors)
onsuccess();
}
function doOperation(testCase, store, index, operation, requestId, results) {
const opcode = operation[0];
const primaryKey = operation[1];
const cursor = operation[2];
return new Promise((resolve, reject) => {
let request;
switch (opcode) {
case 'add': // Tests returning a primary key.
request = store.add(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
break;
case 'put': // Tests returning a primary key.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
break;
case 'put-with-id': // Tests returning success or a primary key.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`],
id: primaryKey });
break;
case 'get': // Tests returning a value.
case 'get-empty': // Tests returning undefined.
request = store.get(primaryKey);
break;
case 'getall': // Tests returning an array of values.
request = store.getAll();
break;
case 'error': // Tests returning an error.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
break;
case 'continue': // Tests returning a key, primary key, and value.
case 'continue-empty': // Tests returning null.
request = cursor;
cursor.result.continue();
break;
case 'open': // Tests returning a cursor, key, primary key, and value.
case 'open-empty': // Tests returning null.
request = index.openCursor(IDBKeyRange.lowerBound(`k${primaryKey}`));
break;
case 'count': // Tests returning a numeric result.
request = index.count();
break;
};
request.onsuccess = testCase.step_func(() => {
reject(new Error(
'requests should not succeed after the transaction is aborted'));
});
request.onerror = testCase.step_func(event => {
event.preventDefault();
results.push([requestId, request.error]);
resolve();
});
});
}
function abortTest(label, operations) {
promise_test(testCase => {
return createDatabase(testCase, (database, transaction) => {
const store = database.createObjectStore(
'test-store', { autoIncrement: true, keyPath: 'id' });
store.createIndex('test-index', 'key', { unique: true });
populateStore(store);
}).then(database => {
const transaction = database.transaction(['test-store'], 'readwrite');
const store = transaction.objectStore('test-store');
const index = store.index('test-index');
return new Promise((resolve, reject) => {
openCursors(testCase, index, operations, reject, () => {
const results = [];
const promises = [];
for (let i = 0; i < operations.length; ++i) {
const promise = doOperation(
testCase, store, index, operations[i], i, results);
promises.push(promise);
};
transaction.abort();
resolve(Promise.all(promises).then(() => results));
});
});
}).then(results => {
assert_equals(
results.length, operations.length,
'Promise.all should resolve after all sub-promises resolve');
for (let i = 0; i < operations.length; ++i) {
assert_equals(
results[i][0], i,
'error event order should match request order');
assert_equals(
results[i][1].name, 'AbortError',
'transaction aborting should result in AbortError on all requests');
}
});
}, label);
}
abortTest('small values', [
['get', 2],
['count', null],
['continue-empty', null],
['get-empty', 5],
['add', 5],
['open', 2],
['continue', 2],
['get', 4],
['get-empty', 6],
['count', null],
['put-with-id', 5],
['put', 6],
['error', 3],
['continue', 4],
['count', null],
['get-empty', 7],
['open', 4],
['open-empty', 7],
['add', 7],
]);
abortTest('large values', [
['open', 1],
['get', 1],
['getall', 4],
['get', 3],
['continue', 3],
['open', 3],
]);
abortTest('large value followed by small values', [
['get', 1],
['getall', null],
['open', 2],
['continue-empty', null],
['get', 2],
['get-empty', 5],
['count', null],
['continue-empty', null],
['open-empty', 5],
['add', 5],
['error', 1],
['continue', 2],
['get-empty', 6],
['put-with-id', 5],
['put', 6],
]);
abortTest('large values mixed with small values', [
['get', 1],
['get', 2],
['get-empty', 5],
['count', null],
['continue-empty', null],
['open', 1],
['continue', 2],
['open-empty', 5],
['getall', 4],
['open', 2],
['continue-empty', null],
['add', 5],
['get', 3],
['count', null],
['get-empty', 6],
['put-with-id', 5],
['getall', null],
['continue', 3],
['open-empty', 6],
['put', 6],
['error', 1],
['continue', 2],
['open', 4],
['get-empty', 7],
['count', null],
['continue', 3],
['add', 7],
['getall', null],
['error', 3],
['count', null],
]);
</script>

83
tests/wpt/web-platform-tests/IndexedDB/request-abort-ordering.html Normal file
View file

@ -0,0 +1,83 @@
<!doctype html>
<meta charset="utf8">
<meta name="timeout" content="long">
<title>IndexedDB: request abort events are delivered in order</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#abort-transaction">
<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support-promises.js"></script>
<script>
'use strict';
promise_test(testCase => {
let requests;
return createDatabase(testCase, (database, transaction) => {
createBooksStore(testCase, database);
}).then(database => {
const transaction = database.transaction(['books'], 'readwrite');
const store = transaction.objectStore('books');
const index = store.index('by_author');
const cursorRequest = store.openCursor(IDBKeyRange.lowerBound(0));
return new Promise((resolve, reject) => {
cursorRequest.onerror = testCase.step_func(event => {
event.preventDefault();
reject(cursorRequest.error);
});
cursorRequest.onsuccess = testCase.step_func(() => {
const cursor = cursorRequest.result;
requests = [
() => store.get(123456),
() => index.get('Fred'),
() => store.count(),
() => index.count(),
() => store.put({title: 'Bedrock II', author: 'Barney', isbn: 987 }),
() => store.getAll(),
() => index.getAll(),
() => store.get(999999),
() => index.get('Nobody'),
() => store.openCursor(IDBKeyRange.lowerBound(0)),
() => index.openCursor(IDBKeyRange.lowerBound('')),
() => { cursor.continue(); return cursorRequest; },
];
const results = [];
const promises = [];
for (let i = 0; i < requests.length; ++i) {
promises.push(new Promise((resolve, reject) => {
const requestId = i;
const request = requests[i](store);
request.onsuccess = testCase.step_func(() => {
reject(new Error(
'IDB requests should not succeed after transaction abort'));
});
request.onerror = testCase.step_func(event => {
event.preventDefault();
results.push([requestId, request.error]);
resolve();
});
}));
};
transaction.abort();
resolve(Promise.all(promises).then(() => results));
});
});
}).then(results => {
assert_equals(
results.length, requests.length,
'Promise.all should resolve after all sub-promises resolve');
for (let i = 0; i < requests.length; ++i) {
assert_equals(
results[i][0], i,
'error event order should match request order');
assert_equals(
results[i][1].name, 'AbortError',
'transaction aborting should result in AbortError on all requests');
}
});
});
</script>

369
tests/wpt/web-platform-tests/IndexedDB/request-event-ordering.html Normal file
View file

@ -0,0 +1,369 @@
<!doctype html>
<meta charset="utf8">
<meta name="timeout" content="long">
<title>IndexedDB: request result events are delivered in order</title>
<link rel="help" href="https://w3c.github.io/IndexedDB/#abort-transaction">
<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="support-promises.js"></script>
<script>
'use strict';
// Should be large enough to trigger large value handling in the IndexedDB
// engines that have special code paths for large values.
const wrapThreshold = 128 * 1024;
function populateStore(store) {
store.put({id: 1, key: 'k1', value: largeValue(wrapThreshold, 1) });
store.put({id: 2, key: 'k2', value: ['small-2'] });
store.put({id: 3, key: 'k3', value: largeValue(wrapThreshold, 3) });
store.put({id: 4, key: 'k4', value: ['small-4'] });
}
// Assigns cursor indexes for operations that require open cursors.
//
// Returns the number of open cursors required to perform all operations.
function assignCursors(operations) {
return cursorCount;
}
// Opens index cursors for operations that require open cursors.
//
// onsuccess is called if all cursors are opened successfully. Otherwise,
// onerror will be called at least once.
function openCursors(testCase, index, operations, onerror, onsuccess) {
let pendingCursors = 0;
for (let operation of operations) {
const opcode = operation[0];
const primaryKey = operation[1];
let request;
switch (opcode) {
case 'continue':
request = index.openCursor(
IDBKeyRange.lowerBound(`k${primaryKey - 1}`));
break;
case 'continue-empty':
// k4 is the last key in the data set, so calling continue() will get
// the cursor past the end of the store.
request = index.openCursor(IDBKeyRange.lowerBound('k4'));
break;
default:
continue;
}
operation[2] = request;
++pendingCursors;
request.onsuccess = testCase.step_func(() => {
--pendingCursors;
if (!pendingCursors)
onsuccess();
});
request.onerror = testCase.step_func(onerror);
}
if (!pendingCursors)
onsuccess();
}
function doOperation(testCase, store, index, operation, requestId, results) {
const opcode = operation[0];
const primaryKey = operation[1];
const cursor = operation[2];
return new Promise((resolve, reject) => {
let request;
switch (opcode) {
case 'add': // Tests returning a primary key.
request = store.add(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
break;
case 'put': // Tests returning a primary key.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
break;
case 'put-with-id': // Tests returning success or a primary key.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`],
id: primaryKey });
break;
case 'get': // Tests returning a value.
case 'get-empty': // Tests returning undefined.
request = store.get(primaryKey);
break;
case 'getall': // Tests returning an array of values.
request = store.getAll();
break;
case 'error': // Tests returning an error.
request = store.put(
{ key: `k${primaryKey}`, value: [`small-${primaryKey}`] });
request.onerror = testCase.step_func(event => {
event.preventDefault();
results.push([requestId, request.error]);
resolve();
});
request.onsuccess = testCase.step_func(() => {
reject(new Error('put with duplicate primary key succeded'));
});
break;
case 'continue': // Tests returning a key, primary key, and value.
request = cursor;
cursor.result.continue();
request.onsuccess = testCase.step_func(() => {
const result = request.result;
results.push(
[requestId, result.key, result.primaryKey, result.value]);
resolve();
});
request.onerror = null;
break;
case 'open': // Tests returning a cursor, key, primary key, and value.
request = index.openCursor(IDBKeyRange.lowerBound(`k${primaryKey}`));
request.onsuccess = testCase.step_func(() => {
const result = request.result;
results.push(
[requestId, result.key, result.primaryKey, result.value]);
resolve();
});
break;
case 'continue-empty': // Tests returning a null result.
request = cursor;
cursor.result.continue();
request.onsuccess = testCase.step_func(() => {
results.push([requestId, request.result]);
resolve();
});
request.onerror = null;
break;
case 'open-empty': // Tests returning a null cursor.
request = index.openCursor(IDBKeyRange.lowerBound(`k${primaryKey}`));
request.onsuccess = testCase.step_func(() => {
const result = request.result;
results.push([requestId, request.result]);
resolve();
});
break;
case 'count': // Tests returning a numeric result.
request = index.count();
request.onsuccess = testCase.step_func(() => {
results.push([requestId, request.result]);
resolve();
});
break;
};
if (!request.onsuccess) {
request.onsuccess = testCase.step_func(() => {
results.push([requestId, request.result]);
resolve();
});
}
if (!request.onerror)
request.onerror = testCase.step_func(event => {
event.preventDefault();
reject(request.error);
});
});
}
function checkOperationResult(operation, result, requestId) {
const opcode = operation[0];
const primaryKey = operation[1];
const expectedValue = (primaryKey == 1 || primaryKey == 3) ?
largeValue(wrapThreshold, primaryKey) : [`small-${primaryKey}`];
const requestIndex = result[0];
assert_equals(
requestIndex, requestId, 'result event order should match request order');
switch (opcode) {
case 'put':
case 'put-with-id':
case 'add':
assert_equals(
result[1], primaryKey,
`${opcode} result should be the new object's primary key`);
break;
case 'get':
assert_equals(
result[1].id, primaryKey,
'get result should match put value (primary key)');
assert_equals(
result[1].key, `k${primaryKey}`,
'get result should match put value (key)');
assert_equals(
result[1].value.join(','), expectedValue.join(','),
'get result should match put value (nested value)');
break;
case 'getall':
assert_equals(
result[1].length, primaryKey,
'getAll should return all the objects in the store');
for (let i = 0; i < primaryKey; ++i) {
const object = result[1][i];
assert_equals(
object.id, i + 1,
`getAll result ${i + 1} should match put value (primary key)`);
assert_equals(
object.key, `k${i + 1}`,
`get result ${i + 1} should match put value (key)`);
const expectedValue = (i == 0 || i == 2) ?
largeValue(wrapThreshold, i + 1) : [`small-${i + 1}`];
assert_equals(
object.value.join(','), object.value.join(','),
`get result ${i + 1} should match put value (nested value)`);
}
break;
case 'get-empty':
assert_equals(
result[1], undefined, 'get-empty result should be undefined');
break;
case 'error':
assert_equals(
result[1].name, 'ConstraintError',
'incorrect error from put with duplicate primary key');
break;
case 'continue':
case 'open':
assert_equals(
result[1], `k${primaryKey}`,
`${opcode} key should match the key in the put value`);
assert_equals(
result[2], primaryKey,
`${opcode} primary key should match the put value's primary key`);
assert_equals(
result[3].id, primaryKey,
`${opcode} value should match put value (primary key)`);
assert_equals(
result[3].key, `k${primaryKey}`,
`${opcode} value should match put value (key)`);
assert_equals(
result[3].value.join(','), expectedValue.join(','),
`${opcode} value should match put value (nested value)`);
break;
case 'continue-empty':
case 'open-empty':
assert_equals(result[1], null, `${opcode} result should be null`);
break;
}
}
function eventsTest(label, operations) {
promise_test(testCase => {
return createDatabase(testCase, (database, transaction) => {
const store = database.createObjectStore(
'test-store', { autoIncrement: true, keyPath: 'id' });
store.createIndex('test-index', 'key', { unique: true });
populateStore(store);
}).then(database => {
const transaction = database.transaction(['test-store'], 'readwrite');
const store = transaction.objectStore('test-store');
const index = store.index('test-index');
return new Promise((resolve, reject) => {
openCursors(testCase, index, operations, reject, () => {
const results = [];
const promises = [];
for (let i = 0; i < operations.length; ++i) {
const promise = doOperation(
testCase, store, index, operations[i], i, results);
promises.push(promise);
};
resolve(Promise.all(promises).then(() => results));
});
});
}).then(results => {
assert_equals(
results.length, operations.length,
'Promise.all should resolve after all sub-promises resolve');
for (let i = 0; i < operations.length; ++i)
checkOperationResult(operations[i], results[i], i);
});
}, label);
}
eventsTest('small values', [
['get', 2],
['count', 4],
['continue-empty', null],
['get-empty', 5],
['add', 5],
['open', 2],
['continue', 2],
['get', 4],
['get-empty', 6],
['count', 5],
['put-with-id', 5],
['put', 6],
['error', 3],
['continue', 4],
['count', 6],
['get-empty', 7],
['open', 4],
['open-empty', 7],
['add', 7],
]);
eventsTest('large values', [
['open', 1],
['get', 1],
['getall', 4],
['get', 3],
['continue', 3],
['open', 3],
]);
eventsTest('large value followed by small values', [
['get', 1],
['getall', 4],
['open', 2],
['continue-empty', null],
['get', 2],
['get-empty', 5],
['count', 4],
['continue-empty', null],
['open-empty', 5],
['add', 5],
['error', 1],
['continue', 2],
['get-empty', 6],
['put-with-id', 5],
['put', 6],
]);
eventsTest('large values mixed with small values', [
['get', 1],
['get', 2],
['get-empty', 5],
['count', 4],
['continue-empty', null],
['open', 1],
['continue', 2],
['open-empty', 5],
['getall', 4],
['open', 2],
['continue-empty', null],
['add', 5],
['get', 3],
['count', 5],
['get-empty', 6],
['put-with-id', 5],
['getall', 5],
['continue', 3],
['open-empty', 6],
['put', 6],
['error', 1],
['continue', 2],
['open', 4],
['get-empty', 7],
['count', 6],
['continue', 3],
['add', 7],
['getall', 7],
['error', 3],
['count', 7],
]);
</script>

20
tests/wpt/web-platform-tests/IndexedDB/support-promises.js
View file

@ -270,3 +270,23 @@ function checkTitleIndexContents(testCase, index, errorMessage) {
assert_equals(result.author, BOOKS_RECORD_DATA[2].author, errorMessage);
});
}
// Returns an Uint8Array with pseudorandom data.
//
// The PRNG should be sufficient to defeat compression schemes, but it is not
// cryptographically strong.
function largeValue(size, seed) {
const buffer = new Uint8Array(size);
// 32-bit xorshift - the seed can't be zero
let state = 1000 + seed;
for (let i = 0; i < size; ++i) {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
buffer[i] = state & 0xff;
}
return buffer;
}

30
tests/wpt/web-platform-tests/IndexedDB/support.js
View file

@ -106,30 +106,34 @@ function assert_key_equals(actual, expected, description) {
function indexeddb_test(upgrade_func, open_func, description, options) {
async_test(function(t) {
var options = Object.assign({upgrade_will_abort: false}, options);
options = Object.assign({upgrade_will_abort: false}, options);
var dbname = document.location + '-' + t.name;
var del = indexedDB.deleteDatabase(dbname);
del.onerror = t.unreached_func('deleteDatabase should succeed');
var open = indexedDB.open(dbname, 1);
if (!options.upgrade_will_abort) {
open.onsuccess = t.unreached_func('open should not succeed');
} else {
open.onerror = t.unreached_func('open should succeed');
}
open.onupgradeneeded = t.step_func(function() {
var db = open.result;
var tx = open.transaction;
upgrade_func(t, db, tx);
});
open.onsuccess = t.step_func(function() {
var db = open.result;
t.add_cleanup(function() {
// If open didn't succeed already, ignore the error.
open.onerror = function(e) {
e.preventDefault();
};
db.close();
indexedDB.deleteDatabase(db.name);
});
if (open_func)
open_func(t, db);
var tx = open.transaction;
upgrade_func(t, db, tx, open);
});
if (options.upgrade_will_abort) {
open.onsuccess = t.unreached_func('open should not succeed');
} else {
open.onerror = t.unreached_func('open should succeed');
open.onsuccess = t.step_func(function() {
var db = open.result;
if (open_func)
open_func(t, db, open);
});
}
}, description);
}