Add deletion test, cursor read with writeback to same store.

chrome/test/data/indexeddb/perf_test.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var overallTestStartTime = Date.now();
 var kUseIndex = true;
 var kDontUseIndex = false;
 var kReadKeysOnly = true;
 var kReadDataToo = false;
 var kWriteToo = true;
 var kDontWrite = false;
+var kWriteSameStore = true;
+var kWriteDifferentStore = false;
+var kPlaceholderArg = false;
 
 var tests = [
+  /*  These tests give crazy results, and the fourth times out.
+   *  See crbug.com/140123.
+
+// Create a few small items in a single object store, then delete everything.
+  [testCreateAndDeleteDatabase,  4,    1,    1],
+// Create a few small items in a single object store, then delete everything.
+  [testCreateAndDeleteDatabase,  3,    1,    1],
+// Create a couple small items in a single object store, then delete everything.
+  [testCreateAndDeleteDatabase,  2,    1,    1],
+// Create a single small items in a single object store, then delete everything.
+  [testCreateAndDeleteDatabase,  1,    1,    1],
+  */
 // Create a single small item in a single object store.
   [testCreateKeysInStores, 1,     1,    1],
 // Create many small items in a single object store.
   [testCreateKeysInStores, 100,   1,    1],
 // Create a single small item in many object stores.
   [testCreateKeysInStores, 1,     100,  1],
 // Create many large items in a single object store.
   [testCreateKeysInStores, 100,   1,    10000],
 // Read a few random items in each of many transactions.
   [testRandomReadsAndWrites, 1000,  5,    0,  50, kDontUseIndex],
 // Read many random items in each of a few transactions.
   [testRandomReadsAndWrites, 1000,  50,   0,  5,  kDontUseIndex],
 // Read many random items in each of a few transactions, in a large store.
   [testRandomReadsAndWrites, 5000,  50,   0,  5,  kDontUseIndex],
 // Read a few random items from an index, in each of many transactions.
   [testRandomReadsAndWrites, 1000,  5,    0,  50, kUseIndex],
 // Read many random items from an index, in each of a few transactions.
   [testRandomReadsAndWrites, 1000,  50,   0,  5,  kUseIndex],
 // Read many random items from an index, in each of a few transactions, in a
 // large store.
   [testRandomReadsAndWrites, 5000,  50,   0,  5,  kUseIndex],
 // Read and write a few random items in each of many transactions.
   [testRandomReadsAndWrites, 1000,  5,    5,  50, kDontUseIndex],
 // Read and write a few random items, reading from an index, in each of many
 // transactions.
   [testRandomReadsAndWrites, 1000,  5,    5,  50, kUseIndex],
 // Read a long, contiguous sequence of an object store via a cursor.
-  [testCursorReadsAndRandomWrites, kReadDataToo, kDontUseIndex, kDontWrite],
+  [testCursorReadsAndRandomWrites, kReadDataToo, kDontUseIndex, kDontWrite,
+   kPlaceholderArg],
 // Read a sequence of an object store via a cursor, writing
 // transformed values into another.
-  [testCursorReadsAndRandomWrites, kReadDataToo, kDontUseIndex, kWriteToo],
+  [testCursorReadsAndRandomWrites, kReadDataToo, kDontUseIndex, kWriteToo,
+   kWriteDifferentStore],
+// Read a sequence of an object store via a cursor, writing
+// transformed values into another.
+  [testCursorReadsAndRandomWrites, kReadDataToo, kDontUseIndex, kWriteToo,
+   kWriteSameStore],
 // Read a sequence of an index into an object store via a cursor.
-  [testCursorReadsAndRandomWrites, kReadDataToo, kUseIndex, kDontWrite],
+  [testCursorReadsAndRandomWrites, kReadDataToo, kUseIndex, kDontWrite,
+   kPlaceholderArg],
 // Read a sequence of an index into an object store via a key cursor.
-  [testCursorReadsAndRandomWrites, kReadKeysOnly, kUseIndex, kDontWrite],
+  [testCursorReadsAndRandomWrites, kReadKeysOnly, kUseIndex, kDontWrite,
+   kPlaceholderArg],
 // Make batches of random writes into a store, triggered by periodic setTimeout
 // calls.
   [testSporadicWrites, 5, 0],
 // Make large batches of random writes into a store, triggered by periodic
 // setTimeout calls.
   [testSporadicWrites, 50, 0],
 // Make batches of random writes into a store with many indices, triggered by
 // periodic setTimeout calls.
   [testSporadicWrites, 5, 10],
 // Make large batches of random writes into a store with many indices, triggered
@@ skipping 20 matching lines @@
     onAllTestsComplete();
   }
 }
 
 function onAllTestsComplete() {
   var overallDuration = Date.now() - overallTestStartTime;
   automation.addResult("OverallTestDuration", overallDuration);
   automation.setDone();
 }
 
+function testCreateAndDeleteDatabase(
+    numKeys, numStores, payloadLength, onTestComplete) {
+  var testName = getDisplayName(arguments);
+  assert(numKeys >= 0);
+  assert(numStores >= 1);
+  var objectStoreNames = [];
+  for (var i=0; i < numStores; ++i) {
+    objectStoreNames.push("store " + i);
+  }
+  var value = stringOfLength(payloadLength);
+  function getValue() {
+    return value;
+  }
+
+  automation.setStatus("Creating database.");
+  var startTime = Date.now();
+
+  createDatabase(testName, objectStoreNames, onCreated, onError);
+
+  function onCreated(db) {
+    automation.setStatus("Constructing transaction.");
+    var transaction =
+        getTransaction(db, objectStoreNames, "readwrite", onValuesWritten);
+    putLinearValues(transaction, objectStoreNames, numKeys, null, getValue);
+  }
+
+  function onValuesWritten() {
+    automation.setStatus("Deleting database.");
+    deleteDatabase(testName, onDeleted);

[jsbell, 2012/08/01 23:05:26]

Need to call db.close() before deleteDatabase() or you'll be waiting for GC to
kick in and collect it before the delete can proceed.

Tossing an onblocked handler on the delete request could log this. And/or add an
onversionchange handler to the database. Or both. :)

[ericu, 2012/08/01 23:39:43]

Added onblocked.

+  }
+
+  function onDeleted() {
+    var duration = Date.now() - startTime;
+    automation.addResult(testName, duration);
+    automation.setStatus("Deleted database.");
+    onTestComplete();
+  }
+}
+
 function testCreateKeysInStores(
     numKeys, numStores, payloadLength, onTestComplete) {
   var testName = getDisplayName(arguments);
   assert(numKeys >= 0);
   assert(numStores >= 1);
   var objectStoreNames = [];
   for (var i=0; i < numStores; ++i) {
     objectStoreNames.push("store " + i);
   }
   var value = stringOfLength(payloadLength);
@@ skipping 116 matching lines @@
     completionFunc = getCompletionFunc("testDeleteIndex",
         indexCreationCompleteTime, onTestComplete);
     var f = function(objectStore) {
       objectStore.deleteIndex("index");
     };
     automation.setStatus("Deleting index.");
     alterObjectStores(testName, objectStoreNames, f, completionFunc, onError);
   }
 }
 
-// TODO: Add a version that writes back to the same store, to see how that
-// affects cursor speed w.r.t. invalidated caches.
 function testCursorReadsAndRandomWrites(
-    readKeysOnly, useIndexForReads, writeToAnotherStore, onTestComplete) {
+    readKeysOnly, useIndexForReads, writeAlso, sameStoreForWrites,
+    onTestComplete) {
   // There's no key cursor unless you're reading from an index.
   assert(useIndexForReads || !readKeysOnly);
   // If we're writing to another store, having an index would constrain our
   // writes, as we create both object stores with the same configurations.
   // We could do that if needed, but it's simpler not to.
-  assert(!useIndexForReads || !writeToAnotherStore);
+  assert(!useIndexForReads || !writeAlso);
   var numKeys = 1000;
   var numReadsPerTransaction = 100;
   var testName = getDisplayName(arguments);
   var objectStoreNames = ["input store"];
-  if (writeToAnotherStore)
-    objectStoreNames.push("output store");
+  var outputStoreName;
+  if (writeAlso) {
+    if (sameStoreForWrites) {
+      outputStoreName = objectStoreNames[0];
+    } else {
+      outputStoreName = "output store";
+      objectStoreNames.push(outputStoreName);
+    }
+  }
   var getKeyForRead = getSimpleKey;
   var indexName;
   if (useIndexForReads) {
     indexName = "index";
     getKeyForRead = function(i) {
       // This depends on the implementations of getValuesFromCursor and
       // getObjectValue.  We reverse the order of the iteration here so that
       // setting up bounds from k to k+n with n>0 works.  Without this reversal,
       // the upper bound is below the lower bound.
       return getBackwardIndexKey(numKeys - i);
@@ skipping 17 matching lines @@
     var transaction = getTransaction(db, objectStoreNames, "readwrite",
         function() { onSetupComplete(db); });
     putLinearValues(transaction, objectStoreNames, numKeys, getSimpleKey,
         getObjectValue);
   }
   function onSetupComplete(db) {
     automation.setStatus("Setup complete.");
     var completionFunc =
         getCompletionFunc(testName, Date.now(), onTestComplete);
     var mode = "readonly";
-    if (writeToAnotherStore)
+    if (writeAlso)
       mode = "readwrite";
     var transaction =
         getTransaction(db, objectStoreNames, mode, completionFunc);
 
     getValuesFromCursor(
         transaction, objectStoreNames[0], numReadsPerTransaction, numKeys,
-        indexName, getKeyForRead, readKeysOnly, objectStoreNames[1]);
+        indexName, getKeyForRead, readKeysOnly, outputStoreName);
   }
 }
 
 function testSporadicWrites(
     numWritesPerTransaction, numIndices, onTestComplete) {
   var numKeys = 1000;
   // With 30 transactions, spaced 50ms apart, we'll need at least 1.5s.
   var numTransactions = 30;
   var delayBetweenBatches = 50;
   var indexName;
@@ skipping 47 matching lines @@
 
     var mode = "readonly";
     if (numWritesPerTransaction)
       mode = "readwrite";
 
     var transaction = getTransaction(db, objectStoreNames, mode, batchComplete);
     putRandomValues(transaction, objectStoreNames, numWritesPerTransaction,
         numKeys);
   }
 }