IndexedDB layout tests should make better use of test library functions
authorjsbell@chromium.org <jsbell@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 19 May 2012 23:36:46 +0000 (23:36 +0000)
committerjsbell@chromium.org <jsbell@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 19 May 2012 23:36:46 +0000 (23:36 +0000)
https://bugs.webkit.org/show_bug.cgi?id=86932

Reviewed by Ojan Vafai.

Use functions like shouldBeEqualToString, shouldBeNull,  evalAndExpectException
and so forth where possible.

* storage/indexeddb/basics-expected.txt:
* storage/indexeddb/basics-workers-expected.txt:
* storage/indexeddb/create-object-store-options-expected.txt:
* storage/indexeddb/createObjectStore-null-name-expected.txt:
* storage/indexeddb/cursor-added-bug-expected.txt:
* storage/indexeddb/cursor-continue-expected.txt:
* storage/indexeddb/cursor-continue-validity-expected.txt:
* storage/indexeddb/cursor-delete-expected.txt:
* storage/indexeddb/cursor-inconsistency-expected.txt:
* storage/indexeddb/cursor-index-delete-expected.txt:
* storage/indexeddb/cursor-key-order-expected.txt:
* storage/indexeddb/cursor-primary-key-order-expected.txt:
* storage/indexeddb/cursor-skip-deleted-expected.txt:
* storage/indexeddb/cursor-update-expected.txt:
* storage/indexeddb/data-corruption-expected.txt:
* storage/indexeddb/database-basics-expected.txt:
* storage/indexeddb/duplicates-expected.txt:
* storage/indexeddb/error-causes-abort-by-default-expected.txt:
* storage/indexeddb/exception-in-event-aborts-expected.txt:
* storage/indexeddb/factory-basics-expected.txt:
* storage/indexeddb/factory-cmp-expected.txt:
* storage/indexeddb/factory-deletedatabase-expected.txt:
* storage/indexeddb/get-keyrange-expected.txt:
* storage/indexeddb/index-basics-expected.txt:
* storage/indexeddb/index-basics-workers-expected.txt:
* storage/indexeddb/index-count-expected.txt:
* storage/indexeddb/index-cursor-expected.txt:
* storage/indexeddb/index-multientry-expected.txt:
* storage/indexeddb/index-population-expected.txt:
* storage/indexeddb/index-unique-expected.txt:
* storage/indexeddb/key-type-array-expected.txt:
* storage/indexeddb/keyrange-expected.txt:
* storage/indexeddb/legacy-constants-expected.txt:
* storage/indexeddb/mutating-cursor-expected.txt:
* storage/indexeddb/objectstore-autoincrement-expected.txt:
* storage/indexeddb/objectstore-basics-expected.txt:
* storage/indexeddb/objectstore-basics-workers-expected.txt:
* storage/indexeddb/objectstore-clear-expected.txt:
* storage/indexeddb/objectstore-count-expected.txt:
* storage/indexeddb/objectstore-cursor-expected.txt:
* storage/indexeddb/objectstore-removeobjectstore-expected.txt:
* storage/indexeddb/open-cursor-expected.txt:
* storage/indexeddb/opencursor-key-expected.txt:
* storage/indexeddb/prefetch-bugfix-108071-expected.txt:
* storage/indexeddb/queued-commands-expected.txt:
* storage/indexeddb/request-event-propagation-expected.txt:
* storage/indexeddb/resources/basics.js:
(test):
(openCallback):
* storage/indexeddb/resources/create-object-store-options.js:
(setVersionComplete):
* storage/indexeddb/resources/createObjectStore-null-name.js:
(createAndPopulateObjectStore):
* storage/indexeddb/resources/cursor-added-bug.js:
(setVersionSuccess):
* storage/indexeddb/resources/cursor-continue-validity.js:
(deleteExisting):
* storage/indexeddb/resources/cursor-continue.js:
(deleteExisting):
* storage/indexeddb/resources/cursor-delete.js:
(setVersionSuccess):
* storage/indexeddb/resources/cursor-inconsistency.js:
(setVersionSuccess):
(checkCursor):
* storage/indexeddb/resources/cursor-index-delete.js:
(setVersionSuccess):
* storage/indexeddb/resources/cursor-key-order.js:
(checkStore.curreq.onsuccess.getreq.onsuccess):
(checkStore.curreq.onsuccess):
(checkStore):
* storage/indexeddb/resources/cursor-primary-key-order.js:
(checkStore.cursorRequest.onsuccess):
(checkStore):
* storage/indexeddb/resources/cursor-skip-deleted.js:
(setVersionSuccess):
* storage/indexeddb/resources/cursor-update.js:
(setVersionSuccess):
(basicUpdateCursor.request.onsuccess):
(basicUpdateCursor):
(autoIncrementUpdateCursor.request.onsuccess):
(autoIncrementUpdateCursor):
(keyPathUpdateCursor.request.onsuccess):
(keyPathUpdateCursor):
(keyCursor):
* storage/indexeddb/resources/data-corruption.js:
(setVersionSuccess):
(doCheck):
* storage/indexeddb/resources/database-basics.js:
(setVersionSuccess):
(createAnotherObjectStore):
* storage/indexeddb/resources/database-quota.js:
(setVersionSuccess):
* storage/indexeddb/resources/duplicates.js:
(deleteExisting):
(cursor1Continue):
(cursor1Continue2):
(openObjectCursor):
(cursor2Continue):
(cursor2Continue2):
(last):
* storage/indexeddb/resources/error-causes-abort-by-default.js:
(deleteExisting):
* storage/indexeddb/resources/exception-in-event-aborts.js:
(deleteExisting):
* storage/indexeddb/resources/factory-basics.js:
(test):
* storage/indexeddb/resources/factory-cmp.js:
(test):
(testValidKeys):
(testIdenticalKeys):
* storage/indexeddb/resources/factory-deletedatabase.js:
(deleteExisting):
* storage/indexeddb/resources/get-keyrange.js:
(deleteExisting):
* storage/indexeddb/resources/index-basics.js:
(deleteExisting):
(cursor1Continue):
(cursor1Continue2):
(cursor1Continue3):
(openObjectCursor):
(cursor2Continue):
(cursor2Continue2):
(cursor2Continue3):
(last):
* storage/indexeddb/resources/index-count.js:
(prepareDatabase):
(verifyCount.request.onsuccess):
(verifyCount):
(verifyCountWithRange.nextTest.request.onsuccess):
(verifyCountWithRange.nextTest):
(verifyCountWithRange):
(verifyCountWithKey.nextTest.request.onsuccess):
(verifyCountWithKey.nextTest):
(verifyCountWithKey):
* storage/indexeddb/resources/index-cursor.js:
(deleteExisting):
* storage/indexeddb/resources/index-multientry.js:
(prepareDatabase):
(verifyIndexes.request.onsuccess):
(verifyIndexes):
* storage/indexeddb/resources/index-population.js:
(setVersion2Abort):
* storage/indexeddb/resources/index-unique.js:
(deleteExisting):
(cursorSuccess):
(keyCursorSuccess):
* storage/indexeddb/resources/key-type-array.js:
(test):
* storage/indexeddb/resources/keyrange.js:
(test):
* storage/indexeddb/resources/legacy-constants.js:
(populateStore):
(checkNext.request.onsuccess):
(checkNext):
(checkNextNoDuplicate.request.onsuccess):
(checkNextNoDuplicate):
(checkPrev.request.onsuccess):
(checkPrev):
(checkPrevNoDuplicate.request.onsuccess):
(checkPrevNoDuplicate):
* storage/indexeddb/resources/mutating-cursor.js:
(setVersionSuccess):
* storage/indexeddb/resources/objectstore-autoincrement.js:
(setVersionSuccess):
(testLongKeyPath.cursorRequest.onsuccess):
(testLongKeyPath):
* storage/indexeddb/resources/objectstore-basics.js:
(setVersionSuccess):
(createIndex):
(createAnotherIndex):
(addDateSuccess):
(addAgainFailure):
* storage/indexeddb/resources/objectstore-clear.js:
(deleteExisting):
* storage/indexeddb/resources/objectstore-count.js:
(prepareDatabase):
(verifyCount.request.onsuccess):
(verifyCount):
(verifyCountWithRange.nextTest.request.onsuccess):
(verifyCountWithRange.nextTest):
(verifyCountWithRange):
(verifyCountWithKey.nextTest.request.onsuccess):
(verifyCountWithKey.nextTest):
(verifyCountWithKey):
* storage/indexeddb/resources/objectstore-cursor.js:
(deleteExisting):
* storage/indexeddb/resources/objectstore-removeobjectstore.js:
(deleteExisting):
(deleteObjectStore):
* storage/indexeddb/resources/open-cursor.js:
(cursorWithKeySuccess):
(cursorSuccess):
(setVersionSuccess):
* storage/indexeddb/resources/opencursor-key.js:
(testObjectStore.request.onsuccess):
(testObjectStore):
(testIndex.request.onsuccess):
(testIndex):
(testIndexWithKey.request.onsuccess):
(testIndexWithKey):
* storage/indexeddb/resources/prefetch-bugfix-108071.js:
(setVersionSuccess):
* storage/indexeddb/resources/queued-commands.js:
* storage/indexeddb/resources/request-event-propagation.js:
(deleteExisting):
* storage/indexeddb/resources/setVersion-null.js:
(postSetVersion):
* storage/indexeddb/resources/shared.js:
(evalAndExpectExceptionClass):
* storage/indexeddb/resources/transaction-abort.js:
(deleteExisting):
* storage/indexeddb/resources/transaction-and-objectstore-calls.js:
(created):
(afterComplete):
* storage/indexeddb/resources/transaction-basics.js:
(addRemoveIDBObjects):
(addRemoveAddIDBObjects):
(addIDBObjects):
(addIDBObjectsAndCommit):
(removeIDBObjects):
(setVersionSuccess):
(testDOMStringList):
* storage/indexeddb/resources/transaction-event-propagation.js:
(deleteExisting):
* storage/indexeddb/resources/transaction-rollback.js:
(addSuccess):
(getSuccess):
* storage/indexeddb/resources/two-version-changes.js:
(test):
* storage/indexeddb/resources/values-odd-types.js:
(openACursor.request.onsuccess):
(openACursor):
* storage/indexeddb/setVersion-null-expected.txt:
* storage/indexeddb/transaction-abort-expected.txt:
* storage/indexeddb/transaction-and-objectstore-calls-expected.txt:
* storage/indexeddb/transaction-basics-expected.txt:
* storage/indexeddb/transaction-event-propagation-expected.txt:
* storage/indexeddb/transaction-rollback-expected.txt:
* storage/indexeddb/two-version-changes-expected.txt:
* storage/indexeddb/values-odd-types-expected.txt:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@117702 268f45cc-cd09-0410-ab3c-d52691b4dbfc

108 files changed:
LayoutTests/ChangeLog
LayoutTests/storage/indexeddb/basics-expected.txt
LayoutTests/storage/indexeddb/basics-workers-expected.txt
LayoutTests/storage/indexeddb/create-object-store-options-expected.txt
LayoutTests/storage/indexeddb/createObjectStore-null-name-expected.txt
LayoutTests/storage/indexeddb/cursor-added-bug-expected.txt
LayoutTests/storage/indexeddb/cursor-continue-expected.txt
LayoutTests/storage/indexeddb/cursor-continue-validity-expected.txt
LayoutTests/storage/indexeddb/cursor-delete-expected.txt
LayoutTests/storage/indexeddb/cursor-inconsistency-expected.txt
LayoutTests/storage/indexeddb/cursor-index-delete-expected.txt
LayoutTests/storage/indexeddb/cursor-key-order-expected.txt
LayoutTests/storage/indexeddb/cursor-primary-key-order-expected.txt
LayoutTests/storage/indexeddb/cursor-skip-deleted-expected.txt
LayoutTests/storage/indexeddb/cursor-update-expected.txt
LayoutTests/storage/indexeddb/data-corruption-expected.txt
LayoutTests/storage/indexeddb/database-basics-expected.txt
LayoutTests/storage/indexeddb/duplicates-expected.txt
LayoutTests/storage/indexeddb/error-causes-abort-by-default-expected.txt
LayoutTests/storage/indexeddb/exception-in-event-aborts-expected.txt
LayoutTests/storage/indexeddb/factory-basics-expected.txt
LayoutTests/storage/indexeddb/factory-cmp-expected.txt
LayoutTests/storage/indexeddb/factory-deletedatabase-expected.txt
LayoutTests/storage/indexeddb/get-keyrange-expected.txt
LayoutTests/storage/indexeddb/index-basics-expected.txt
LayoutTests/storage/indexeddb/index-basics-workers-expected.txt
LayoutTests/storage/indexeddb/index-count-expected.txt
LayoutTests/storage/indexeddb/index-cursor-expected.txt
LayoutTests/storage/indexeddb/index-multientry-expected.txt
LayoutTests/storage/indexeddb/index-population-expected.txt
LayoutTests/storage/indexeddb/index-unique-expected.txt
LayoutTests/storage/indexeddb/key-type-array-expected.txt
LayoutTests/storage/indexeddb/keyrange-expected.txt
LayoutTests/storage/indexeddb/legacy-constants-expected.txt
LayoutTests/storage/indexeddb/mutating-cursor-expected.txt
LayoutTests/storage/indexeddb/objectstore-autoincrement-expected.txt
LayoutTests/storage/indexeddb/objectstore-basics-expected.txt
LayoutTests/storage/indexeddb/objectstore-basics-workers-expected.txt
LayoutTests/storage/indexeddb/objectstore-clear-expected.txt
LayoutTests/storage/indexeddb/objectstore-count-expected.txt
LayoutTests/storage/indexeddb/objectstore-cursor-expected.txt
LayoutTests/storage/indexeddb/objectstore-removeobjectstore-expected.txt
LayoutTests/storage/indexeddb/open-cursor-expected.txt
LayoutTests/storage/indexeddb/opencursor-key-expected.txt
LayoutTests/storage/indexeddb/prefetch-bugfix-108071-expected.txt
LayoutTests/storage/indexeddb/queued-commands-expected.txt
LayoutTests/storage/indexeddb/request-event-propagation-expected.txt
LayoutTests/storage/indexeddb/resources/basics.js
LayoutTests/storage/indexeddb/resources/create-object-store-options.js
LayoutTests/storage/indexeddb/resources/createObjectStore-null-name.js
LayoutTests/storage/indexeddb/resources/cursor-added-bug.js
LayoutTests/storage/indexeddb/resources/cursor-continue-validity.js
LayoutTests/storage/indexeddb/resources/cursor-continue.js
LayoutTests/storage/indexeddb/resources/cursor-delete.js
LayoutTests/storage/indexeddb/resources/cursor-inconsistency.js
LayoutTests/storage/indexeddb/resources/cursor-index-delete.js
LayoutTests/storage/indexeddb/resources/cursor-key-order.js
LayoutTests/storage/indexeddb/resources/cursor-primary-key-order.js
LayoutTests/storage/indexeddb/resources/cursor-skip-deleted.js
LayoutTests/storage/indexeddb/resources/cursor-update.js
LayoutTests/storage/indexeddb/resources/data-corruption.js
LayoutTests/storage/indexeddb/resources/database-basics.js
LayoutTests/storage/indexeddb/resources/database-quota.js
LayoutTests/storage/indexeddb/resources/duplicates.js
LayoutTests/storage/indexeddb/resources/error-causes-abort-by-default.js
LayoutTests/storage/indexeddb/resources/exception-in-event-aborts.js
LayoutTests/storage/indexeddb/resources/factory-basics.js
LayoutTests/storage/indexeddb/resources/factory-cmp.js
LayoutTests/storage/indexeddb/resources/factory-deletedatabase.js
LayoutTests/storage/indexeddb/resources/get-keyrange.js
LayoutTests/storage/indexeddb/resources/index-basics.js
LayoutTests/storage/indexeddb/resources/index-count.js
LayoutTests/storage/indexeddb/resources/index-cursor.js
LayoutTests/storage/indexeddb/resources/index-multientry.js
LayoutTests/storage/indexeddb/resources/index-population.js
LayoutTests/storage/indexeddb/resources/index-unique.js
LayoutTests/storage/indexeddb/resources/key-type-array.js
LayoutTests/storage/indexeddb/resources/keyrange.js
LayoutTests/storage/indexeddb/resources/legacy-constants.js
LayoutTests/storage/indexeddb/resources/mutating-cursor.js
LayoutTests/storage/indexeddb/resources/objectstore-autoincrement.js
LayoutTests/storage/indexeddb/resources/objectstore-basics.js
LayoutTests/storage/indexeddb/resources/objectstore-clear.js
LayoutTests/storage/indexeddb/resources/objectstore-count.js
LayoutTests/storage/indexeddb/resources/objectstore-cursor.js
LayoutTests/storage/indexeddb/resources/objectstore-removeobjectstore.js
LayoutTests/storage/indexeddb/resources/open-cursor.js
LayoutTests/storage/indexeddb/resources/opencursor-key.js
LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js
LayoutTests/storage/indexeddb/resources/queued-commands.js
LayoutTests/storage/indexeddb/resources/request-event-propagation.js
LayoutTests/storage/indexeddb/resources/setVersion-null.js
LayoutTests/storage/indexeddb/resources/shared.js
LayoutTests/storage/indexeddb/resources/transaction-abort.js
LayoutTests/storage/indexeddb/resources/transaction-and-objectstore-calls.js
LayoutTests/storage/indexeddb/resources/transaction-basics.js
LayoutTests/storage/indexeddb/resources/transaction-event-propagation.js
LayoutTests/storage/indexeddb/resources/transaction-rollback.js
LayoutTests/storage/indexeddb/resources/two-version-changes.js
LayoutTests/storage/indexeddb/resources/values-odd-types.js
LayoutTests/storage/indexeddb/setVersion-null-expected.txt
LayoutTests/storage/indexeddb/transaction-abort-expected.txt
LayoutTests/storage/indexeddb/transaction-and-objectstore-calls-expected.txt
LayoutTests/storage/indexeddb/transaction-basics-expected.txt
LayoutTests/storage/indexeddb/transaction-event-propagation-expected.txt
LayoutTests/storage/indexeddb/transaction-rollback-expected.txt
LayoutTests/storage/indexeddb/two-version-changes-expected.txt
LayoutTests/storage/indexeddb/values-odd-types-expected.txt

index 5fd032b..50021e6 100644 (file)
@@ -1,3 +1,254 @@
+2012-05-19  Joshua Bell  <jsbell@chromium.org>
+
+        IndexedDB layout tests should make better use of test library functions
+        https://bugs.webkit.org/show_bug.cgi?id=86932
+
+        Reviewed by Ojan Vafai.
+
+        Use functions like shouldBeEqualToString, shouldBeNull,  evalAndExpectException
+        and so forth where possible.
+
+        * storage/indexeddb/basics-expected.txt:
+        * storage/indexeddb/basics-workers-expected.txt:
+        * storage/indexeddb/create-object-store-options-expected.txt:
+        * storage/indexeddb/createObjectStore-null-name-expected.txt:
+        * storage/indexeddb/cursor-added-bug-expected.txt:
+        * storage/indexeddb/cursor-continue-expected.txt:
+        * storage/indexeddb/cursor-continue-validity-expected.txt:
+        * storage/indexeddb/cursor-delete-expected.txt:
+        * storage/indexeddb/cursor-inconsistency-expected.txt:
+        * storage/indexeddb/cursor-index-delete-expected.txt:
+        * storage/indexeddb/cursor-key-order-expected.txt:
+        * storage/indexeddb/cursor-primary-key-order-expected.txt:
+        * storage/indexeddb/cursor-skip-deleted-expected.txt:
+        * storage/indexeddb/cursor-update-expected.txt:
+        * storage/indexeddb/data-corruption-expected.txt:
+        * storage/indexeddb/database-basics-expected.txt:
+        * storage/indexeddb/duplicates-expected.txt:
+        * storage/indexeddb/error-causes-abort-by-default-expected.txt:
+        * storage/indexeddb/exception-in-event-aborts-expected.txt:
+        * storage/indexeddb/factory-basics-expected.txt:
+        * storage/indexeddb/factory-cmp-expected.txt:
+        * storage/indexeddb/factory-deletedatabase-expected.txt:
+        * storage/indexeddb/get-keyrange-expected.txt:
+        * storage/indexeddb/index-basics-expected.txt:
+        * storage/indexeddb/index-basics-workers-expected.txt:
+        * storage/indexeddb/index-count-expected.txt:
+        * storage/indexeddb/index-cursor-expected.txt:
+        * storage/indexeddb/index-multientry-expected.txt:
+        * storage/indexeddb/index-population-expected.txt:
+        * storage/indexeddb/index-unique-expected.txt:
+        * storage/indexeddb/key-type-array-expected.txt:
+        * storage/indexeddb/keyrange-expected.txt:
+        * storage/indexeddb/legacy-constants-expected.txt:
+        * storage/indexeddb/mutating-cursor-expected.txt:
+        * storage/indexeddb/objectstore-autoincrement-expected.txt:
+        * storage/indexeddb/objectstore-basics-expected.txt:
+        * storage/indexeddb/objectstore-basics-workers-expected.txt:
+        * storage/indexeddb/objectstore-clear-expected.txt:
+        * storage/indexeddb/objectstore-count-expected.txt:
+        * storage/indexeddb/objectstore-cursor-expected.txt:
+        * storage/indexeddb/objectstore-removeobjectstore-expected.txt:
+        * storage/indexeddb/open-cursor-expected.txt:
+        * storage/indexeddb/opencursor-key-expected.txt:
+        * storage/indexeddb/prefetch-bugfix-108071-expected.txt:
+        * storage/indexeddb/queued-commands-expected.txt:
+        * storage/indexeddb/request-event-propagation-expected.txt:
+        * storage/indexeddb/resources/basics.js:
+        (test):
+        (openCallback):
+        * storage/indexeddb/resources/create-object-store-options.js:
+        (setVersionComplete):
+        * storage/indexeddb/resources/createObjectStore-null-name.js:
+        (createAndPopulateObjectStore):
+        * storage/indexeddb/resources/cursor-added-bug.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/cursor-continue-validity.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/cursor-continue.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/cursor-delete.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/cursor-inconsistency.js:
+        (setVersionSuccess):
+        (checkCursor):
+        * storage/indexeddb/resources/cursor-index-delete.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/cursor-key-order.js:
+        (checkStore.curreq.onsuccess.getreq.onsuccess):
+        (checkStore.curreq.onsuccess):
+        (checkStore):
+        * storage/indexeddb/resources/cursor-primary-key-order.js:
+        (checkStore.cursorRequest.onsuccess):
+        (checkStore):
+        * storage/indexeddb/resources/cursor-skip-deleted.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/cursor-update.js:
+        (setVersionSuccess):
+        (basicUpdateCursor.request.onsuccess):
+        (basicUpdateCursor):
+        (autoIncrementUpdateCursor.request.onsuccess):
+        (autoIncrementUpdateCursor):
+        (keyPathUpdateCursor.request.onsuccess):
+        (keyPathUpdateCursor):
+        (keyCursor):
+        * storage/indexeddb/resources/data-corruption.js:
+        (setVersionSuccess):
+        (doCheck):
+        * storage/indexeddb/resources/database-basics.js:
+        (setVersionSuccess):
+        (createAnotherObjectStore):
+        * storage/indexeddb/resources/database-quota.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/duplicates.js:
+        (deleteExisting):
+        (cursor1Continue):
+        (cursor1Continue2):
+        (openObjectCursor):
+        (cursor2Continue):
+        (cursor2Continue2):
+        (last):
+        * storage/indexeddb/resources/error-causes-abort-by-default.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/exception-in-event-aborts.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/factory-basics.js:
+        (test):
+        * storage/indexeddb/resources/factory-cmp.js:
+        (test):
+        (testValidKeys):
+        (testIdenticalKeys):
+        * storage/indexeddb/resources/factory-deletedatabase.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/get-keyrange.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/index-basics.js:
+        (deleteExisting):
+        (cursor1Continue):
+        (cursor1Continue2):
+        (cursor1Continue3):
+        (openObjectCursor):
+        (cursor2Continue):
+        (cursor2Continue2):
+        (cursor2Continue3):
+        (last):
+        * storage/indexeddb/resources/index-count.js:
+        (prepareDatabase):
+        (verifyCount.request.onsuccess):
+        (verifyCount):
+        (verifyCountWithRange.nextTest.request.onsuccess):
+        (verifyCountWithRange.nextTest):
+        (verifyCountWithRange):
+        (verifyCountWithKey.nextTest.request.onsuccess):
+        (verifyCountWithKey.nextTest):
+        (verifyCountWithKey):
+        * storage/indexeddb/resources/index-cursor.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/index-multientry.js:
+        (prepareDatabase):
+        (verifyIndexes.request.onsuccess):
+        (verifyIndexes):
+        * storage/indexeddb/resources/index-population.js:
+        (setVersion2Abort):
+        * storage/indexeddb/resources/index-unique.js:
+        (deleteExisting):
+        (cursorSuccess):
+        (keyCursorSuccess):
+        * storage/indexeddb/resources/key-type-array.js:
+        (test):
+        * storage/indexeddb/resources/keyrange.js:
+        (test):
+        * storage/indexeddb/resources/legacy-constants.js:
+        (populateStore):
+        (checkNext.request.onsuccess):
+        (checkNext):
+        (checkNextNoDuplicate.request.onsuccess):
+        (checkNextNoDuplicate):
+        (checkPrev.request.onsuccess):
+        (checkPrev):
+        (checkPrevNoDuplicate.request.onsuccess):
+        (checkPrevNoDuplicate):
+        * storage/indexeddb/resources/mutating-cursor.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/objectstore-autoincrement.js:
+        (setVersionSuccess):
+        (testLongKeyPath.cursorRequest.onsuccess):
+        (testLongKeyPath):
+        * storage/indexeddb/resources/objectstore-basics.js:
+        (setVersionSuccess):
+        (createIndex):
+        (createAnotherIndex):
+        (addDateSuccess):
+        (addAgainFailure):
+        * storage/indexeddb/resources/objectstore-clear.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/objectstore-count.js:
+        (prepareDatabase):
+        (verifyCount.request.onsuccess):
+        (verifyCount):
+        (verifyCountWithRange.nextTest.request.onsuccess):
+        (verifyCountWithRange.nextTest):
+        (verifyCountWithRange):
+        (verifyCountWithKey.nextTest.request.onsuccess):
+        (verifyCountWithKey.nextTest):
+        (verifyCountWithKey):
+        * storage/indexeddb/resources/objectstore-cursor.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/objectstore-removeobjectstore.js:
+        (deleteExisting):
+        (deleteObjectStore):
+        * storage/indexeddb/resources/open-cursor.js:
+        (cursorWithKeySuccess):
+        (cursorSuccess):
+        (setVersionSuccess):
+        * storage/indexeddb/resources/opencursor-key.js:
+        (testObjectStore.request.onsuccess):
+        (testObjectStore):
+        (testIndex.request.onsuccess):
+        (testIndex):
+        (testIndexWithKey.request.onsuccess):
+        (testIndexWithKey):
+        * storage/indexeddb/resources/prefetch-bugfix-108071.js:
+        (setVersionSuccess):
+        * storage/indexeddb/resources/queued-commands.js:
+        * storage/indexeddb/resources/request-event-propagation.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/setVersion-null.js:
+        (postSetVersion):
+        * storage/indexeddb/resources/shared.js:
+        (evalAndExpectExceptionClass):
+        * storage/indexeddb/resources/transaction-abort.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/transaction-and-objectstore-calls.js:
+        (created):
+        (afterComplete):
+        * storage/indexeddb/resources/transaction-basics.js:
+        (addRemoveIDBObjects):
+        (addRemoveAddIDBObjects):
+        (addIDBObjects):
+        (addIDBObjectsAndCommit):
+        (removeIDBObjects):
+        (setVersionSuccess):
+        (testDOMStringList):
+        * storage/indexeddb/resources/transaction-event-propagation.js:
+        (deleteExisting):
+        * storage/indexeddb/resources/transaction-rollback.js:
+        (addSuccess):
+        (getSuccess):
+        * storage/indexeddb/resources/two-version-changes.js:
+        (test):
+        * storage/indexeddb/resources/values-odd-types.js:
+        (openACursor.request.onsuccess):
+        (openACursor):
+        * storage/indexeddb/setVersion-null-expected.txt:
+        * storage/indexeddb/transaction-abort-expected.txt:
+        * storage/indexeddb/transaction-and-objectstore-calls-expected.txt:
+        * storage/indexeddb/transaction-basics-expected.txt:
+        * storage/indexeddb/transaction-event-propagation-expected.txt:
+        * storage/indexeddb/transaction-rollback-expected.txt:
+        * storage/indexeddb/two-version-changes-expected.txt:
+        * storage/indexeddb/values-odd-types-expected.txt:
+
 2012-05-19  Raphael Kubo da Costa  <rakuco@webkit.org>
 
         [EFL] Unreviewed gardening.
index 0b652b7..78704b6 100644 (file)
@@ -23,7 +23,7 @@ PASS request.source is indexedDB
 PASS 'transaction' in request is true
 PASS request.transaction is null
 PASS 'readyState' in request is true
-PASS request.readyState is 'pending'
+PASS request.readyState is "pending"
 PASS 'onsuccess' in request is true
 PASS request.onsuccess is null
 PASS 'onerror' in request is true
@@ -39,7 +39,7 @@ PASS request.source is indexedDB
 PASS 'transaction' in event.target is true
 PASS event.target.transaction is null
 PASS 'readyState' in request is true
-PASS event.target.readyState is 'done'
+PASS event.target.readyState is "done"
 PASS 'onsuccess' in event.target is true
 PASS 'onerror' in event.target is true
 PASS successfullyParsed is true
index bb18f22..be0c021 100644 (file)
@@ -24,7 +24,7 @@ PASS [Worker] request.source is indexedDB
 PASS [Worker] 'transaction' in request is true
 PASS [Worker] request.transaction is null
 PASS [Worker] 'readyState' in request is true
-PASS [Worker] request.readyState is 'pending'
+PASS [Worker] request.readyState is "pending"
 PASS [Worker] 'onsuccess' in request is true
 PASS [Worker] request.onsuccess is null
 PASS [Worker] 'onerror' in request is true
@@ -40,7 +40,7 @@ PASS [Worker] request.source is indexedDB
 PASS [Worker] 'transaction' in event.target is true
 PASS [Worker] event.target.transaction is null
 PASS [Worker] 'readyState' in request is true
-PASS [Worker] event.target.readyState is 'done'
+PASS [Worker] event.target.readyState is "done"
 PASS [Worker] 'onsuccess' in event.target is true
 PASS [Worker] 'onerror' in event.target is true
 PASS successfullyParsed is true
index 3b82799..eee0812 100644 (file)
@@ -13,7 +13,7 @@ db.createObjectStore('a', {keyPath: 'a'})
 db.createObjectStore('b')
 db.createObjectStore('c', {autoIncrement: true});
 trans = db.transaction(['a', 'b'], 'readwrite')
-PASS trans.mode is 'readwrite'
+PASS trans.mode is "readwrite"
 trans.objectStore('a').put({'a': 0})
 Expecting TypeError exception from db.createObjectStore('d', 'bar');
 PASS Exception was thrown.
index e6f0c86..fc4536c 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 request = db.setVersion('1')
 Deleted all object stores.
 db.createObjectStore(null);
-PASS objectStore.name is 'null'
+PASS objectStore.name is "null"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 815eb0c..ca7c567 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('cursor-delete')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('test')
 objectStore.add(1, 1)
index 82f8444..12caa6a 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('cursor-continue')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('someObjectStore')
 objectStore.createIndex('someIndex', 'x')
index 82e1517..b767645 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('cursor-continue')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('someObjectStore')
 objectStore.createIndex('someIndex', 'x')
index 6965834..8707475 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('test')
 objectStore.add('myValue1', 'myKey1')
index e5962a0..ab867fa 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('basicStore')
 objectStore.add('someValue1', 'someKey1').onerror = unexpectedErrorCallback
@@ -24,7 +24,7 @@ objectStore.openCursor(keyRange)
 
 checkCursor()
 storedCursor = event.target.result
-PASS storedCursor === event.target.result is true
+PASS storedCursor is event.target.result
 PASS storedCursor.key is "someKey1"
 PASS event.target.result.key is "someKey1"
 PASS storedCursor.value is "someValue1"
@@ -32,7 +32,7 @@ PASS event.target.result.value is "someValue1"
 event.target.result.continue()
 
 checkCursor()
-PASS storedCursor === event.target.result is true
+PASS storedCursor is event.target.result
 PASS storedCursor.key is "someKey2"
 PASS event.target.result.key is "someKey2"
 PASS storedCursor.value is "someValue2"
@@ -40,7 +40,7 @@ PASS event.target.result.value is "someValue2"
 event.target.result.continue()
 
 checkCursor()
-PASS storedCursor === event.target.result is true
+PASS storedCursor is event.target.result
 PASS storedCursor.key is "someKey3"
 PASS event.target.result.key is "someKey3"
 PASS storedCursor.value is "someValue3"
@@ -48,7 +48,7 @@ PASS event.target.result.value is "someValue3"
 event.target.result.continue()
 
 checkCursor()
-PASS storedCursor === event.target.result is true
+PASS storedCursor is event.target.result
 PASS storedCursor.key is "someKey4"
 PASS event.target.result.key is "someKey4"
 PASS storedCursor.value is "someValue4"
index ad78043..371b6c3 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('test')
 objectStore.createIndex('testIndex', 'x')
index 8d88534..c2d8195 100644 (file)
@@ -73,204 +73,204 @@ curreq = store.openCursor()
 cursor = curreq.result
 PASS compare(cursor.key, -Infinity) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, -Number.MAX_VALUE) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, -1) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, -Number.MIN_VALUE) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 0) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, Number.MIN_VALUE) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 1) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, Number.MAX_VALUE) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, Infinity) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, new Date(0)) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, new Date(1000)) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, new Date(1317399931023)) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '\0') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 'a') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 'aa') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 'b') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, 'ba') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '¢') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '水') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '𝄞') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, '�') is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, []) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [-Infinity]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [-Number.MAX_VALUE]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [-1]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [-Number.MIN_VALUE]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [0]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [Number.MIN_VALUE]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [1]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [Number.MAX_VALUE]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [Infinity]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [new Date(0)]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [new Date(1000)]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [new Date(1317399931023)]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['\0']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['a']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['aa']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['b']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['ba']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['¢']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['水']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['𝄞']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, ['�']) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [[]]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [[], []]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [[], [], []]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [[[]]]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
+PASS getreq.result is count++
 cursor = curreq.result
 PASS compare(cursor.key, [[[[]]]]) is true
 getreq = store.get(cursor.key)
-PASS getreq.result === count++ is true
-PASS count === keys.length is true
+PASS getreq.result is count++
+PASS count is keys.length
 
 validate compare function
 PASS compare(undefined, undefined) is true
index 3438849..560504d 100644 (file)
@@ -86,7 +86,7 @@ PASS cursor.primaryKey is 'b'
 cursor = cursorRequest.result
 PASS cursor.key is 0
 PASS cursor.primaryKey is 'c'
-PASS count === keys.length is true
+PASS count is keys.length
 PASS successfullyParsed is true
 
 TEST COMPLETE
index a7e40d0..a0db9ea 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('store', {keyPath: 'id'})
 objectStore.createIndex('nameIndex', 'name')
index b3ddaaf..ffb5636 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('basicStore')
 objectStore.add('myValue1', 'myKey1').onerror = unexpectedErrorCallback
@@ -158,22 +158,26 @@ trans.objectStore('keyPathStore').index('numberIndex').openKeyCursor(keyRange)
 keyCursor()
 PASS event.target.result.key is counter + 100
 PASS event.target.result.primaryKey is counter
-event.target.result.update({id: counter, number: counter + 200})
+Expecting exception from event.target.result.update({id: counter, number: counter + 200})
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
 keyCursor()
 PASS event.target.result.key is counter + 100
 PASS event.target.result.primaryKey is counter
-event.target.result.update({id: counter, number: counter + 200})
+Expecting exception from event.target.result.update({id: counter, number: counter + 200})
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
 keyCursor()
 PASS event.target.result.key is counter + 100
 PASS event.target.result.primaryKey is counter
-event.target.result.update({id: counter, number: counter + 200})
+Expecting exception from event.target.result.update({id: counter, number: counter + 200})
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
 keyCursor()
 PASS event.target.result.key is counter + 100
 PASS event.target.result.primaryKey is counter
-event.target.result.update({id: counter, number: counter + 200})
+Expecting exception from event.target.result.update({id: counter, number: counter + 200})
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
 keyCursor()
 PASS counter is 5
index cd01e7c..edff1d3 100644 (file)
@@ -11,7 +11,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName')
 addData():
@@ -20,7 +20,7 @@ request = transaction.objectStore('storeName').add({x: testDate}, 'key')
 addData():
 transaction = db.transaction(['storeName'], 'readonly')
 request = transaction.objectStore('storeName').get('key')
-PASS event.target.result.x.toString() == testDate.toString() is true
+PASS event.target.result.x.toString() is testDate.toString()
 PASS successfullyParsed is true
 
 TEST COMPLETE
index ca7c4e0..434e375 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 Testing setVersion.
 db.setVersion("version a")
@@ -38,7 +38,7 @@ PASS db.objectStoreNames.contains('test456') is false
 PASS db.objectStoreNames.contains('test123') is true
 db.createObjectStore("test456")
 setVersionTrans = event.target.result
-PASS setVersionTrans !== null is true
+PASS setVersionTrans is non-null.
 PASS db.version is "version b"
 PASS db.objectStoreNames is ['test123']
 PASS db.objectStoreNames.length is 1
index 16a5d09..faaea14 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName', null)
 store.createIndex('indexName', 'x')
@@ -26,33 +26,33 @@ PASS event.target.result is undefined
 indexObject.get('does not exist')
 PASS event.target.result is undefined
 indexObject.openKeyCursor()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.primaryKey is "key"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.primaryKey is "key2"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 indexObject.openCursor()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.value.x is "value"
 PASS event.target.result.value.y is "zzz"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.value.x is "value2"
 PASS event.target.result.value.y is "zzz2"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 indexedDB.open('duplicates-2')
 db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName', null)
 store.createIndex('indexName', 'x')
@@ -68,27 +68,27 @@ PASS event.target.result is undefined
 indexObject.get('does not exist')
 PASS event.target.result is undefined
 indexObject.openKeyCursor()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.primaryKey is "key"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.primaryKey is "key2"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 indexObject.openCursor()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.value.x is "value"
 PASS event.target.result.value.y is "zzz"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.value.x is "value2"
 PASS event.target.result.value.y is "zzz2"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 2adc89d..b2440ed 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 trans.oncomplete = addData
 Deleted all object stores.
 db.createObjectStore('storeName', null)
index f78a60c..b9b8eb7 100644 (file)
@@ -12,7 +12,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 trans.oncomplete = startTest
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
index f097365..f122da4 100644 (file)
@@ -5,10 +5,10 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
 
-PASS typeof indexedDB.open === 'function' is true
-PASS typeof indexedDB.cmp === 'function' is true
-PASS typeof indexedDB.getDatabaseNames === 'function' is true
-PASS typeof indexedDB.deleteDatabase === 'function' is true
+PASS typeof indexedDB.open is "function"
+PASS typeof indexedDB.cmp is "function"
+PASS typeof indexedDB.getDatabaseNames is "function"
+PASS typeof indexedDB.deleteDatabase is "function"
 indexedDB.getDatabaseNames()
 databaseNames = event.target.result
 PASS databaseNames.contains('storage/indexeddb/factory-basics') is false
index cd3c3b6..761801e 100644 (file)
@@ -5,205 +5,205 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
 
-PASS typeof indexedDB.cmp === 'function' is true
+PASS typeof indexedDB.cmp is "function"
 
 compare valid keys
-PASS indexedDB.cmp(-Infinity,-Number.MAX_VALUE) === -1 is true
-PASS indexedDB.cmp(-Number.MAX_VALUE,-Infinity) === 1 is true
-PASS indexedDB.cmp(-Infinity,-Infinity) === 0 is true
-PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) === 0 is true
-PASS indexedDB.cmp(-Number.MAX_VALUE,-1) === -1 is true
-PASS indexedDB.cmp(-1,-Number.MAX_VALUE) === 1 is true
-PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) === 0 is true
-PASS indexedDB.cmp(-1,-1) === 0 is true
-PASS indexedDB.cmp(-1,-Number.MIN_VALUE) === -1 is true
-PASS indexedDB.cmp(-Number.MIN_VALUE,-1) === 1 is true
-PASS indexedDB.cmp(-1,-1) === 0 is true
-PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) === 0 is true
-PASS indexedDB.cmp(-Number.MIN_VALUE,0) === -1 is true
-PASS indexedDB.cmp(0,-Number.MIN_VALUE) === 1 is true
-PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) === 0 is true
-PASS indexedDB.cmp(0,0) === 0 is true
-PASS indexedDB.cmp(0,Number.MIN_VALUE) === -1 is true
-PASS indexedDB.cmp(Number.MIN_VALUE,0) === 1 is true
-PASS indexedDB.cmp(0,0) === 0 is true
-PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) === 0 is true
-PASS indexedDB.cmp(Number.MIN_VALUE,1) === -1 is true
-PASS indexedDB.cmp(1,Number.MIN_VALUE) === 1 is true
-PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) === 0 is true
-PASS indexedDB.cmp(1,1) === 0 is true
-PASS indexedDB.cmp(1,Number.MAX_VALUE) === -1 is true
-PASS indexedDB.cmp(Number.MAX_VALUE,1) === 1 is true
-PASS indexedDB.cmp(1,1) === 0 is true
-PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) === 0 is true
-PASS indexedDB.cmp(Number.MAX_VALUE,Infinity) === -1 is true
-PASS indexedDB.cmp(Infinity,Number.MAX_VALUE) === 1 is true
-PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) === 0 is true
-PASS indexedDB.cmp(Infinity,Infinity) === 0 is true
-PASS indexedDB.cmp(Infinity,new Date(0)) === -1 is true
-PASS indexedDB.cmp(new Date(0),Infinity) === 1 is true
-PASS indexedDB.cmp(Infinity,Infinity) === 0 is true
-PASS indexedDB.cmp(new Date(0),new Date(0)) === 0 is true
-PASS indexedDB.cmp(new Date(0),new Date(1000)) === -1 is true
-PASS indexedDB.cmp(new Date(1000),new Date(0)) === 1 is true
-PASS indexedDB.cmp(new Date(0),new Date(0)) === 0 is true
-PASS indexedDB.cmp(new Date(1000),new Date(1000)) === 0 is true
-PASS indexedDB.cmp(new Date(1000),new Date(1317399931023)) === -1 is true
-PASS indexedDB.cmp(new Date(1317399931023),new Date(1000)) === 1 is true
-PASS indexedDB.cmp(new Date(1000),new Date(1000)) === 0 is true
-PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) === 0 is true
-PASS indexedDB.cmp(new Date(1317399931023),'') === -1 is true
-PASS indexedDB.cmp('',new Date(1317399931023)) === 1 is true
-PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) === 0 is true
-PASS indexedDB.cmp('','') === 0 is true
-PASS indexedDB.cmp('','\0') === -1 is true
-PASS indexedDB.cmp('\0','') === 1 is true
-PASS indexedDB.cmp('','') === 0 is true
-PASS indexedDB.cmp('\0','\0') === 0 is true
-PASS indexedDB.cmp('\0','a') === -1 is true
-PASS indexedDB.cmp('a','\0') === 1 is true
-PASS indexedDB.cmp('\0','\0') === 0 is true
-PASS indexedDB.cmp('a','a') === 0 is true
-PASS indexedDB.cmp('a','aa') === -1 is true
-PASS indexedDB.cmp('aa','a') === 1 is true
-PASS indexedDB.cmp('a','a') === 0 is true
-PASS indexedDB.cmp('aa','aa') === 0 is true
-PASS indexedDB.cmp('aa','b') === -1 is true
-PASS indexedDB.cmp('b','aa') === 1 is true
-PASS indexedDB.cmp('aa','aa') === 0 is true
-PASS indexedDB.cmp('b','b') === 0 is true
-PASS indexedDB.cmp('b','ba') === -1 is true
-PASS indexedDB.cmp('ba','b') === 1 is true
-PASS indexedDB.cmp('b','b') === 0 is true
-PASS indexedDB.cmp('ba','ba') === 0 is true
-PASS indexedDB.cmp('ba','¢') === -1 is true
-PASS indexedDB.cmp('¢','ba') === 1 is true
-PASS indexedDB.cmp('ba','ba') === 0 is true
-PASS indexedDB.cmp('¢','¢') === 0 is true
-PASS indexedDB.cmp('¢','水') === -1 is true
-PASS indexedDB.cmp('水','¢') === 1 is true
-PASS indexedDB.cmp('¢','¢') === 0 is true
-PASS indexedDB.cmp('水','水') === 0 is true
-PASS indexedDB.cmp('水','𝄞') === -1 is true
-PASS indexedDB.cmp('𝄞','水') === 1 is true
-PASS indexedDB.cmp('水','水') === 0 is true
-PASS indexedDB.cmp('𝄞','𝄞') === 0 is true
-PASS indexedDB.cmp('𝄞','�') === -1 is true
-PASS indexedDB.cmp('�','𝄞') === 1 is true
-PASS indexedDB.cmp('𝄞','𝄞') === 0 is true
-PASS indexedDB.cmp('�','�') === 0 is true
-PASS indexedDB.cmp('�',[]) === -1 is true
-PASS indexedDB.cmp([],'�') === 1 is true
-PASS indexedDB.cmp('�','�') === 0 is true
-PASS indexedDB.cmp([],[]) === 0 is true
-PASS indexedDB.cmp([],[-Infinity]) === -1 is true
-PASS indexedDB.cmp([-Infinity],[]) === 1 is true
-PASS indexedDB.cmp([],[]) === 0 is true
-PASS indexedDB.cmp([-Infinity],[-Infinity]) === 0 is true
-PASS indexedDB.cmp([-Infinity],[-Number.MAX_VALUE]) === -1 is true
-PASS indexedDB.cmp([-Number.MAX_VALUE],[-Infinity]) === 1 is true
-PASS indexedDB.cmp([-Infinity],[-Infinity]) === 0 is true
-PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) === 0 is true
-PASS indexedDB.cmp([-Number.MAX_VALUE],[-1]) === -1 is true
-PASS indexedDB.cmp([-1],[-Number.MAX_VALUE]) === 1 is true
-PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) === 0 is true
-PASS indexedDB.cmp([-1],[-1]) === 0 is true
-PASS indexedDB.cmp([-1],[-Number.MIN_VALUE]) === -1 is true
-PASS indexedDB.cmp([-Number.MIN_VALUE],[-1]) === 1 is true
-PASS indexedDB.cmp([-1],[-1]) === 0 is true
-PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) === 0 is true
-PASS indexedDB.cmp([-Number.MIN_VALUE],[0]) === -1 is true
-PASS indexedDB.cmp([0],[-Number.MIN_VALUE]) === 1 is true
-PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) === 0 is true
-PASS indexedDB.cmp([0],[0]) === 0 is true
-PASS indexedDB.cmp([0],[Number.MIN_VALUE]) === -1 is true
-PASS indexedDB.cmp([Number.MIN_VALUE],[0]) === 1 is true
-PASS indexedDB.cmp([0],[0]) === 0 is true
-PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) === 0 is true
-PASS indexedDB.cmp([Number.MIN_VALUE],[1]) === -1 is true
-PASS indexedDB.cmp([1],[Number.MIN_VALUE]) === 1 is true
-PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) === 0 is true
-PASS indexedDB.cmp([1],[1]) === 0 is true
-PASS indexedDB.cmp([1],[Number.MAX_VALUE]) === -1 is true
-PASS indexedDB.cmp([Number.MAX_VALUE],[1]) === 1 is true
-PASS indexedDB.cmp([1],[1]) === 0 is true
-PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) === 0 is true
-PASS indexedDB.cmp([Number.MAX_VALUE],[Infinity]) === -1 is true
-PASS indexedDB.cmp([Infinity],[Number.MAX_VALUE]) === 1 is true
-PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) === 0 is true
-PASS indexedDB.cmp([Infinity],[Infinity]) === 0 is true
-PASS indexedDB.cmp([Infinity],[new Date(0)]) === -1 is true
-PASS indexedDB.cmp([new Date(0)],[Infinity]) === 1 is true
-PASS indexedDB.cmp([Infinity],[Infinity]) === 0 is true
-PASS indexedDB.cmp([new Date(0)],[new Date(0)]) === 0 is true
-PASS indexedDB.cmp([new Date(0)],[new Date(1000)]) === -1 is true
-PASS indexedDB.cmp([new Date(1000)],[new Date(0)]) === 1 is true
-PASS indexedDB.cmp([new Date(0)],[new Date(0)]) === 0 is true
-PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) === 0 is true
-PASS indexedDB.cmp([new Date(1000)],[new Date(1317399931023)]) === -1 is true
-PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1000)]) === 1 is true
-PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) === 0 is true
-PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) === 0 is true
-PASS indexedDB.cmp([new Date(1317399931023)],['']) === -1 is true
-PASS indexedDB.cmp([''],[new Date(1317399931023)]) === 1 is true
-PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) === 0 is true
-PASS indexedDB.cmp([''],['']) === 0 is true
-PASS indexedDB.cmp([''],['\0']) === -1 is true
-PASS indexedDB.cmp(['\0'],['']) === 1 is true
-PASS indexedDB.cmp([''],['']) === 0 is true
-PASS indexedDB.cmp(['\0'],['\0']) === 0 is true
-PASS indexedDB.cmp(['\0'],['a']) === -1 is true
-PASS indexedDB.cmp(['a'],['\0']) === 1 is true
-PASS indexedDB.cmp(['\0'],['\0']) === 0 is true
-PASS indexedDB.cmp(['a'],['a']) === 0 is true
-PASS indexedDB.cmp(['a'],['aa']) === -1 is true
-PASS indexedDB.cmp(['aa'],['a']) === 1 is true
-PASS indexedDB.cmp(['a'],['a']) === 0 is true
-PASS indexedDB.cmp(['aa'],['aa']) === 0 is true
-PASS indexedDB.cmp(['aa'],['b']) === -1 is true
-PASS indexedDB.cmp(['b'],['aa']) === 1 is true
-PASS indexedDB.cmp(['aa'],['aa']) === 0 is true
-PASS indexedDB.cmp(['b'],['b']) === 0 is true
-PASS indexedDB.cmp(['b'],['ba']) === -1 is true
-PASS indexedDB.cmp(['ba'],['b']) === 1 is true
-PASS indexedDB.cmp(['b'],['b']) === 0 is true
-PASS indexedDB.cmp(['ba'],['ba']) === 0 is true
-PASS indexedDB.cmp(['ba'],['¢']) === -1 is true
-PASS indexedDB.cmp(['¢'],['ba']) === 1 is true
-PASS indexedDB.cmp(['ba'],['ba']) === 0 is true
-PASS indexedDB.cmp(['¢'],['¢']) === 0 is true
-PASS indexedDB.cmp(['¢'],['水']) === -1 is true
-PASS indexedDB.cmp(['水'],['¢']) === 1 is true
-PASS indexedDB.cmp(['¢'],['¢']) === 0 is true
-PASS indexedDB.cmp(['水'],['水']) === 0 is true
-PASS indexedDB.cmp(['水'],['𝄞']) === -1 is true
-PASS indexedDB.cmp(['𝄞'],['水']) === 1 is true
-PASS indexedDB.cmp(['水'],['水']) === 0 is true
-PASS indexedDB.cmp(['𝄞'],['𝄞']) === 0 is true
-PASS indexedDB.cmp(['𝄞'],['�']) === -1 is true
-PASS indexedDB.cmp(['�'],['𝄞']) === 1 is true
-PASS indexedDB.cmp(['𝄞'],['𝄞']) === 0 is true
-PASS indexedDB.cmp(['�'],['�']) === 0 is true
-PASS indexedDB.cmp(['�'],[[]]) === -1 is true
-PASS indexedDB.cmp([[]],['�']) === 1 is true
-PASS indexedDB.cmp(['�'],['�']) === 0 is true
-PASS indexedDB.cmp([[]],[[]]) === 0 is true
-PASS indexedDB.cmp([[]],[[], []]) === -1 is true
-PASS indexedDB.cmp([[], []],[[]]) === 1 is true
-PASS indexedDB.cmp([[]],[[]]) === 0 is true
-PASS indexedDB.cmp([[], []],[[], []]) === 0 is true
-PASS indexedDB.cmp([[], []],[[], [], []]) === -1 is true
-PASS indexedDB.cmp([[], [], []],[[], []]) === 1 is true
-PASS indexedDB.cmp([[], []],[[], []]) === 0 is true
-PASS indexedDB.cmp([[], [], []],[[], [], []]) === 0 is true
-PASS indexedDB.cmp([[], [], []],[[[]]]) === -1 is true
-PASS indexedDB.cmp([[[]]],[[], [], []]) === 1 is true
-PASS indexedDB.cmp([[], [], []],[[], [], []]) === 0 is true
-PASS indexedDB.cmp([[[]]],[[[]]]) === 0 is true
-PASS indexedDB.cmp([[[]]],[[[[]]]]) === -1 is true
-PASS indexedDB.cmp([[[[]]]],[[[]]]) === 1 is true
-PASS indexedDB.cmp([[[]]],[[[]]]) === 0 is true
-PASS indexedDB.cmp([[[[]]]],[[[[]]]]) === 0 is true
+PASS indexedDB.cmp(-Infinity,-Number.MAX_VALUE) is -1
+PASS indexedDB.cmp(-Number.MAX_VALUE,-Infinity) is 1
+PASS indexedDB.cmp(-Infinity,-Infinity) is 0
+PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) is 0
+PASS indexedDB.cmp(-Number.MAX_VALUE,-1) is -1
+PASS indexedDB.cmp(-1,-Number.MAX_VALUE) is 1
+PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) is 0
+PASS indexedDB.cmp(-1,-1) is 0
+PASS indexedDB.cmp(-1,-Number.MIN_VALUE) is -1
+PASS indexedDB.cmp(-Number.MIN_VALUE,-1) is 1
+PASS indexedDB.cmp(-1,-1) is 0
+PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) is 0
+PASS indexedDB.cmp(-Number.MIN_VALUE,0) is -1
+PASS indexedDB.cmp(0,-Number.MIN_VALUE) is 1
+PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) is 0
+PASS indexedDB.cmp(0,0) is 0
+PASS indexedDB.cmp(0,Number.MIN_VALUE) is -1
+PASS indexedDB.cmp(Number.MIN_VALUE,0) is 1
+PASS indexedDB.cmp(0,0) is 0
+PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) is 0
+PASS indexedDB.cmp(Number.MIN_VALUE,1) is -1
+PASS indexedDB.cmp(1,Number.MIN_VALUE) is 1
+PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) is 0
+PASS indexedDB.cmp(1,1) is 0
+PASS indexedDB.cmp(1,Number.MAX_VALUE) is -1
+PASS indexedDB.cmp(Number.MAX_VALUE,1) is 1
+PASS indexedDB.cmp(1,1) is 0
+PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) is 0
+PASS indexedDB.cmp(Number.MAX_VALUE,Infinity) is -1
+PASS indexedDB.cmp(Infinity,Number.MAX_VALUE) is 1
+PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) is 0
+PASS indexedDB.cmp(Infinity,Infinity) is 0
+PASS indexedDB.cmp(Infinity,new Date(0)) is -1
+PASS indexedDB.cmp(new Date(0),Infinity) is 1
+PASS indexedDB.cmp(Infinity,Infinity) is 0
+PASS indexedDB.cmp(new Date(0),new Date(0)) is 0
+PASS indexedDB.cmp(new Date(0),new Date(1000)) is -1
+PASS indexedDB.cmp(new Date(1000),new Date(0)) is 1
+PASS indexedDB.cmp(new Date(0),new Date(0)) is 0
+PASS indexedDB.cmp(new Date(1000),new Date(1000)) is 0
+PASS indexedDB.cmp(new Date(1000),new Date(1317399931023)) is -1
+PASS indexedDB.cmp(new Date(1317399931023),new Date(1000)) is 1
+PASS indexedDB.cmp(new Date(1000),new Date(1000)) is 0
+PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) is 0
+PASS indexedDB.cmp(new Date(1317399931023),'') is -1
+PASS indexedDB.cmp('',new Date(1317399931023)) is 1
+PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) is 0
+PASS indexedDB.cmp('','') is 0
+PASS indexedDB.cmp('','\0') is -1
+PASS indexedDB.cmp('\0','') is 1
+PASS indexedDB.cmp('','') is 0
+PASS indexedDB.cmp('\0','\0') is 0
+PASS indexedDB.cmp('\0','a') is -1
+PASS indexedDB.cmp('a','\0') is 1
+PASS indexedDB.cmp('\0','\0') is 0
+PASS indexedDB.cmp('a','a') is 0
+PASS indexedDB.cmp('a','aa') is -1
+PASS indexedDB.cmp('aa','a') is 1
+PASS indexedDB.cmp('a','a') is 0
+PASS indexedDB.cmp('aa','aa') is 0
+PASS indexedDB.cmp('aa','b') is -1
+PASS indexedDB.cmp('b','aa') is 1
+PASS indexedDB.cmp('aa','aa') is 0
+PASS indexedDB.cmp('b','b') is 0
+PASS indexedDB.cmp('b','ba') is -1
+PASS indexedDB.cmp('ba','b') is 1
+PASS indexedDB.cmp('b','b') is 0
+PASS indexedDB.cmp('ba','ba') is 0
+PASS indexedDB.cmp('ba','¢') is -1
+PASS indexedDB.cmp('¢','ba') is 1
+PASS indexedDB.cmp('ba','ba') is 0
+PASS indexedDB.cmp('¢','¢') is 0
+PASS indexedDB.cmp('¢','水') is -1
+PASS indexedDB.cmp('水','¢') is 1
+PASS indexedDB.cmp('¢','¢') is 0
+PASS indexedDB.cmp('水','水') is 0
+PASS indexedDB.cmp('水','𝄞') is -1
+PASS indexedDB.cmp('𝄞','水') is 1
+PASS indexedDB.cmp('水','水') is 0
+PASS indexedDB.cmp('𝄞','𝄞') is 0
+PASS indexedDB.cmp('𝄞','�') is -1
+PASS indexedDB.cmp('�','𝄞') is 1
+PASS indexedDB.cmp('𝄞','𝄞') is 0
+PASS indexedDB.cmp('�','�') is 0
+PASS indexedDB.cmp('�',[]) is -1
+PASS indexedDB.cmp([],'�') is 1
+PASS indexedDB.cmp('�','�') is 0
+PASS indexedDB.cmp([],[]) is 0
+PASS indexedDB.cmp([],[-Infinity]) is -1
+PASS indexedDB.cmp([-Infinity],[]) is 1
+PASS indexedDB.cmp([],[]) is 0
+PASS indexedDB.cmp([-Infinity],[-Infinity]) is 0
+PASS indexedDB.cmp([-Infinity],[-Number.MAX_VALUE]) is -1
+PASS indexedDB.cmp([-Number.MAX_VALUE],[-Infinity]) is 1
+PASS indexedDB.cmp([-Infinity],[-Infinity]) is 0
+PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) is 0
+PASS indexedDB.cmp([-Number.MAX_VALUE],[-1]) is -1
+PASS indexedDB.cmp([-1],[-Number.MAX_VALUE]) is 1
+PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) is 0
+PASS indexedDB.cmp([-1],[-1]) is 0
+PASS indexedDB.cmp([-1],[-Number.MIN_VALUE]) is -1
+PASS indexedDB.cmp([-Number.MIN_VALUE],[-1]) is 1
+PASS indexedDB.cmp([-1],[-1]) is 0
+PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) is 0
+PASS indexedDB.cmp([-Number.MIN_VALUE],[0]) is -1
+PASS indexedDB.cmp([0],[-Number.MIN_VALUE]) is 1
+PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) is 0
+PASS indexedDB.cmp([0],[0]) is 0
+PASS indexedDB.cmp([0],[Number.MIN_VALUE]) is -1
+PASS indexedDB.cmp([Number.MIN_VALUE],[0]) is 1
+PASS indexedDB.cmp([0],[0]) is 0
+PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) is 0
+PASS indexedDB.cmp([Number.MIN_VALUE],[1]) is -1
+PASS indexedDB.cmp([1],[Number.MIN_VALUE]) is 1
+PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) is 0
+PASS indexedDB.cmp([1],[1]) is 0
+PASS indexedDB.cmp([1],[Number.MAX_VALUE]) is -1
+PASS indexedDB.cmp([Number.MAX_VALUE],[1]) is 1
+PASS indexedDB.cmp([1],[1]) is 0
+PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) is 0
+PASS indexedDB.cmp([Number.MAX_VALUE],[Infinity]) is -1
+PASS indexedDB.cmp([Infinity],[Number.MAX_VALUE]) is 1
+PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) is 0
+PASS indexedDB.cmp([Infinity],[Infinity]) is 0
+PASS indexedDB.cmp([Infinity],[new Date(0)]) is -1
+PASS indexedDB.cmp([new Date(0)],[Infinity]) is 1
+PASS indexedDB.cmp([Infinity],[Infinity]) is 0
+PASS indexedDB.cmp([new Date(0)],[new Date(0)]) is 0
+PASS indexedDB.cmp([new Date(0)],[new Date(1000)]) is -1
+PASS indexedDB.cmp([new Date(1000)],[new Date(0)]) is 1
+PASS indexedDB.cmp([new Date(0)],[new Date(0)]) is 0
+PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) is 0
+PASS indexedDB.cmp([new Date(1000)],[new Date(1317399931023)]) is -1
+PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1000)]) is 1
+PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) is 0
+PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) is 0
+PASS indexedDB.cmp([new Date(1317399931023)],['']) is -1
+PASS indexedDB.cmp([''],[new Date(1317399931023)]) is 1
+PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) is 0
+PASS indexedDB.cmp([''],['']) is 0
+PASS indexedDB.cmp([''],['\0']) is -1
+PASS indexedDB.cmp(['\0'],['']) is 1
+PASS indexedDB.cmp([''],['']) is 0
+PASS indexedDB.cmp(['\0'],['\0']) is 0
+PASS indexedDB.cmp(['\0'],['a']) is -1
+PASS indexedDB.cmp(['a'],['\0']) is 1
+PASS indexedDB.cmp(['\0'],['\0']) is 0
+PASS indexedDB.cmp(['a'],['a']) is 0
+PASS indexedDB.cmp(['a'],['aa']) is -1
+PASS indexedDB.cmp(['aa'],['a']) is 1
+PASS indexedDB.cmp(['a'],['a']) is 0
+PASS indexedDB.cmp(['aa'],['aa']) is 0
+PASS indexedDB.cmp(['aa'],['b']) is -1
+PASS indexedDB.cmp(['b'],['aa']) is 1
+PASS indexedDB.cmp(['aa'],['aa']) is 0
+PASS indexedDB.cmp(['b'],['b']) is 0
+PASS indexedDB.cmp(['b'],['ba']) is -1
+PASS indexedDB.cmp(['ba'],['b']) is 1
+PASS indexedDB.cmp(['b'],['b']) is 0
+PASS indexedDB.cmp(['ba'],['ba']) is 0
+PASS indexedDB.cmp(['ba'],['¢']) is -1
+PASS indexedDB.cmp(['¢'],['ba']) is 1
+PASS indexedDB.cmp(['ba'],['ba']) is 0
+PASS indexedDB.cmp(['¢'],['¢']) is 0
+PASS indexedDB.cmp(['¢'],['水']) is -1
+PASS indexedDB.cmp(['水'],['¢']) is 1
+PASS indexedDB.cmp(['¢'],['¢']) is 0
+PASS indexedDB.cmp(['水'],['水']) is 0
+PASS indexedDB.cmp(['水'],['𝄞']) is -1
+PASS indexedDB.cmp(['𝄞'],['水']) is 1
+PASS indexedDB.cmp(['水'],['水']) is 0
+PASS indexedDB.cmp(['𝄞'],['𝄞']) is 0
+PASS indexedDB.cmp(['𝄞'],['�']) is -1
+PASS indexedDB.cmp(['�'],['𝄞']) is 1
+PASS indexedDB.cmp(['𝄞'],['𝄞']) is 0
+PASS indexedDB.cmp(['�'],['�']) is 0
+PASS indexedDB.cmp(['�'],[[]]) is -1
+PASS indexedDB.cmp([[]],['�']) is 1
+PASS indexedDB.cmp(['�'],['�']) is 0
+PASS indexedDB.cmp([[]],[[]]) is 0
+PASS indexedDB.cmp([[]],[[], []]) is -1
+PASS indexedDB.cmp([[], []],[[]]) is 1
+PASS indexedDB.cmp([[]],[[]]) is 0
+PASS indexedDB.cmp([[], []],[[], []]) is 0
+PASS indexedDB.cmp([[], []],[[], [], []]) is -1
+PASS indexedDB.cmp([[], [], []],[[], []]) is 1
+PASS indexedDB.cmp([[], []],[[], []]) is 0
+PASS indexedDB.cmp([[], [], []],[[], [], []]) is 0
+PASS indexedDB.cmp([[], [], []],[[[]]]) is -1
+PASS indexedDB.cmp([[[]]],[[], [], []]) is 1
+PASS indexedDB.cmp([[], [], []],[[], [], []]) is 0
+PASS indexedDB.cmp([[[]]],[[[]]]) is 0
+PASS indexedDB.cmp([[[]]],[[[[]]]]) is -1
+PASS indexedDB.cmp([[[[]]]],[[[]]]) is 1
+PASS indexedDB.cmp([[[]]],[[[]]]) is 0
+PASS indexedDB.cmp([[[[]]]],[[[[]]]]) is 0
 
 compare invalid keys
 Expecting exception from indexedDB.cmp(void 0, true)
@@ -406,7 +406,7 @@ PASS Exception was thrown.
 PASS code is IDBDatabaseException.DATA_ERR
 
 compare identical keys
-PASS indexedDB.cmp(0, -0) === 0 is true
+PASS indexedDB.cmp(0, -0) is 0
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 64e0db1..27e7c84 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('database-to-delete')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = db.createObjectStore('storeName', null)
 store.createIndex('indexName', '')
 PASS store.indexNames.contains('indexName') is true
index fe254a4..3dc1fe0 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('cursor-continue')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('someObjectStore')
 objectStore.createIndex('someIndex', 'x')
index 6111996..a693937 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName', null)
 store.createIndex('indexName', 'x')
@@ -66,41 +66,45 @@ indexObject4.getKey('value2')
 PASS event.target.result is "key2"
 indexObject.openKeyCursor()
 PASS event.target.source is indexObject
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.primaryKey is "key"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.primaryKey is "key2"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value3"
 PASS event.target.result.primaryKey is "key3"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 indexObject.openCursor()
 PASS event.target.source is indexObject
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value"
 PASS event.target.result.value.x is "value"
 PASS event.target.result.value.y is "zzz"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value2"
 PASS event.target.result.value.x is "value2"
 PASS event.target.result.value.y is "zzz2"
 event.target.result.continue()
-PASS event.target.result === null is false
+PASS event.target.result is non-null.
 PASS event.target.result.key is "value3"
 PASS event.target.result.value.x is "value3"
 PASS event.target.result.value.y is "456"
 event.target.result.continue()
-PASS event.target.result === null is true
+PASS event.target.result is null
 Passing an invalid key into indexObject.get({}).
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from indexObject.get({})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into indexObject.getKey({}).
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from indexObject.getKey({})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 05401a4..7643ae5 100644 (file)
@@ -11,7 +11,7 @@ Starting worker: resources/index-basics.js
 [Worker] db.setVersion('new version')
 [Worker] setVersionSuccess():
 [Worker] trans = event.target.result
-PASS [Worker] trans !== null is true
+PASS [Worker] trans is non-null.
 [Worker] Deleted all object stores.
 [Worker] db.createObjectStore('storeName', null)
 [Worker] store.createIndex('indexName', 'x')
@@ -67,41 +67,45 @@ PASS [Worker] event.target.result is undefined
 PASS [Worker] event.target.result is "key2"
 [Worker] indexObject.openKeyCursor()
 PASS [Worker] event.target.source is indexObject
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value"
 PASS [Worker] event.target.result.primaryKey is "key"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value2"
 PASS [Worker] event.target.result.primaryKey is "key2"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value3"
 PASS [Worker] event.target.result.primaryKey is "key3"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is true
+PASS [Worker] event.target.result is null
 [Worker] indexObject.openCursor()
 PASS [Worker] event.target.source is indexObject
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value"
 PASS [Worker] event.target.result.value.x is "value"
 PASS [Worker] event.target.result.value.y is "zzz"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value2"
 PASS [Worker] event.target.result.value.x is "value2"
 PASS [Worker] event.target.result.value.y is "zzz2"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is false
+PASS [Worker] event.target.result is non-null.
 PASS [Worker] event.target.result.key is "value3"
 PASS [Worker] event.target.result.value.x is "value3"
 PASS [Worker] event.target.result.value.y is "456"
 [Worker] event.target.result.continue()
-PASS [Worker] event.target.result === null is true
+PASS [Worker] event.target.result is null
 [Worker] Passing an invalid key into indexObject.get({}).
-PASS [Worker] Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+[Worker] Expecting exception from indexObject.get({})
+PASS [Worker] Exception was thrown.
+PASS [Worker] code is IDBDatabaseException.DATA_ERR
 [Worker] Passing an invalid key into indexObject.getKey({}).
-PASS [Worker] Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+[Worker] Expecting exception from indexObject.getKey({})
+PASS [Worker] Exception was thrown.
+PASS [Worker] code is IDBDatabaseException.DATA_ERR
 PASS successfullyParsed is true
 
 TEST COMPLETE
index b0aca8c..6e2707d 100644 (file)
@@ -11,7 +11,7 @@ db.setVersion('new version')
 
 preparing database
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
 store.createIndex('indexName', '')
@@ -20,75 +20,75 @@ adding 0 ... 99
 
 verifying count without range
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 index = store.index('indexName')
-PASS index != null is true
+PASS index is non-null.
 request = index.count()
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 verifying count with range
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 index = trans.objectStore('storeName').index('indexName')
-PASS index != null is true
+PASS index is non-null.
 
 test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":false,"expected":100}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":false,"expected":99}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 99
 
 test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":true,"expected":99}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 99
 
 test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":true,"expected":98}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 98
 
 test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":10,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":90}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 90
 
 test = {"lower":0,"lowerOpen":false,"upper":0,"upperOpen":false,"expected":1}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 1
 
 test = {"lower":500,"lowerOpen":false,"upper":500,"upperOpen":false,"expected":0}
 request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 0
 
 verifying count with key
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 index = trans.objectStore('storeName').index('indexName')
-PASS index != null is true
+PASS index is non-null.
 Expecting exception from index.count(NaN)
 PASS Exception was thrown.
 PASS code is IDBDatabaseException.DATA_ERR
@@ -101,17 +101,17 @@ PASS code is IDBDatabaseException.DATA_ERR
 
 test = {"key":0,"expected":1}
 request = index.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 1
 
 test = {"key":100,"expected":0}
 request = index.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 0
 
 test = {"key":null,"expected":100}
 request = index.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 PASS successfullyParsed is true
 
index 2e88702..7bf8c00 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('index-cursor')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('someObjectStore')
 objectStore.createIndex('someIndex', 'x')
index 7810009..3b8b07b 100644 (file)
@@ -11,7 +11,7 @@ db.setVersion('1')
 
 Creating empty stores and indexes
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 store = db.createObjectStore('store')
 store.createIndex('index', 'x', {multiEntry: true})
@@ -30,37 +30,37 @@ Verifying index: index
 transaction = db.transaction(['store'], 'readonly')
 transaction.objectStore('store').index('index').openCursor()
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 1
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 2
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 3
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 4
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 5
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 6
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS expected.length === 0 is true
+PASS expected.length is 0
 
 Verifying unique constraint on multiEntry index
 transaction = db.transaction(['store-unique'], 'readwrite')
@@ -77,7 +77,7 @@ Transaction aborted as expected
 Create an index on a populated store
 db.setVersion('2')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = trans.objectStore('store')
 store.createIndex('index-new', 'x', {multiEntry: true})
 
@@ -85,37 +85,37 @@ Verifying index: index-new
 transaction = db.transaction(['store'], 'readonly')
 transaction.objectStore('store').index('index-new').openCursor()
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 1
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 2
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 3
 PASS cursor.primaryKey is "foo"
 PASS cursor.value.y is "a"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 4
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 5
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS ex != null is true
+PASS ex is non-null.
 PASS cursor.key is 6
 PASS cursor.primaryKey is "bar"
 PASS cursor.value.y is "b"
 cursor = event.target.result
-PASS expected.length === 0 is true
+PASS expected.length is 0
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 061e53a..85f10e8 100644 (file)
@@ -41,7 +41,7 @@ PASS index2.unique is true
 
 setVersion2Abort():
 PASS db.objectStoreNames.length is 1
-PASS db.objectStoreNames[0] is 'store1'
+PASS db.objectStoreNames[0] is "store1"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 109f093..d33afa5 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 deleteExisting():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('store')
 store.createIndex('index', 'x', {unique: true})
index 6ac8979..9b094f4 100644 (file)
@@ -5,10 +5,6 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
 
-IDBTransaction = self.IDBTransaction || self.IDBTransaction;
-PASS IDBTransaction == null is false
-IDBDatabaseException = self.IDBDatabaseException || self.IDBDatabaseException;
-PASS IDBDatabaseException == null is false
 indexedDB.open(name)
 db = openreq.result
 request = db.setVersion('1')
index 347106a..9c1c7f2 100644 (file)
@@ -210,17 +210,29 @@ PASS keyRange.upper is 'abf'
 PASS keyRange.lowerOpen is true
 PASS keyRange.upperOpen is true
 Passing an invalid key into only({})
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.only({})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into upperBound({})
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.upperBound({})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into lowerBound({})
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.lowerBound({})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into bound(null, {})
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.bound(null, {})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into bound({},null)
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.bound({}, null)
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Passing an invalid key into bound({}, {})
-PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
+Expecting exception from IDBKeyRange.bound({}, {})
+PASS Exception was thrown.
+PASS code is IDBDatabaseException.DATA_ERR
 Lower key greater than higher key, bound(4, 3)
 Expecting exception from IDBKeyRange.bound(4, 3)
 PASS Exception was thrown.
index 448c4fb..580b2d9 100644 (file)
@@ -24,37 +24,37 @@ store.createIndex('index', 'value')
 
 populating store...
 trans = db.transaction('store', IDBTransaction.READ_WRITE)
-PASS trans.mode is 'readwrite'
+PASS trans.mode is "readwrite"
 store = trans.objectStore('store');
 store.put({value: 111}, 1)
 store.put({value: 222}, 2)
 trans = db.transaction('store', IDBTransaction.READ_ONLY)
-PASS trans.mode is 'readonly'
+PASS trans.mode is "readonly"
 request = store.openCursor(null, IDBCursor.NEXT)
-PASS cursor.direction is 'next'
+PASS cursor.direction is "next"
 cursor.continue();
-PASS cursor.direction is 'next'
+PASS cursor.direction is "next"
 cursor.continue();
 trans = db.transaction('store', IDBTransaction.READ_ONLY)
-PASS trans.mode is 'readonly'
+PASS trans.mode is "readonly"
 request = store.openCursor(null, IDBCursor.NEXT_NO_DUPLICATE)
-PASS cursor.direction is 'nextunique'
+PASS cursor.direction is "nextunique"
 cursor.continue();
-PASS cursor.direction is 'nextunique'
+PASS cursor.direction is "nextunique"
 cursor.continue();
 trans = db.transaction('store', IDBTransaction.READ_ONLY)
-PASS trans.mode is 'readonly'
+PASS trans.mode is "readonly"
 request = store.openCursor(null, IDBCursor.PREV)
-PASS cursor.direction is 'prev'
+PASS cursor.direction is "prev"
 cursor.continue();
-PASS cursor.direction is 'prev'
+PASS cursor.direction is "prev"
 cursor.continue();
 trans = db.transaction('store', IDBTransaction.READ_ONLY)
-PASS trans.mode is 'readonly'
+PASS trans.mode is "readonly"
 request = store.openCursor(null, IDBCursor.NEXT)
-PASS cursor.direction is 'next'
+PASS cursor.direction is "next"
 cursor.continue();
-PASS cursor.direction is 'next'
+PASS cursor.direction is "next"
 cursor.continue();
 PASS successfullyParsed is true
 
index 3a4e75e..0e0cd7c 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('1')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('store')
 objectStore.add(1, 1).onerror = unexpectedErrorCallback
index 911142a..0e22f3b 100644 (file)
@@ -11,7 +11,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 createObjectStore():
 store = db.createObjectStore('StoreWithKeyPath', {keyPath: 'id', autoIncrement: true})
@@ -20,7 +20,7 @@ db.createObjectStore('PlainOldStore', {autoIncrement: false})
 db.createObjectStore('StoreWithLongKeyPath', {keyPath: 'a.b.c.id', autoIncrement: true})
 storeNames = db.objectStoreNames
 PASS store.name is "StoreWithKeyPath"
-PASS store.keyPath is 'id'
+PASS store.keyPath is "id"
 PASS storeNames.contains('StoreWithKeyPath') is true
 PASS storeNames.contains('StoreWithAutoIncrement') is true
 PASS storeNames.contains('PlainOldStore') is true
@@ -76,13 +76,13 @@ store.openCursor()
 expected = null
 count = 0
 expected = cursor.value.a.b.c.id + 1
-PASS cursor.value.foo is 'bar'
+PASS cursor.value.foo is "bar"
 PASS cursor.value.a.b.c.id is expected
 expected = cursor.value.a.b.c.id + 1
-PASS cursor.value.foo is 'bar'
+PASS cursor.value.foo is "bar"
 PASS cursor.value.a.b.c.id is expected
 expected = cursor.value.a.b.c.id + 1
-PASS cursor.value.foo is 'bar'
+PASS cursor.value.foo is "bar"
 PASS cursor.value.a.b.c.id is expected
 expected = cursor.value.a.b.c.id + 1
 PASS count is 4
index 07dff4c..f04f8c7 100644 (file)
@@ -11,7 +11,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 createObjectStore():
 store = db.createObjectStore('storeName', null)
@@ -49,23 +49,23 @@ PASS storeNames.length is 1
 PASS db.createObjectStore('storeWithKeyPath', {keyPath: 'path'}).keyPath is "path"
 PASS db.createObjectStore('storeWithKeyGenerator', {autoIncrement: true}).autoIncrement is true
 Ask for an index that doesn't exist:
-index = store.index('asdf')
-PASS Exception thrown.
+Expecting exception from store.index('asdf')
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_FOUND_ERR
 createIndex():
 index = store.createIndex('indexName', 'x', {unique: true})
-PASS index !== null is true
+PASS index is non-null.
 PASS store.indexNames.contains('indexName') is true
 index = store.index('indexName')
-PASS index !== null is true
+PASS index is non-null.
 Ask for an index that doesn't exist:
-index = store.index('asdf')
-PASS Exception thrown.
+Expecting exception from store.index('asdf')
+PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_FOUND_ERR
 db.setVersion("version fail")
 PASS db.version is "version fail"
 setVersionTrans = event.target.result
-PASS setVersionTrans !== null is true
+PASS setVersionTrans is non-null.
 store = setVersionTrans.objectStore('storeName')
 index = store.createIndex('indexFail', 'x')
 PASS db.version is "new version"
@@ -85,9 +85,9 @@ store = transaction.objectStore('storeName')
 Try to insert data with a Date key:
 store.add({x: 'foo'}, testDate)
 Try to insert a value not handled by structured clone:
-store.add({x: 'bar', y: self}, 'bar')
-PASS Exception thrown
-PASS code is 25
+Expecting exception from store.add({x: 'bar', y: self}, 'bar')
+PASS Exception was thrown.
+PASS code is DOMException.DATA_CLONE_ERR
 Try to insert data where key path yields a Date key:
 store.add({x: testDateB, y: 'value'}, 'key')
 addSuccess():
index ac5a2ec..edc1264 100644 (file)
@@ -12,7 +12,7 @@ Starting worker: resources/objectstore-basics.js
 [Worker] db.setVersion('new version')
 [Worker] setVersionSuccess():
 [Worker] trans = event.target.result
-PASS [Worker] trans !== null is true
+PASS [Worker] trans is non-null.
 [Worker] Deleted all object stores.
 [Worker] createObjectStore():
 [Worker] store = db.createObjectStore('storeName', null)
@@ -50,23 +50,23 @@ PASS [Worker] storeNames.length is 1
 PASS [Worker] db.createObjectStore('storeWithKeyPath', {keyPath: 'path'}).keyPath is "path"
 PASS [Worker] db.createObjectStore('storeWithKeyGenerator', {autoIncrement: true}).autoIncrement is true
 [Worker] Ask for an index that doesn't exist:
-[Worker] index = store.index('asdf')
-PASS [Worker] Exception thrown.
+[Worker] Expecting exception from store.index('asdf')
+PASS [Worker] Exception was thrown.
 PASS [Worker] code is IDBDatabaseException.NOT_FOUND_ERR
 [Worker] createIndex():
 [Worker] index = store.createIndex('indexName', 'x', {unique: true})
-PASS [Worker] index !== null is true
+PASS [Worker] index is non-null.
 PASS [Worker] store.indexNames.contains('indexName') is true
 [Worker] index = store.index('indexName')
-PASS [Worker] index !== null is true
+PASS [Worker] index is non-null.
 [Worker] Ask for an index that doesn't exist:
-[Worker] index = store.index('asdf')
-PASS [Worker] Exception thrown.
+[Worker] Expecting exception from store.index('asdf')
+PASS [Worker] Exception was thrown.
 PASS [Worker] code is IDBDatabaseException.NOT_FOUND_ERR
 [Worker] db.setVersion("version fail")
 PASS [Worker] db.version is "version fail"
 [Worker] setVersionTrans = event.target.result
-PASS [Worker] setVersionTrans !== null is true
+PASS [Worker] setVersionTrans is non-null.
 [Worker] store = setVersionTrans.objectStore('storeName')
 [Worker] index = store.createIndex('indexFail', 'x')
 PASS [Worker] db.version is "new version"
@@ -86,9 +86,9 @@ PASS [Worker] store.indexNames.item(100) is null
 [Worker] Try to insert data with a Date key:
 [Worker] store.add({x: 'foo'}, testDate)
 [Worker] Try to insert a value not handled by structured clone:
-[Worker] store.add({x: 'bar', y: self}, 'bar')
-PASS [Worker] Exception thrown
-PASS [Worker] code is 25
+[Worker] Expecting exception from store.add({x: 'bar', y: self}, 'bar')
+PASS [Worker] Exception was thrown.
+PASS [Worker] code is DOMException.DATA_CLONE_ERR
 [Worker] Try to insert data where key path yields a Date key:
 [Worker] store.add({x: testDateB, y: 'value'}, 'key')
 [Worker] addSuccess():
index 1e33704..6335ecc 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('objectstore-clear')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
 store.createIndex('indexName', '')
index 1b5f511..b3c0271 100644 (file)
@@ -11,76 +11,76 @@ db.setVersion('new version')
 
 preparing database
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
 adding 0 ... 99
 
 verifying count without range
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 request = store.count()
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 verifying count with range
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 
 test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":false,"expected":100}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":false,"expected":99}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 99
 
 test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":true,"expected":99}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 99
 
 test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":true,"expected":98}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 98
 
 test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 
 test = {"lower":10,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":90}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 90
 
 test = {"lower":0,"lowerOpen":false,"upper":0,"upperOpen":false,"expected":1}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 1
 
 test = {"lower":500,"lowerOpen":false,"upper":500,"upperOpen":false,"expected":0}
 request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 0
 
 verifying count with key
 trans = db.transaction('storeName', 'readonly')
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('storeName')
-PASS store != null is true
+PASS store is non-null.
 Expecting exception from store.count(NaN)
 PASS Exception was thrown.
 PASS code is IDBDatabaseException.DATA_ERR
@@ -93,17 +93,17 @@ PASS code is IDBDatabaseException.DATA_ERR
 
 test = {"key":0,"expected":1}
 request = store.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 1
 
 test = {"key":100,"expected":0}
 request = store.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 0
 
 test = {"key":null,"expected":100}
 request = store.count(test.key)
-PASS typeof request.result == 'number' is true
+PASS typeof request.result is "number"
 PASS request.result is 100
 PASS successfullyParsed is true
 
index 875db62..8b3ea10 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('objectstore-cursor')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('someObjectStore')
 objectStore.add('', testData[nextToAdd])
index 082f3b3..16144d2 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('objectstore-removeobjectstore')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
 store.createIndex('indexName', '')
@@ -21,7 +21,7 @@ store.get('key')
 PASS event.target.result is "value"
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 db.deleteObjectStore('storeName')
 db.createObjectStore('storeName', null)
 db.transaction(['storeName'])
index 57fec82..cc88c1b 100644 (file)
@@ -10,16 +10,16 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 objectStore = db.createObjectStore('test')
 objectStore.add('myValue', 'myKey')
 Opening cursor
 event.target.source.openCursor(keyRange)
 Cursor opened successfully.
-PASS cursor.direction is 'next'
-PASS cursor.key is 'myKey'
-PASS cursor.value is 'myValue'
+PASS cursor.direction is "next"
+PASS cursor.key is "myKey"
+PASS cursor.value is "myValue"
 
 Passing an invalid key into .continue({}).
 Expecting exception from event.target.result.continue({})
@@ -33,9 +33,9 @@ PASS cursor is null
 Opening cursor
 event.target.source.openCursor("myKey")
 Cursor opened successfully.
-PASS cursor.direction is 'next'
-PASS cursor.key is 'myKey'
-PASS cursor.value is 'myValue'
+PASS cursor.direction is "next"
+PASS cursor.key is "myKey"
+PASS cursor.value is "myValue"
 
 Passing an invalid key into .continue({}).
 Expecting exception from cursor.continue({})
index f6104e1..5e902ac 100644 (file)
@@ -33,7 +33,7 @@ testObjectStore()
 trans = db.transaction(objectStoreName, 'readwrite')
 objectStore = trans.objectStore(objectStoreName)
 request = objectStore.openCursor('237-23-7739')
-PASS cursor.key is '237-23-7739'
+PASS cursor.key is "237-23-7739"
 PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[7].value)
 PASS cursor.primaryKey is cursor.key
 cursor.continue()
@@ -44,15 +44,15 @@ index = objectStore.index('weight')
 request = index.openCursor(180)
 PASS cursor.key is 180
 PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[2].value)
-PASS cursor.primaryKey is '237-23-7734'
+PASS cursor.primaryKey is "237-23-7734"
 cursor.continue()
 PASS cursor.key is 180
 PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[6].value)
-PASS cursor.primaryKey is '237-23-7738'
+PASS cursor.primaryKey is "237-23-7738"
 cursor.continue()
 PASS cursor.key is 180
 PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[10].value)
-PASS cursor.primaryKey is '237-23-7742'
+PASS cursor.primaryKey is "237-23-7742"
 cursor.continue()
 PASS cursor is null
 trans = db.transaction(objectStoreName, 'readwrite')
@@ -60,13 +60,13 @@ objectStore = trans.objectStore(objectStoreName)
 index = objectStore.index('weight')
 request = index.openKeyCursor(180)
 PASS cursor.key is 180
-PASS cursor.primaryKey is '237-23-7734'
+PASS cursor.primaryKey is "237-23-7734"
 cursor.continue()
 PASS cursor.key is 180
-PASS cursor.primaryKey is '237-23-7738'
+PASS cursor.primaryKey is "237-23-7738"
 cursor.continue()
 PASS cursor.key is 180
-PASS cursor.primaryKey is '237-23-7742'
+PASS cursor.primaryKey is "237-23-7742"
 cursor.continue()
 PASS cursor is null
 PASS successfullyParsed is true
index c301392..d70b8d2 100644 (file)
@@ -11,7 +11,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 objectStore = db.createObjectStore('store', {keyPath: 'id'})
 
 resetObjectStore():
index 8ab2d1a..9da55be 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName')
 store.createIndex('indexName', 'x')
index 8fb6137..9e8cb93 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 trans.oncomplete = startTest
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
index 92318d7..6d7bdb9 100644 (file)
@@ -20,7 +20,7 @@ function test()
     shouldBeTrue("'transaction' in request");
     shouldBeNull("request.transaction");
     shouldBeTrue("'readyState' in request");
-    shouldBe("request.readyState", "'pending'");
+    shouldBeEqualToString("request.readyState", "pending");
     shouldBeTrue("'onsuccess' in request");
     shouldBeNull("request.onsuccess");
     shouldBeTrue("'onerror' in request");
@@ -43,7 +43,7 @@ function openCallback(evt)
     shouldBeTrue("'transaction' in event.target");
     shouldBeNull("event.target.transaction");
     shouldBeTrue("'readyState' in request");
-    shouldBe("event.target.readyState", "'done'");
+    shouldBeEqualToString("event.target.readyState", "done");
     shouldBeTrue("'onsuccess' in event.target");
     shouldBeTrue("'onerror' in event.target");
 
index 6312039..7039bc0 100644 (file)
@@ -38,7 +38,7 @@ function cleanDatabase()
 function setVersionComplete()
 {
     trans = evalAndLog("trans = db.transaction(['a', 'b'], 'readwrite')");
-    shouldBe("trans.mode", "'readwrite'");
+    shouldBeEqualToString("trans.mode", "readwrite");
 
     req = evalAndLog("trans.objectStore('a').put({'a': 0})");
     req.onsuccess = putB;
index 7108da6..35d7c09 100644 (file)
@@ -29,7 +29,7 @@ function createAndPopulateObjectStore()
     deleteAllObjectStores(db);
 
     objectStore = evalAndLog("db.createObjectStore(null);");
-    shouldBe("objectStore.name", "'null'");
+    shouldBeEqualToString("objectStore.name", "null");
     finishJSTest();
 }
 
index ff4d76a..74ddbc4 100644 (file)
@@ -27,7 +27,7 @@ function openSuccess()
 function setVersionSuccess()
 {
     trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openCursor;
 
index 2b498f3..adfe8c7 100644 (file)
@@ -36,7 +36,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index 9c3b766..1ff167f 100644 (file)
@@ -54,7 +54,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index e556a2f..425ff77 100644 (file)
@@ -28,7 +28,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openCursor;
 
index aa9cc60..5f24882 100644 (file)
@@ -28,7 +28,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openBasicCursor;
 
@@ -69,7 +69,7 @@ function checkCursor()
     if (storedCursor == null)
       storedCursor = evalAndLog("storedCursor = event.target.result");
 
-    shouldBeTrue("storedCursor === event.target.result");
+    shouldBe("storedCursor", "event.target.result");
     shouldBeEqualToString("storedCursor.key", "someKey" + counter);
     shouldBeEqualToString("event.target.result.key", "someKey" + counter);
     shouldBeEqualToString("storedCursor.value", "someValue" + counter);
index 1d9c3b8..d1ae969 100644 (file)
@@ -28,7 +28,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openCursor;
 
index 8a92932..0299371 100644 (file)
@@ -163,11 +163,11 @@ function checkStore()
             evalAndLog("getreq = store.get(cursor.key)");
             getreq.onerror = unexpectedErrorCallback;
             getreq.onsuccess = function() {
-                shouldBeTrue("getreq.result === count++");
+                shouldBe("getreq.result", "count++");
                 cursor.continue();
             };
         } else {
-            shouldBeTrue("count === keys.length");
+            shouldBe("count", "keys.length");
             finishUp();
         }
     };
index 306975c..738b317 100644 (file)
@@ -89,7 +89,7 @@ function checkStore()
             shouldBe("cursor.primaryKey", self.keys[count++]);
             cursor.continue();
         } else {
-            shouldBeTrue("count === keys.length");
+            shouldBe("count", "keys.length");
             finishJSTest();
         }
     };
index 5da0725..6360074 100644 (file)
@@ -33,7 +33,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = basicCursorTest;
 
index d718e30..37d3ac6 100644 (file)
@@ -28,7 +28,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openBasicCursor;
 
@@ -40,13 +40,13 @@ function setVersionSuccess()
     evalAndLog("objectStore.add('myValue3', 'myKey3').onerror = unexpectedErrorCallback");
     evalAndLog("objectStore.add('myValue4', 'myKey4').onerror = unexpectedErrorCallback");
 
-    var objectStore = evalAndLog("objectStore = db.createObjectStore('autoIncrementStore', {autoIncrement: true})");
+    objectStore = evalAndLog("objectStore = db.createObjectStore('autoIncrementStore', {autoIncrement: true})");
     evalAndLog("objectStore.add('foo1').onerror = unexpectedErrorCallback");
     evalAndLog("objectStore.add('foo2').onerror = unexpectedErrorCallback");
     evalAndLog("objectStore.add('foo3').onerror = unexpectedErrorCallback");
     evalAndLog("objectStore.add('foo4').onerror = unexpectedErrorCallback");
 
-    var objectStore = evalAndLog("objectStore = db.createObjectStore('keyPathStore', {keyPath: 'id'})");
+    objectStore = evalAndLog("objectStore = db.createObjectStore('keyPathStore', {keyPath: 'id'})");
     evalAndLog("objectStore.createIndex('numberIndex', 'number')");
     evalAndLog("objectStore.add({number: 1, id: 1}).onerror = unexpectedErrorCallback");
     evalAndLog("objectStore.add({number: 2, id: 2}).onerror = unexpectedErrorCallback");
@@ -84,7 +84,7 @@ function basicUpdateCursor()
     }
 
     request = evalAndLog("event.target.result.update('myUpdatedValue' + counter++)");
-    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); }
+    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
     request.onerror = unexpectedErrorCallback;
 }
 
@@ -121,7 +121,7 @@ function autoIncrementUpdateCursor()
     }
 
     request = evalAndLog("event.target.result.update('myUpdatedFoo' + counter++)");
-    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); }
+    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
     request.onerror = unexpectedErrorCallback;
 }
 
@@ -160,7 +160,7 @@ function keyPathUpdateCursor()
     evalAndExpectException("event.target.result.update({id: 100 + counter, number: 100 + counter})", "IDBDatabaseException.DATA_ERR");
 
     request = evalAndLog("event.target.result.update({id: counter, number: 100 + counter++})");
-    request.onsuccess = function() { evalAndLog("event.target.source.continue()") };
+    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
     request.onerror = unexpectedErrorCallback;
 }
 
@@ -196,14 +196,8 @@ function keyCursor()
     shouldBe("event.target.result.key", "counter + 100");
     shouldBe("event.target.result.primaryKey", "counter");
 
-    try {
-        debug("event.target.result.update({id: counter, number: counter + 200})");
-        event.target.result.update({id: counter, number: counter + 200});
-        testFailed("Expected exception.");
-    } catch (e) {
-        code = e.code;
-        shouldBe("code", "IDBDatabaseException.NOT_ALLOWED_ERR");
-    }
+    evalAndExpectException("event.target.result.update({id: counter, number: counter + 200})",
+                           "IDBDatabaseException.NOT_ALLOWED_ERR");
 
     counter++;
     event.target.result.continue();
index 179a47b..2a08bf1 100644 (file)
@@ -27,7 +27,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = addData;
 
@@ -58,7 +58,7 @@ function getData()
 
 function doCheck()
 {
-    shouldBeTrue("event.target.result.x.toString() == testDate.toString()");
+    shouldBe("event.target.result.x.toString()", "testDate.toString()");
     finishJSTest();
 }
 
index 2a5a7a7..fe5ab9e 100644 (file)
@@ -27,7 +27,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
@@ -89,7 +89,7 @@ function createAnotherObjectStore()
 
     objectStore = evalAndLog('db.createObjectStore("test456")');
     var setVersionTrans = evalAndLog("setVersionTrans = event.target.result");
-    shouldBeTrue("setVersionTrans !== null");
+    shouldBeNonNull("setVersionTrans");
     setVersionTrans.oncomplete = unexpectedCompleteCallback;
     setVersionTrans.onabort = checkMetadata;
     setVersionTrans.abort();
index d7e7f3a..bd20d15 100644 (file)
@@ -26,7 +26,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = checkQuotaEnforcing;
 
index e133ae8..c437df5 100644 (file)
@@ -29,7 +29,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
@@ -99,7 +99,7 @@ function openKeyCursor()
 
 function cursor1Continue()
 {
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value");
     shouldBeEqualToString("event.target.result.primaryKey", "key");
 
@@ -110,7 +110,7 @@ function cursor1Continue()
 
 function cursor1Continue2()
 {
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value2");
     shouldBeEqualToString("event.target.result.primaryKey", "key2");
 
@@ -121,7 +121,7 @@ function cursor1Continue2()
 
 function openObjectCursor()
 {
-    shouldBeTrue("event.target.result === null");
+    shouldBeNull("event.target.result");
 
     self.request = evalAndLog("indexObject.openCursor()");
     request.onsuccess = cursor2Continue;
@@ -130,7 +130,7 @@ function openObjectCursor()
 
 function cursor2Continue()
 {
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value");
     shouldBeEqualToString("event.target.result.value.x", "value");
     shouldBeEqualToString("event.target.result.value.y", "zzz");
@@ -142,9 +142,9 @@ function cursor2Continue()
 
 function cursor2Continue2()
 {
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value2");
-    shouldBeEqualToString("event.target.result.value.x", "value2");    
+    shouldBeEqualToString("event.target.result.value.x", "value2");
     shouldBeEqualToString("event.target.result.value.y", "zzz2");
 
     // We re-use the last request object.
@@ -154,7 +154,7 @@ function cursor2Continue2()
 
 function last()
 {
-    shouldBeTrue("event.target.result === null");
+    shouldBeNull("event.target.result");
 
     if (testCount == 1)
         test();
index 047db21..d8b762c 100644 (file)
@@ -26,7 +26,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     evalAndLog("trans.oncomplete = addData");
 
index 6a0a8fe..578c3cd 100644 (file)
@@ -26,7 +26,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     evalAndLog("trans.oncomplete = startTest");
 
index 3b5fae1..cb36ce2 100644 (file)
@@ -9,11 +9,11 @@ function test()
 {
     removeVendorPrefixes();
 
-    shouldBeTrue("typeof indexedDB.open === 'function'");
-    shouldBeTrue("typeof indexedDB.cmp === 'function'");
-    shouldBeTrue("typeof indexedDB.getDatabaseNames === 'function'");
+    shouldBeEqualToString("typeof indexedDB.open", "function");
+    shouldBeEqualToString("typeof indexedDB.cmp", "function");
+    shouldBeEqualToString("typeof indexedDB.getDatabaseNames", "function");
 
-    shouldBeTrue("typeof indexedDB.deleteDatabase === 'function'");
+    shouldBeEqualToString("typeof indexedDB.deleteDatabase", "function");
 
     name = 'storage/indexeddb/factory-basics';
 
index f42676a..d17f7c6 100644 (file)
@@ -9,7 +9,7 @@ function test()
 {
     removeVendorPrefixes();
 
-    shouldBeTrue("typeof indexedDB.cmp === 'function'");
+    shouldBeEqualToString("typeof indexedDB.cmp", "function");
 
     testValidKeys();
     testInvalidKeys();
@@ -90,10 +90,10 @@ function testValidKeys()
     for (i = 0; i < keys.length - 1; i += 1) {
         key1 = keys[i];
         key2 = keys[i + 1];
-        shouldBeTrue("indexedDB.cmp(" + key1 + "," + key2 + ") === -1");
-        shouldBeTrue("indexedDB.cmp(" + key2 + "," + key1 + ") === 1");
-        shouldBeTrue("indexedDB.cmp(" + key1 + "," + key1 + ") === 0");
-        shouldBeTrue("indexedDB.cmp(" + key2 + "," + key2 + ") === 0");
+        shouldBe("indexedDB.cmp(" + key1 + "," + key2 + ")", "-1");
+        shouldBe("indexedDB.cmp(" + key2 + "," + key1 + ")", "1");
+        shouldBe("indexedDB.cmp(" + key1 + "," + key1 + ")", "0");
+        shouldBe("indexedDB.cmp(" + key2 + "," + key2 + ")", "0");
     }
 }
 
@@ -135,7 +135,7 @@ function testIdenticalKeys()
     debug("");
     debug("compare identical keys");
 
-    shouldBeTrue("indexedDB.cmp(0, -0) === 0");
+    shouldBe("indexedDB.cmp(0, -0)", "0");
 }
 
 test();
\ No newline at end of file
index 8e419f0..681d8a0 100644 (file)
@@ -25,7 +25,7 @@ function startSetVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
 
     store = evalAndLog("store = db.createObjectStore('storeName', null)");
 
index c47a676..8eec84d 100644 (file)
@@ -30,7 +30,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index 2d3ff46..811e918 100644 (file)
@@ -28,7 +28,7 @@ function deleteExisting(evt)
     event = evt;
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
@@ -174,7 +174,7 @@ function cursor1Continue(evt)
 {
     event = evt;
     shouldBe("event.target.source", "indexObject");
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value");
     shouldBeEqualToString("event.target.result.primaryKey", "key");
 
@@ -186,7 +186,7 @@ function cursor1Continue(evt)
 function cursor1Continue2(evt)
 {
     event = evt;
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value2");
     shouldBeEqualToString("event.target.result.primaryKey", "key2");
 
@@ -198,7 +198,7 @@ function cursor1Continue2(evt)
 function cursor1Continue3(evt)
 {
     event = evt;
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value3");
     shouldBeEqualToString("event.target.result.primaryKey", "key3");
 
@@ -210,7 +210,7 @@ function cursor1Continue3(evt)
 function openObjectCursor(evt)
 {
     event = evt;
-    shouldBeTrue("event.target.result === null");
+    shouldBeNull("event.target.result");
 
     self.request = evalAndLog("indexObject.openCursor()");
     request.onsuccess = cursor2Continue;
@@ -221,7 +221,7 @@ function cursor2Continue(evt)
 {
     event = evt;
     shouldBe("event.target.source", "indexObject");
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value");
     shouldBeEqualToString("event.target.result.value.x", "value");
     shouldBeEqualToString("event.target.result.value.y", "zzz");
@@ -234,7 +234,7 @@ function cursor2Continue(evt)
 function cursor2Continue2(evt)
 {
     event = evt;
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value2");
     shouldBeEqualToString("event.target.result.value.x", "value2");
     shouldBeEqualToString("event.target.result.value.y", "zzz2");
@@ -247,7 +247,7 @@ function cursor2Continue2(evt)
 function cursor2Continue3(evt)
 {
     event = evt;
-    shouldBeFalse("event.target.result === null");
+    shouldBeNonNull("event.target.result");
     shouldBeEqualToString("event.target.result.key", "value3");
     shouldBeEqualToString("event.target.result.value.x", "value3");
     shouldBeEqualToString("event.target.result.value.y", "456");
@@ -260,23 +260,14 @@ function cursor2Continue3(evt)
 function last(evt)
 {
     event = evt;
-    shouldBeTrue("event.target.result === null");
-
-    try {
-        debug("Passing an invalid key into indexObject.get({}).");
-        indexObject.get({});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into indexObject.getKey({}).");
-        indexObject.getKey({});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
+    shouldBeNull("event.target.result");
+
+    debug("Passing an invalid key into indexObject.get({}).");
+    evalAndExpectException("indexObject.get({})", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into indexObject.getKey({}).");
+    evalAndExpectException("indexObject.getKey({})", "IDBDatabaseException.DATA_ERR");
+
     finishJSTest();
 }
 
index f24c442..452c347 100644 (file)
@@ -23,7 +23,7 @@ function prepareDatabase()
     debug("");
     debug("preparing database");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
 
     deleteAllObjectStores(db);
 
@@ -45,19 +45,19 @@ function verifyCount()
     debug("");
     debug("verifying count without range");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = verifyCountWithRange;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
     index = evalAndLog("index = store.index('indexName')");
-    shouldBeTrue("index != null");
+    shouldBeNonNull("index");
 
     request = evalAndLog("request = index.count()");
     request.onerror = unexpectedErrorCallback;
     request.onsuccess = function() {
-         shouldBeTrue("typeof request.result == 'number'");
+         shouldBeEqualToString("typeof request.result", "number");
          shouldBe("request.result", "100");
          // let the transaction complete
     };
@@ -68,14 +68,14 @@ function verifyCountWithRange()
     debug("");
     debug("verifying count with range");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = verifyCountWithKey;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
     store = evalAndLog("index = trans.objectStore('storeName').index('indexName')");
-    shouldBeTrue("index != null");
+    shouldBeNonNull("index");
 
     var tests = [
         { lower: 0, lowerOpen: false, upper: 99, upperOpen: false, expected: 100 },
@@ -95,7 +95,7 @@ function verifyCountWithRange()
         request = evalAndLog("request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))");
         request.onerror = unexpectedErrorCallback;
         request.onsuccess = function() {
-             shouldBeTrue("typeof request.result == 'number'");
+             shouldBeEqualToString("typeof request.result", "number");
              shouldBe("request.result", String(test.expected));
 
              if (tests.length) {
@@ -113,14 +113,14 @@ function verifyCountWithKey()
     debug("");
     debug("verifying count with key");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = finishJSTest;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
     store = evalAndLog("index = trans.objectStore('storeName').index('indexName')");
-    shouldBeTrue("index != null");
+    shouldBeNonNull("index");
 
     evalAndExpectException("index.count(NaN)", "IDBDatabaseException.DATA_ERR");
     evalAndExpectException("index.count({})", "IDBDatabaseException.DATA_ERR");
@@ -138,7 +138,7 @@ function verifyCountWithKey()
         request = evalAndLog("request = index.count(test.key)");
         request.onerror = unexpectedErrorCallback;
         request.onsuccess = function() {
-             shouldBeTrue("typeof request.result == 'number'");
+             shouldBeEqualToString("typeof request.result", "number");
              shouldBe("request.result", String(test.expected));
 
              if (tests.length) {
index 5e84caa..1299363 100644 (file)
@@ -37,7 +37,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index ff7fcb1..9e1ad7a 100644 (file)
@@ -25,7 +25,7 @@ function prepareDatabase()
     debug("");
     debug("Creating empty stores and indexes");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = addData;
 
@@ -79,13 +79,13 @@ function verifyIndexes(indexName, callback)
         cursor = evalAndLog("cursor = event.target.result");
         if (cursor) {
             ex = expected.shift();
-            shouldBeTrue("ex != null");
+            shouldBeNonNull("ex");
             shouldBe("cursor.key", String(ex.key));
             shouldBeEqualToString("cursor.primaryKey", ex.primaryKey);
             shouldBeEqualToString("cursor.value.y", ex.y);
             cursor.continue();
         } else {
-            shouldBeTrue("expected.length === 0");
+            shouldBe("expected.length", "0");
         }
     };
 }
@@ -128,7 +128,7 @@ function createIndexOnStoreWithData()
     request.onsuccess = function() {
 
         var trans = evalAndLog("trans = event.target.result");
-        shouldBeTrue("trans !== null");
+        shouldBeNonNull("trans");
         trans.onabort = unexpectedAbortCallback;
         trans.oncomplete = function() { verifyIndexes('index-new', finishJSTest); };
 
index a997286..61f7667 100644 (file)
@@ -84,7 +84,7 @@ function setVersion2Abort()
     debug("");
     debug("setVersion2Abort():");
     shouldBe("db.objectStoreNames.length", "1");
-    shouldBe("db.objectStoreNames[0]", "'store1'");
+    shouldBeEqualToString("db.objectStoreNames[0]", "store1");
     finishJSTest();
 }
 
index 004b62a..629e364 100644 (file)
@@ -26,7 +26,7 @@ function deleteExisting()
 {
     debug("deleteExisting():");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = setVersionCompleted;
 
@@ -86,7 +86,7 @@ function changeDataSuccess()
 function cursorSuccess()
 {
     debug("cursorSuccess():");
-    shouldBe("event.target.result", "null");
+    shouldBeNull("event.target.result");
 
     // A key cursor starting at 1 should not find anything.
     var request = evalAndLog("transaction.objectStore('store').index('index').openKeyCursor(IDBKeyRange.lowerBound(1))");
@@ -97,7 +97,7 @@ function cursorSuccess()
 function keyCursorSuccess()
 {
     debug("keyCursorSuccess():");
-    shouldBe("event.target.result", "null");
+    shouldBeNull("event.target.result");
 
     // Now we should be able to add a value with x: 1.
     request = evalAndLog("transaction.objectStore('store').put({x: 1}, 'bar')");
index 5e470d9..f0a4704 100644 (file)
@@ -9,12 +9,6 @@ function test()
 {
     removeVendorPrefixes();
 
-    evalAndLog("IDBTransaction = self.IDBTransaction || self.IDBTransaction;");
-    shouldBeFalse("IDBTransaction == null");
-
-    evalAndLog("IDBDatabaseException = self.IDBDatabaseException || self.IDBDatabaseException;");
-    shouldBeFalse("IDBDatabaseException == null");
-
     name = self.location.pathname;
     openreq = evalAndLog("indexedDB.open(name)");
     openreq.onsuccess = openSuccess;
index c2f5f65..e2e4a8b 100644 (file)
@@ -118,53 +118,23 @@ function test()
     checkBoundKeyRange("'aae'", "'abe'", true, false);
     checkBoundKeyRange("'aaf'", "'abf'", true, true);
 
-    try {
-        debug("Passing an invalid key into only({})");
-        IDBKeyRange.only({});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into upperBound({})");
-        IDBKeyRange.upperBound({});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into lowerBound({})");
-        IDBKeyRange.lowerBound({});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into bound(null, {})");
-        IDBKeyRange.bound(null, {});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into bound({},null)");
-        IDBKeyRange.bound({}, null);
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
-
-    try {
-        debug("Passing an invalid key into bound({}, {})");
-        IDBKeyRange.bound({}, {});
-        testFailed("No exception thrown");
-    } catch (e) {
-        testPassed("Caught exception: " + e.toString());
-    }
+    debug("Passing an invalid key into only({})");
+    evalAndExpectException("IDBKeyRange.only({})", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into upperBound({})");
+    evalAndExpectException("IDBKeyRange.upperBound({})", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into lowerBound({})");
+    evalAndExpectException("IDBKeyRange.lowerBound({})", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into bound(null, {})");
+    evalAndExpectException("IDBKeyRange.bound(null, {})", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into bound({},null)");
+    evalAndExpectException("IDBKeyRange.bound({}, null)", "IDBDatabaseException.DATA_ERR");
+
+    debug("Passing an invalid key into bound({}, {})");
+    evalAndExpectException("IDBKeyRange.bound({}, {})", "IDBDatabaseException.DATA_ERR");
 
     debug("Lower key greater than higher key, bound(4, 3)");
     evalAndExpectException("IDBKeyRange.bound(4, 3)", "IDBDatabaseException.DATA_ERR");
index 9928942..9c9a5cc 100644 (file)
@@ -35,7 +35,7 @@ function populateStore()
     debug("");
     debug("populating store...");
     evalAndLog("trans = db.transaction('store', IDBTransaction.READ_WRITE)");
-    shouldBe("trans.mode", "'readwrite'");
+    shouldBeEqualToString("trans.mode", "readwrite");
     evalAndLog("store = trans.objectStore('store');");
     trans.onerror = unexpectedErrorCallback;
     trans.onabort = unexpectedAbortCallback;
@@ -48,7 +48,7 @@ function populateStore()
 function checkNext()
 {
     evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
-    shouldBe("trans.mode", "'readonly'");
+    shouldBeEqualToString("trans.mode", "readonly");
     store = trans.objectStore('store');
     evalAndLog("request = store.openCursor(null, IDBCursor.NEXT)");
     request.onsuccess = function()
@@ -56,7 +56,7 @@ function checkNext()
         cursor = event.target.result;
         if (!cursor)
             return;
-        shouldBe("cursor.direction", "'next'");
+        shouldBeEqualToString("cursor.direction", "next");
         evalAndLog("cursor.continue();");
     };
     trans.oncomplete = checkNextNoDuplicate;
@@ -65,7 +65,7 @@ function checkNext()
 function checkNextNoDuplicate()
 {
     evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
-    shouldBe("trans.mode", "'readonly'");
+    shouldBeEqualToString("trans.mode", "readonly");
     store = trans.objectStore('store');
     evalAndLog("request = store.openCursor(null, IDBCursor.NEXT_NO_DUPLICATE)");
     request.onsuccess = function()
@@ -73,7 +73,7 @@ function checkNextNoDuplicate()
         cursor = event.target.result;
         if (!cursor)
             return;
-        shouldBe("cursor.direction", "'nextunique'");
+        shouldBeEqualToString("cursor.direction", "nextunique");
         evalAndLog("cursor.continue();");
     };
     trans.oncomplete = checkPrev;
@@ -82,7 +82,7 @@ function checkNextNoDuplicate()
 function checkPrev()
 {
     evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
-    shouldBe("trans.mode", "'readonly'");
+    shouldBeEqualToString("trans.mode", "readonly");
     store = trans.objectStore('store');
     evalAndLog("request = store.openCursor(null, IDBCursor.PREV)");
     request.onsuccess = function()
@@ -90,7 +90,7 @@ function checkPrev()
         cursor = event.target.result;
         if (!cursor)
             return;
-        shouldBe("cursor.direction", "'prev'");
+        shouldBeEqualToString("cursor.direction", "prev");
         evalAndLog("cursor.continue();");
     };
     trans.oncomplete = checkPrevNoDuplicate;
@@ -99,7 +99,7 @@ function checkPrev()
 function checkPrevNoDuplicate()
 {
     evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
-    shouldBe("trans.mode", "'readonly'");
+    shouldBeEqualToString("trans.mode", "readonly");
     store = trans.objectStore('store');
     evalAndLog("request = store.openCursor(null, IDBCursor.NEXT)");
     request.onsuccess = function()
@@ -107,7 +107,7 @@ function checkPrevNoDuplicate()
         cursor = event.target.result;
         if (!cursor)
             return;
-        shouldBe("cursor.direction", "'next'");
+        shouldBeEqualToString("cursor.direction", "next");
         evalAndLog("cursor.continue();");
     };
     trans.oncomplete = finishJSTest;
index 04a4702..acdbc91 100644 (file)
@@ -28,7 +28,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = openForwardCursor;
 
index d975693..8a29e93 100644 (file)
@@ -27,7 +27,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = setVersionCompleted;
 
@@ -41,7 +41,7 @@ function setVersionSuccess()
     var storeNames = evalAndLog("storeNames = db.objectStoreNames");
 
     shouldBeEqualToString("store.name", "StoreWithKeyPath");
-    shouldBe("store.keyPath", "'id'");
+    shouldBeEqualToString("store.keyPath", "id");
     shouldBe("storeNames.contains('StoreWithKeyPath')", "true");
     shouldBe("storeNames.contains('StoreWithAutoIncrement')", "true");
     shouldBe("storeNames.contains('PlainOldStore')", "true");
@@ -181,7 +181,7 @@ function testLongKeyPath()
         if (expected === null) {
             evalAndLog("expected = cursor.value.a.b.c.id + 1");
         } else {
-            shouldBe("cursor.value.foo", "'bar'");
+            shouldBeEqualToString("cursor.value.foo", "bar");
             shouldBe("cursor.value.a.b.c.id", "expected");
             evalAndLog("expected = cursor.value.a.b.c.id + 1");
         }
index 074d319..611628a 100644 (file)
@@ -29,7 +29,7 @@ function setVersionSuccess(evt)
     event = evt;
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
@@ -76,16 +76,7 @@ function setVersionSuccess(evt)
     // FIXME: test all of object store's methods.
 
     debug("Ask for an index that doesn't exist:");
-    try {
-        debug("index = store.index('asdf')");
-        index = store.index('asdf');
-        testFailed("Asking for a store that doesn't exist should have thrown.");
-    } catch (err) {
-        testPassed("Exception thrown.");
-        code = err.code;
-        shouldBe("code", "IDBDatabaseException.NOT_FOUND_ERR");
-    }
-
+    evalAndExpectException("store.index('asdf')", "IDBDatabaseException.NOT_FOUND_ERR");
     createIndex();
 }
 
@@ -93,21 +84,13 @@ function createIndex()
 {
     debug("createIndex():");
     var index = evalAndLog("index = store.createIndex('indexName', 'x', {unique: true})"); // true == unique requirement.
-    shouldBeTrue("index !== null");
+    shouldBeNonNull("index");
     shouldBeTrue("store.indexNames.contains('indexName')");
     index = evalAndLog("index = store.index('indexName')");
-    shouldBeTrue("index !== null");
+    shouldBeNonNull("index");
 
     debug("Ask for an index that doesn't exist:");
-    try {
-        debug("index = store.index('asdf')");
-        index = store.index('asdf');
-        testFailed("Asking for a store that doesn't exist should have thrown.");
-    } catch (err) {
-        testPassed("Exception thrown.");
-        code = err.code
-        shouldBe("code", "IDBDatabaseException.NOT_FOUND_ERR");
-    }
+    evalAndExpectException("store.index('asdf')", "IDBDatabaseException.NOT_FOUND_ERR");
     trans.oncomplete = testSetVersionAbort;
 }
 
@@ -124,7 +107,7 @@ function createAnotherIndex(evt)
     shouldBeEqualToString("db.version", "version fail");
 
     var setVersionTrans = evalAndLog("setVersionTrans = event.target.result");
-    shouldBeTrue("setVersionTrans !== null");
+    shouldBeNonNull("setVersionTrans");
     setVersionTrans.oncomplete = unexpectedCompleteCallback;
     setVersionTrans.onabort = checkMetadata;
     self.store = evalAndLog("store = setVersionTrans.objectStore('storeName')");
@@ -169,17 +152,7 @@ function addDateSuccess(evt)
 {
     event = evt;
     debug("Try to insert a value not handled by structured clone:");
-    try {
-        debug("store.add({x: 'bar', y: self}, 'bar')");
-        store.add({x: 'bar', y: self}, 'bar');
-        testFailed("Passing a DOM node as value should have thrown.");
-    } catch (err) {
-        testPassed("Exception thrown");
-        code = err.code;
-        // FIXME: When we move to DOM4-style exceptions this should look for the
-        // name "DataCloneError".
-        shouldBe("code", "25");
-    }
+    evalAndExpectException("store.add({x: 'bar', y: self}, 'bar')", "DOMException.DATA_CLONE_ERR");
 
     debug("Try to insert data where key path yields a Date key:");
     request = evalAndLog("store.add({x: testDateB, y: 'value'}, 'key')");
@@ -215,13 +188,13 @@ function addAgainFailure(evt)
 
     transaction = evalAndLog("db.transaction(['storeName'], 'readwrite')");
     transaction.onabort = unexpectedErrorCallback;
-    var store = evalAndLog("store = transaction.objectStore('storeName')");
+    store = evalAndLog("store = transaction.objectStore('storeName')");
 
     evalAndExpectException("store.add({x: null}, 'validkey')", "IDBDatabaseException.DATA_ERR");
 
     transaction = evalAndLog("db.transaction(['storeName'], 'readwrite')");
     transaction.onabort = unexpectedErrorCallback;
-    var store = evalAndLog("store = transaction.objectStore('storeName')");
+    store = evalAndLog("store = transaction.objectStore('storeName')");
 
     request = evalAndLog("store.get('key')");
     request.addEventListener('success', getSuccess, true);
index 6947c6c..0b7f3ff 100644 (file)
@@ -25,7 +25,7 @@ function startSetVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
 
     deleteAllObjectStores(db);
 
index 5b0ffb3..e15d892 100644 (file)
@@ -23,7 +23,7 @@ function prepareDatabase()
     debug("");
     debug("preparing database");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
 
     deleteAllObjectStores(db);
 
@@ -42,17 +42,17 @@ function verifyCount()
     debug("");
     debug("verifying count without range");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = verifyCountWithRange;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
 
     request = evalAndLog("request = store.count()");
     request.onerror = unexpectedErrorCallback;
     request.onsuccess = function() {
-         shouldBeTrue("typeof request.result == 'number'");
+         shouldBeEqualToString("typeof request.result", "number");
          shouldBe("request.result", "100");
          // let the transaction complete
     };
@@ -63,12 +63,12 @@ function verifyCountWithRange()
     debug("");
     debug("verifying count with range");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = verifyCountWithKey;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
 
     var tests = [
         { lower: 0, lowerOpen: false, upper: 99, upperOpen: false, expected: 100 },
@@ -88,7 +88,7 @@ function verifyCountWithRange()
         request = evalAndLog("request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))");
         request.onerror = unexpectedErrorCallback;
         request.onsuccess = function() {
-             shouldBeTrue("typeof request.result == 'number'");
+             shouldBeEqualToString("typeof request.result", "number");
              shouldBe("request.result", String(test.expected));
 
              if (tests.length) {
@@ -106,12 +106,12 @@ function verifyCountWithKey()
     debug("");
     debug("verifying count with key");
     trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = finishJSTest;
 
     store = evalAndLog("store = trans.objectStore('storeName')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
 
     evalAndExpectException("store.count(NaN)", "IDBDatabaseException.DATA_ERR");
     evalAndExpectException("store.count({})", "IDBDatabaseException.DATA_ERR");
@@ -129,7 +129,7 @@ function verifyCountWithKey()
         request = evalAndLog("request = store.count(test.key)");
         request.onerror = unexpectedErrorCallback;
         request.onsuccess = function() {
-            shouldBeTrue("typeof request.result == 'number'");
+            shouldBeEqualToString("typeof request.result", "number");
             shouldBe("request.result", String(test.expected));
              if (tests.length) {
                  nextTest();
index 4d903eb..9b0434d 100644 (file)
@@ -36,7 +36,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index 8398475..74e6115 100644 (file)
@@ -25,7 +25,7 @@ function startSetVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
 
     deleteAllObjectStores(db);
 
@@ -62,7 +62,7 @@ function addIndex()
 function deleteObjectStore()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     evalAndLog("db.deleteObjectStore('storeName')");
index 048b140..bcc2733 100644 (file)
@@ -27,9 +27,9 @@ function cursorWithKeySuccess()
     debug("Cursor opened successfully.");
     // FIXME: check that we can iterate the cursor.
     cursor = event.target.result;
-    shouldBe("cursor.direction", "'next'");
-    shouldBe("cursor.key", "'myKey'");
-    shouldBe("cursor.value", "'myValue'");
+    shouldBeEqualToString("cursor.direction", "next");
+    shouldBeEqualToString("cursor.key", "myKey");
+    shouldBeEqualToString("cursor.value", "myValue");
     debug("");
     debug("Passing an invalid key into .continue({}).");
     evalAndExpectException("cursor.continue({})", "IDBDatabaseException.DATA_ERR");
@@ -67,9 +67,9 @@ function cursorSuccess()
     debug("Cursor opened successfully.");
     // FIXME: check that we can iterate the cursor.
     cursor = event.target.result;
-    shouldBe("cursor.direction", "'next'");
-    shouldBe("cursor.key", "'myKey'");
-    shouldBe("cursor.value", "'myValue'");
+    shouldBeEqualToString("cursor.direction", "next");
+    shouldBeEqualToString("cursor.key", "myKey");
+    shouldBeEqualToString("cursor.value", "myValue");
     debug("");
     debug("Passing an invalid key into .continue({}).");
     evalAndExpectException("event.target.result.continue({})", "IDBDatabaseException.DATA_ERR");
@@ -90,7 +90,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index a828b95..7a4127a 100644 (file)
@@ -92,7 +92,7 @@ function testObjectStore()
         cursor = event.target.result;
 
         if (count == 0) {
-            shouldBe("cursor.key", "'237-23-7739'");
+            shouldBeEqualToString("cursor.key", "237-23-7739");
             shouldBe("JSON.stringify(cursor.value)", "JSON.stringify(objectStoreData[7].value)");
             shouldBe("cursor.primaryKey", "cursor.key");
             evalAndLog("cursor.continue()");
@@ -122,19 +122,19 @@ function testIndex()
             shouldBe("cursor.key", '180');
             shouldBe("JSON.stringify(cursor.value)",
                      "JSON.stringify(objectStoreData[2].value)");
-            shouldBe("cursor.primaryKey", "'237-23-7734'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7734");
             evalAndLog("cursor.continue()");
         } else if (count == 1) {
             shouldBe("cursor.key", '180');
             shouldBe("JSON.stringify(cursor.value)",
                      "JSON.stringify(objectStoreData[6].value)");
-            shouldBe("cursor.primaryKey", "'237-23-7738'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7738");
             evalAndLog("cursor.continue()");
         } else if (count == 2) {
             shouldBe("cursor.key", '180');
             shouldBe("JSON.stringify(cursor.value)",
                      "JSON.stringify(objectStoreData[10].value)");
-            shouldBe("cursor.primaryKey", "'237-23-7742'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7742");
             evalAndLog("cursor.continue()");
         } else if (count == 3) {
             shouldBeNull("cursor");
@@ -160,15 +160,15 @@ function testIndexWithKey()
 
         if (count == 0) {
             shouldBe("cursor.key", '180');
-            shouldBe("cursor.primaryKey", "'237-23-7734'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7734");
             evalAndLog("cursor.continue()");
         } else if (count == 1) {
             shouldBe("cursor.key", '180');
-            shouldBe("cursor.primaryKey", "'237-23-7738'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7738");
             evalAndLog("cursor.continue()");
         } else if (count == 2) {
             shouldBe("cursor.key", '180');
-            shouldBe("cursor.primaryKey", "'237-23-7742'");
+            shouldBeEqualToString("cursor.primaryKey", "237-23-7742");
             evalAndLog("cursor.continue()");
         } else if (count == 3) {
             shouldBeNull("cursor");
index 6a173d6..2e08a12 100644 (file)
@@ -36,7 +36,7 @@ function setVersionSuccess()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.oncomplete = iterateAndDeleteFirstElement;
 
index 100bfd5..095cdd9 100644 (file)
@@ -26,7 +26,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     deleteAllObjectStores(db);
index d528fff..a30a97e 100644 (file)
@@ -26,7 +26,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     evalAndLog("trans.oncomplete = startTest");
 
index 4e3f44b..0006625 100644 (file)
@@ -26,7 +26,7 @@ function openSuccess()
 
 function postSetVersion()
 {
-    shouldBe("db.version", "'null'");
+    shouldBeEqualToString("db.version", "null");
     finishJSTest();
 }
 
index cfd7127..39bd4cb 100644 (file)
@@ -91,11 +91,11 @@ function evalAndExpectExceptionClass(cmd, expected)
         eval(cmd);
         testFailed("No exception thrown!" );
     } catch (e) {
-               testPassed("Exception was thrown.");
-               if (eval("e instanceof " + expected))
-                       testPassed(cmd + " threw " + e);
-               else
-                       testFailed("Expected " + expected + " but saw " + e);
+        testPassed("Exception was thrown.");
+        if (eval("e instanceof " + expected))
+            testPassed(cmd + " threw " + e);
+        else
+            testFailed("Expected " + expected + " but saw " + e);
     }
 }
 
@@ -112,3 +112,34 @@ function deleteAllObjectStores(db)
         db.deleteObjectStore(db.objectStoreNames.item(0));
     debug("Deleted all object stores.");
 }
+
+// For Workers
+if (!self.DOMException) {
+    self.DOMException = {
+        INDEX_SIZE_ERR: 1,
+        DOMSTRING_SIZE_ERR: 2,
+        HIERARCHY_REQUEST_ERR: 3,
+        WRONG_DOCUMENT_ERR: 4,
+        INVALID_CHARACTER_ERR: 5,
+        NO_DATA_ALLOWED_ERR: 6,
+        NO_MODIFICATION_ALLOWED_ERR: 7,
+        NOT_FOUND_ERR: 8,
+        NOT_SUPPORTED_ERR: 9,
+        INUSE_ATTRIBUTE_ERR: 10,
+        INVALID_STATE_ERR: 11,
+        SYNTAX_ERR: 12,
+        INVALID_MODIFICATION_ERR: 13,
+        NAMESPACE_ERR: 14,
+        INVALID_ACCESS_ERR: 15,
+        VALIDATION_ERR: 16,
+        TYPE_MISMATCH_ERR: 17,
+        SECURITY_ERR: 18,
+        NETWORK_ERR: 19,
+        ABORT_ERR: 20,
+        URL_MISMATCH_ERR: 21,
+        QUOTA_EXCEEDED_ERR: 22,
+        TIMEOUT_ERR: 23,
+        INVALID_NODE_TYPE_ERR: 24,
+        DATA_CLONE_ERR: 25
+    };
+}
index 40ce886..ff61301 100644 (file)
@@ -27,7 +27,7 @@ function deleteExisting()
 {
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     evalAndLog("trans.oncomplete = startTest");
 
index 9ea286c..e349143 100644 (file)
@@ -101,20 +101,20 @@ function created()
     debug("");
 
     trans = evalAndLog("trans = db.transaction(['store'])");
-    shouldBeTrue("trans != null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.onerror = unexpectedErrorCallback;
     trans.oncomplete = afterComplete;
     evalAndLog("store = trans.objectStore('store')");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("store");
     evalAndLog("store.get('some_key')");
 }
 
 function afterComplete()
 {
     debug("transaction complete, ensuring methods fail");
-    shouldBeTrue("trans != null");
-    shouldBeTrue("store != null");
+    shouldBeNonNull("trans");
+    shouldBeNonNull("store");
     evalAndExpectException("trans.objectStore('store')", "IDBDatabaseException.NOT_ALLOWED_ERR");
     evalAndExpectException("store.index('index')", "IDBDatabaseException.NOT_ALLOWED_ERR");
 
index ddcc79a..ce852c9 100644 (file)
@@ -40,7 +40,7 @@ function addRemoveIDBObjects()
 {
     debug("addRemoveIDBObjects():");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.addEventListener('abort', testSetVersionAbort2, true);
     trans.oncomplete = unexpectedCompleteCallback;
 
@@ -66,7 +66,7 @@ function addRemoveAddIDBObjects()
 {
     debug("addRemoveAddIDBObjects():");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.addEventListener('abort', testSetVersionAbort3, false);
     trans.oncomplete = unexpectedCompleteCallback;
 
@@ -97,7 +97,7 @@ function addIDBObjects()
     debug("addIDBObjects():");
     shouldBeFalse("event.cancelable");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = testInactiveAbortedTransaction;
     trans.oncomplete = unexpectedCompleteCallback;
 
@@ -140,7 +140,7 @@ function addIDBObjectsAndCommit()
 {
     debug("addIDBObjectsAndCommit():");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
 
     store = evalAndLog("store = db.createObjectStore('storeFail', null)");
@@ -182,7 +182,7 @@ function removeIDBObjects()
 {
     debug("removeIDBObjects():");
     var trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = testSetVersionAbort6;
     trans.oncomplete = unexpectedCompleteCallback;
 
@@ -234,7 +234,7 @@ function setVersionSuccess()
     debug("");
     debug("setVersionSuccess():");
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     trans.addEventListener('complete', completeCallback, false);
     self.completeEventFired = false;
@@ -269,7 +269,7 @@ function testDOMStringList()
     evalAndLog("transaction = db.transaction(db.objectStoreNames)");
     testPassed("no exception thrown");
     for (var i = 0; i < db.objectStoreNames.length; ++i) {
-      shouldBeTrue("transaction.objectStore(" + JSON.stringify(db.objectStoreNames[i]) + ") != null");
+      shouldBeNonNull("transaction.objectStore(" + JSON.stringify(db.objectStoreNames[i]) + ")");
     }
     testPassed("all stores present in transaction");
     testInvalidMode();
index 3ed4f85..7e53c97 100644 (file)
@@ -25,7 +25,7 @@ function setVersion()
 function deleteExisting()
 {
     self.trans = evalAndLog("trans = event.target.result");
-    shouldBeTrue("trans !== null");
+    shouldBeNonNull("trans");
     trans.onabort = unexpectedAbortCallback;
     evalAndLog("trans.oncomplete = startTest");
 
index 67a2f6d..ad72a94 100644 (file)
@@ -52,7 +52,7 @@ function setVersionComplete()
 function addSuccess()
 {
     debug("addSuccess():");
-    shouldBe("event.target.result", "'rollbackKey123'");
+    shouldBeEqualToString("event.target.result", "rollbackKey123");
 
     request = evalAndLog("store.openCursor()");
     request.onsuccess = openCursorSuccess;
@@ -84,7 +84,7 @@ function getSuccess()
     debug("getSuccess():");
     shouldBe("event.target.result", "undefined");
 
-    shouldBe("cursor.value", "'rollbackValue'");
+    shouldBeEqualToString("cursor.value", "rollbackValue");
     finishJSTest();
 }
 
index a66e514..b8ac59b 100644 (file)
@@ -8,8 +8,8 @@ description("Test behavior when the same connection calls setVersion twice");
 function test() {
     removeVendorPrefixes();
 
-    shouldBeFalse("indexedDB == null");
-    shouldBeFalse("IDBTransaction == null");
+    shouldBeNonNull("indexedDB");
+    shouldBeNonNull("IDBTransaction");
     openDBConnection();
 }
 
index 3a6b261..d07229b 100644 (file)
@@ -60,7 +60,7 @@ function openACursor()
         if (cursor) {
             shouldBe("cursor.value.toString()", "validTypes[valueIndex].value.toString()");
             if (valueIndex == 1) {
-                shouldBe("cursor.value.toUTCString()", "'Thu, 01 Jan 1970 00:00:00 GMT'");
+                shouldBeEqualToString("cursor.value.toUTCString()", "Thu, 01 Jan 1970 00:00:00 GMT");
             }
             if (valueIndex == 3) {
                 shouldBe("cursor.value.width", "1");
index e3136d3..42aa75e 100644 (file)
@@ -8,7 +8,7 @@ indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.
 indexedDB.open(name)
 db = event.target.result
 db.setVersion(null);
-PASS db.version is 'null'
+PASS db.version is "null"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 320bf56..7c2e261 100644 (file)
@@ -10,7 +10,7 @@ db = event.target.result
 db.setVersion('new version')
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 trans.oncomplete = startTest
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
index 21970f2..807f0c2 100644 (file)
@@ -109,13 +109,13 @@ PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_FOUND_ERR
 
 trans = db.transaction(['store'])
-PASS trans != null is true
+PASS trans is non-null.
 store = trans.objectStore('store')
-PASS store != null is true
+PASS store is non-null.
 store.get('some_key')
 transaction complete, ensuring methods fail
-PASS trans != null is true
-PASS store != null is true
+PASS trans is non-null.
+PASS store is non-null.
 Expecting exception from trans.objectStore('store')
 PASS Exception was thrown.
 PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
index a8aa094..b49beae 100644 (file)
@@ -16,7 +16,7 @@ PASS self.db.objectStoreNames.contains('storeFail') is false
 request = startSetVersion('version fail')
 addRemoveIDBObjects():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = db.createObjectStore('storeFail', null)
 index = store.createIndex('indexFail', 'x')
 db.deleteObjectStore('storeFail')
@@ -29,7 +29,7 @@ PASS self.db.objectStoreNames.contains('storeFail') is false
 request = startSetVersion('version fail')
 addRemoveAddIDBObjects():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = db.createObjectStore('storeFail', null)
 index = store.createIndex('indexFail', 'x')
 db.deleteObjectStore('storeFail')
@@ -46,7 +46,7 @@ request = startSetVersion('version fail')
 addIDBObjects():
 PASS event.cancelable is false
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = db.createObjectStore('storeFail', null)
 index = store.createIndex('indexFail', 'x')
 
@@ -92,7 +92,7 @@ PASS self.db.objectStoreNames.contains('storeFail') is false
 request = startSetVersion('version fail')
 addIDBObjectsAndCommit():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = db.createObjectStore('storeFail', null)
 index = store.createIndex('indexFail', 'x')
 
@@ -138,7 +138,7 @@ PASS db.objectStoreNames.contains('storeFail') is true
 request = startSetVersion('version fail')
 removeIDBObjects():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 store = trans.objectStore('storeFail')
 store.deleteIndex('indexFail')
 db.deleteObjectStore('storeFail')
@@ -151,7 +151,7 @@ db.setVersion('new version')
 
 setVersionSuccess():
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 Deleted all object stores.
 db.createObjectStore('storeName', null)
 PASS event.cancelable is false
@@ -166,7 +166,7 @@ db.objectStoreNames is [object DOMStringList]
 ... which contains: ["storeName"]
 transaction = db.transaction(db.objectStoreNames)
 PASS no exception thrown
-PASS transaction.objectStore("storeName") != null is true
+PASS transaction.objectStore("storeName") is non-null.
 PASS all stores present in transaction
 
 Verify that specifying an invalid mode raises an exception
index e8876b0..bbbec1a 100644 (file)
@@ -9,7 +9,7 @@ indexedDB.open('transaction-event-propagation')
 db = event.target.result
 db.setVersion('new version')
 trans = event.target.result
-PASS trans !== null is true
+PASS trans is non-null.
 trans.oncomplete = startTest
 Deleted all object stores.
 store = db.createObjectStore('storeName', null)
index 053cfe6..4ab9da0 100644 (file)
@@ -19,7 +19,7 @@ transaction = db.transaction(['myObjectStore'], 'readwrite')
 store = transaction.objectStore('myObjectStore')
 store.add('rollbackValue', 'rollbackKey123')
 addSuccess():
-PASS event.target.result is 'rollbackKey123'
+PASS event.target.result is "rollbackKey123"
 store.openCursor()
 openCursorSuccess():
 cursor = event.target.result
@@ -30,7 +30,7 @@ store = transaction.objectStore('myObjectStore')
 store.get('rollbackKey123')
 getSuccess():
 PASS event.target.result is undefined
-PASS cursor.value is 'rollbackValue'
+PASS cursor.value is "rollbackValue"
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 41b8a84..7594216 100644 (file)
@@ -5,8 +5,8 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
 
 indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
 
-PASS indexedDB == null is false
-PASS IDBTransaction == null is false
+PASS indexedDB is non-null.
+PASS IDBTransaction is non-null.
 self.state = 'starting'
 indexedDB.open('two-versions-one-connection')
 db = event.target.result
index c6b6d7e..56f461f 100644 (file)
@@ -25,7 +25,7 @@ cursor.continue();
 valueIndex++;
 cursor = event.target.result;
 PASS cursor.value.toString() is validTypes[valueIndex].value.toString()
-PASS cursor.value.toUTCString() is 'Thu, 01 Jan 1970 00:00:00 GMT'
+PASS cursor.value.toUTCString() is "Thu, 01 Jan 1970 00:00:00 GMT"
 cursor.continue();
 valueIndex++;
 cursor = event.target.result;