⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 117702 in webkit


Ignore:
Timestamp:
May 19, 2012, 4:36:46 PM (14 years ago)
Author:
jsbell@chromium.org
Message:

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:
Location:
trunk/LayoutTests
Files:
108 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r117701 r117702  
     12012-05-19  Joshua Bell  <jsbell@chromium.org>
     2
     3        IndexedDB layout tests should make better use of test library functions
     4        https://bugs.webkit.org/show_bug.cgi?id=86932
     5
     6        Reviewed by Ojan Vafai.
     7
     8        Use functions like shouldBeEqualToString, shouldBeNull,  evalAndExpectException
     9        and so forth where possible.
     10
     11        * storage/indexeddb/basics-expected.txt:
     12        * storage/indexeddb/basics-workers-expected.txt:
     13        * storage/indexeddb/create-object-store-options-expected.txt:
     14        * storage/indexeddb/createObjectStore-null-name-expected.txt:
     15        * storage/indexeddb/cursor-added-bug-expected.txt:
     16        * storage/indexeddb/cursor-continue-expected.txt:
     17        * storage/indexeddb/cursor-continue-validity-expected.txt:
     18        * storage/indexeddb/cursor-delete-expected.txt:
     19        * storage/indexeddb/cursor-inconsistency-expected.txt:
     20        * storage/indexeddb/cursor-index-delete-expected.txt:
     21        * storage/indexeddb/cursor-key-order-expected.txt:
     22        * storage/indexeddb/cursor-primary-key-order-expected.txt:
     23        * storage/indexeddb/cursor-skip-deleted-expected.txt:
     24        * storage/indexeddb/cursor-update-expected.txt:
     25        * storage/indexeddb/data-corruption-expected.txt:
     26        * storage/indexeddb/database-basics-expected.txt:
     27        * storage/indexeddb/duplicates-expected.txt:
     28        * storage/indexeddb/error-causes-abort-by-default-expected.txt:
     29        * storage/indexeddb/exception-in-event-aborts-expected.txt:
     30        * storage/indexeddb/factory-basics-expected.txt:
     31        * storage/indexeddb/factory-cmp-expected.txt:
     32        * storage/indexeddb/factory-deletedatabase-expected.txt:
     33        * storage/indexeddb/get-keyrange-expected.txt:
     34        * storage/indexeddb/index-basics-expected.txt:
     35        * storage/indexeddb/index-basics-workers-expected.txt:
     36        * storage/indexeddb/index-count-expected.txt:
     37        * storage/indexeddb/index-cursor-expected.txt:
     38        * storage/indexeddb/index-multientry-expected.txt:
     39        * storage/indexeddb/index-population-expected.txt:
     40        * storage/indexeddb/index-unique-expected.txt:
     41        * storage/indexeddb/key-type-array-expected.txt:
     42        * storage/indexeddb/keyrange-expected.txt:
     43        * storage/indexeddb/legacy-constants-expected.txt:
     44        * storage/indexeddb/mutating-cursor-expected.txt:
     45        * storage/indexeddb/objectstore-autoincrement-expected.txt:
     46        * storage/indexeddb/objectstore-basics-expected.txt:
     47        * storage/indexeddb/objectstore-basics-workers-expected.txt:
     48        * storage/indexeddb/objectstore-clear-expected.txt:
     49        * storage/indexeddb/objectstore-count-expected.txt:
     50        * storage/indexeddb/objectstore-cursor-expected.txt:
     51        * storage/indexeddb/objectstore-removeobjectstore-expected.txt:
     52        * storage/indexeddb/open-cursor-expected.txt:
     53        * storage/indexeddb/opencursor-key-expected.txt:
     54        * storage/indexeddb/prefetch-bugfix-108071-expected.txt:
     55        * storage/indexeddb/queued-commands-expected.txt:
     56        * storage/indexeddb/request-event-propagation-expected.txt:
     57        * storage/indexeddb/resources/basics.js:
     58        (test):
     59        (openCallback):
     60        * storage/indexeddb/resources/create-object-store-options.js:
     61        (setVersionComplete):
     62        * storage/indexeddb/resources/createObjectStore-null-name.js:
     63        (createAndPopulateObjectStore):
     64        * storage/indexeddb/resources/cursor-added-bug.js:
     65        (setVersionSuccess):
     66        * storage/indexeddb/resources/cursor-continue-validity.js:
     67        (deleteExisting):
     68        * storage/indexeddb/resources/cursor-continue.js:
     69        (deleteExisting):
     70        * storage/indexeddb/resources/cursor-delete.js:
     71        (setVersionSuccess):
     72        * storage/indexeddb/resources/cursor-inconsistency.js:
     73        (setVersionSuccess):
     74        (checkCursor):
     75        * storage/indexeddb/resources/cursor-index-delete.js:
     76        (setVersionSuccess):
     77        * storage/indexeddb/resources/cursor-key-order.js:
     78        (checkStore.curreq.onsuccess.getreq.onsuccess):
     79        (checkStore.curreq.onsuccess):
     80        (checkStore):
     81        * storage/indexeddb/resources/cursor-primary-key-order.js:
     82        (checkStore.cursorRequest.onsuccess):
     83        (checkStore):
     84        * storage/indexeddb/resources/cursor-skip-deleted.js:
     85        (setVersionSuccess):
     86        * storage/indexeddb/resources/cursor-update.js:
     87        (setVersionSuccess):
     88        (basicUpdateCursor.request.onsuccess):
     89        (basicUpdateCursor):
     90        (autoIncrementUpdateCursor.request.onsuccess):
     91        (autoIncrementUpdateCursor):
     92        (keyPathUpdateCursor.request.onsuccess):
     93        (keyPathUpdateCursor):
     94        (keyCursor):
     95        * storage/indexeddb/resources/data-corruption.js:
     96        (setVersionSuccess):
     97        (doCheck):
     98        * storage/indexeddb/resources/database-basics.js:
     99        (setVersionSuccess):
     100        (createAnotherObjectStore):
     101        * storage/indexeddb/resources/database-quota.js:
     102        (setVersionSuccess):
     103        * storage/indexeddb/resources/duplicates.js:
     104        (deleteExisting):
     105        (cursor1Continue):
     106        (cursor1Continue2):
     107        (openObjectCursor):
     108        (cursor2Continue):
     109        (cursor2Continue2):
     110        (last):
     111        * storage/indexeddb/resources/error-causes-abort-by-default.js:
     112        (deleteExisting):
     113        * storage/indexeddb/resources/exception-in-event-aborts.js:
     114        (deleteExisting):
     115        * storage/indexeddb/resources/factory-basics.js:
     116        (test):
     117        * storage/indexeddb/resources/factory-cmp.js:
     118        (test):
     119        (testValidKeys):
     120        (testIdenticalKeys):
     121        * storage/indexeddb/resources/factory-deletedatabase.js:
     122        (deleteExisting):
     123        * storage/indexeddb/resources/get-keyrange.js:
     124        (deleteExisting):
     125        * storage/indexeddb/resources/index-basics.js:
     126        (deleteExisting):
     127        (cursor1Continue):
     128        (cursor1Continue2):
     129        (cursor1Continue3):
     130        (openObjectCursor):
     131        (cursor2Continue):
     132        (cursor2Continue2):
     133        (cursor2Continue3):
     134        (last):
     135        * storage/indexeddb/resources/index-count.js:
     136        (prepareDatabase):
     137        (verifyCount.request.onsuccess):
     138        (verifyCount):
     139        (verifyCountWithRange.nextTest.request.onsuccess):
     140        (verifyCountWithRange.nextTest):
     141        (verifyCountWithRange):
     142        (verifyCountWithKey.nextTest.request.onsuccess):
     143        (verifyCountWithKey.nextTest):
     144        (verifyCountWithKey):
     145        * storage/indexeddb/resources/index-cursor.js:
     146        (deleteExisting):
     147        * storage/indexeddb/resources/index-multientry.js:
     148        (prepareDatabase):
     149        (verifyIndexes.request.onsuccess):
     150        (verifyIndexes):
     151        * storage/indexeddb/resources/index-population.js:
     152        (setVersion2Abort):
     153        * storage/indexeddb/resources/index-unique.js:
     154        (deleteExisting):
     155        (cursorSuccess):
     156        (keyCursorSuccess):
     157        * storage/indexeddb/resources/key-type-array.js:
     158        (test):
     159        * storage/indexeddb/resources/keyrange.js:
     160        (test):
     161        * storage/indexeddb/resources/legacy-constants.js:
     162        (populateStore):
     163        (checkNext.request.onsuccess):
     164        (checkNext):
     165        (checkNextNoDuplicate.request.onsuccess):
     166        (checkNextNoDuplicate):
     167        (checkPrev.request.onsuccess):
     168        (checkPrev):
     169        (checkPrevNoDuplicate.request.onsuccess):
     170        (checkPrevNoDuplicate):
     171        * storage/indexeddb/resources/mutating-cursor.js:
     172        (setVersionSuccess):
     173        * storage/indexeddb/resources/objectstore-autoincrement.js:
     174        (setVersionSuccess):
     175        (testLongKeyPath.cursorRequest.onsuccess):
     176        (testLongKeyPath):
     177        * storage/indexeddb/resources/objectstore-basics.js:
     178        (setVersionSuccess):
     179        (createIndex):
     180        (createAnotherIndex):
     181        (addDateSuccess):
     182        (addAgainFailure):
     183        * storage/indexeddb/resources/objectstore-clear.js:
     184        (deleteExisting):
     185        * storage/indexeddb/resources/objectstore-count.js:
     186        (prepareDatabase):
     187        (verifyCount.request.onsuccess):
     188        (verifyCount):
     189        (verifyCountWithRange.nextTest.request.onsuccess):
     190        (verifyCountWithRange.nextTest):
     191        (verifyCountWithRange):
     192        (verifyCountWithKey.nextTest.request.onsuccess):
     193        (verifyCountWithKey.nextTest):
     194        (verifyCountWithKey):
     195        * storage/indexeddb/resources/objectstore-cursor.js:
     196        (deleteExisting):
     197        * storage/indexeddb/resources/objectstore-removeobjectstore.js:
     198        (deleteExisting):
     199        (deleteObjectStore):
     200        * storage/indexeddb/resources/open-cursor.js:
     201        (cursorWithKeySuccess):
     202        (cursorSuccess):
     203        (setVersionSuccess):
     204        * storage/indexeddb/resources/opencursor-key.js:
     205        (testObjectStore.request.onsuccess):
     206        (testObjectStore):
     207        (testIndex.request.onsuccess):
     208        (testIndex):
     209        (testIndexWithKey.request.onsuccess):
     210        (testIndexWithKey):
     211        * storage/indexeddb/resources/prefetch-bugfix-108071.js:
     212        (setVersionSuccess):
     213        * storage/indexeddb/resources/queued-commands.js:
     214        * storage/indexeddb/resources/request-event-propagation.js:
     215        (deleteExisting):
     216        * storage/indexeddb/resources/setVersion-null.js:
     217        (postSetVersion):
     218        * storage/indexeddb/resources/shared.js:
     219        (evalAndExpectExceptionClass):
     220        * storage/indexeddb/resources/transaction-abort.js:
     221        (deleteExisting):
     222        * storage/indexeddb/resources/transaction-and-objectstore-calls.js:
     223        (created):
     224        (afterComplete):
     225        * storage/indexeddb/resources/transaction-basics.js:
     226        (addRemoveIDBObjects):
     227        (addRemoveAddIDBObjects):
     228        (addIDBObjects):
     229        (addIDBObjectsAndCommit):
     230        (removeIDBObjects):
     231        (setVersionSuccess):
     232        (testDOMStringList):
     233        * storage/indexeddb/resources/transaction-event-propagation.js:
     234        (deleteExisting):
     235        * storage/indexeddb/resources/transaction-rollback.js:
     236        (addSuccess):
     237        (getSuccess):
     238        * storage/indexeddb/resources/two-version-changes.js:
     239        (test):
     240        * storage/indexeddb/resources/values-odd-types.js:
     241        (openACursor.request.onsuccess):
     242        (openACursor):
     243        * storage/indexeddb/setVersion-null-expected.txt:
     244        * storage/indexeddb/transaction-abort-expected.txt:
     245        * storage/indexeddb/transaction-and-objectstore-calls-expected.txt:
     246        * storage/indexeddb/transaction-basics-expected.txt:
     247        * storage/indexeddb/transaction-event-propagation-expected.txt:
     248        * storage/indexeddb/transaction-rollback-expected.txt:
     249        * storage/indexeddb/two-version-changes-expected.txt:
     250        * storage/indexeddb/values-odd-types-expected.txt:
     251
    12522012-05-19  Raphael Kubo da Costa  <rakuco@webkit.org>
    2253

  • trunk/LayoutTests/storage/indexeddb/basics-expected.txt

    r116337 r117702  
    2424PASS request.transaction is null
    2525PASS 'readyState' in request is true
    26 PASS request.readyState is 'pending'
     26PASS request.readyState is "pending"
    2727PASS 'onsuccess' in request is true
    2828PASS request.onsuccess is null
    … …  
    4040PASS event.target.transaction is null
    4141PASS 'readyState' in request is true
    42 PASS event.target.readyState is 'done'
     42PASS event.target.readyState is "done"
    4343PASS 'onsuccess' in event.target is true
    4444PASS 'onerror' in event.target is true

  • trunk/LayoutTests/storage/indexeddb/basics-workers-expected.txt

    r116337 r117702  
    2525PASS [Worker] request.transaction is null
    2626PASS [Worker] 'readyState' in request is true
    27 PASS [Worker] request.readyState is 'pending'
     27PASS [Worker] request.readyState is "pending"
    2828PASS [Worker] 'onsuccess' in request is true
    2929PASS [Worker] request.onsuccess is null
    … …  
    4141PASS [Worker] event.target.transaction is null
    4242PASS [Worker] 'readyState' in request is true
    43 PASS [Worker] event.target.readyState is 'done'
     43PASS [Worker] event.target.readyState is "done"
    4444PASS [Worker] 'onsuccess' in event.target is true
    4545PASS [Worker] 'onerror' in event.target is true

  • trunk/LayoutTests/storage/indexeddb/create-object-store-options-expected.txt

    r116337 r117702  
    1414db.createObjectStore('c', {autoIncrement: true});
    1515trans = db.transaction(['a', 'b'], 'readwrite')
    16 PASS trans.mode is 'readwrite'
     16PASS trans.mode is "readwrite"
    1717trans.objectStore('a').put({'a': 0})
    1818Expecting TypeError exception from db.createObjectStore('d', 'bar');

  • trunk/LayoutTests/storage/indexeddb/createObjectStore-null-name-expected.txt

    r114672 r117702  
    1111Deleted all object stores.
    1212db.createObjectStore(null);
    13 PASS objectStore.name is 'null'
     13PASS objectStore.name is "null"
    1414PASS successfullyParsed is true
    1515

  • trunk/LayoutTests/storage/indexeddb/cursor-added-bug-expected.txt

    r116337 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414objectStore = db.createObjectStore('test')

  • trunk/LayoutTests/storage/indexeddb/cursor-continue-expected.txt

    r116337 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414db.createObjectStore('someObjectStore')

  • trunk/LayoutTests/storage/indexeddb/cursor-continue-validity-expected.txt

    r116337 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414db.createObjectStore('someObjectStore')

  • trunk/LayoutTests/storage/indexeddb/cursor-delete-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('test')

  • trunk/LayoutTests/storage/indexeddb/cursor-inconsistency-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('basicStore')
    … …  
    2525checkCursor()
    2626storedCursor = event.target.result
    27 PASS storedCursor === event.target.result is true
     27PASS storedCursor is event.target.result
    2828PASS storedCursor.key is "someKey1"
    2929PASS event.target.result.key is "someKey1"
    … …  
    3333
    3434checkCursor()
    35 PASS storedCursor === event.target.result is true
     35PASS storedCursor is event.target.result
    3636PASS storedCursor.key is "someKey2"
    3737PASS event.target.result.key is "someKey2"
    … …  
    4141
    4242checkCursor()
    43 PASS storedCursor === event.target.result is true
     43PASS storedCursor is event.target.result
    4444PASS storedCursor.key is "someKey3"
    4545PASS event.target.result.key is "someKey3"
    … …  
    4949
    5050checkCursor()
    51 PASS storedCursor === event.target.result is true
     51PASS storedCursor is event.target.result
    5252PASS storedCursor.key is "someKey4"
    5353PASS event.target.result.key is "someKey4"

  • trunk/LayoutTests/storage/indexeddb/cursor-index-delete-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('test')

  • trunk/LayoutTests/storage/indexeddb/cursor-key-order-expected.txt

    r116337 r117702  
    7474PASS compare(cursor.key, -Infinity) is true
    7575getreq = store.get(cursor.key)
    76 PASS getreq.result === count++ is true
     76PASS getreq.result is count++
    7777cursor = curreq.result
    7878PASS compare(cursor.key, -Number.MAX_VALUE) is true
    7979getreq = store.get(cursor.key)
    80 PASS getreq.result === count++ is true
     80PASS getreq.result is count++
    8181cursor = curreq.result
    8282PASS compare(cursor.key, -1) is true
    8383getreq = store.get(cursor.key)
    84 PASS getreq.result === count++ is true
     84PASS getreq.result is count++
    8585cursor = curreq.result
    8686PASS compare(cursor.key, -Number.MIN_VALUE) is true
    8787getreq = store.get(cursor.key)
    88 PASS getreq.result === count++ is true
     88PASS getreq.result is count++
    8989cursor = curreq.result
    9090PASS compare(cursor.key, 0) is true
    9191getreq = store.get(cursor.key)
    92 PASS getreq.result === count++ is true
     92PASS getreq.result is count++
    9393cursor = curreq.result
    9494PASS compare(cursor.key, Number.MIN_VALUE) is true
    9595getreq = store.get(cursor.key)
    96 PASS getreq.result === count++ is true
     96PASS getreq.result is count++
    9797cursor = curreq.result
    9898PASS compare(cursor.key, 1) is true
    9999getreq = store.get(cursor.key)
    100 PASS getreq.result === count++ is true
     100PASS getreq.result is count++
    101101cursor = curreq.result
    102102PASS compare(cursor.key, Number.MAX_VALUE) is true
    103103getreq = store.get(cursor.key)
    104 PASS getreq.result === count++ is true
     104PASS getreq.result is count++
    105105cursor = curreq.result
    106106PASS compare(cursor.key, Infinity) is true
    107107getreq = store.get(cursor.key)
    108 PASS getreq.result === count++ is true
     108PASS getreq.result is count++
    109109cursor = curreq.result
    110110PASS compare(cursor.key, new Date(0)) is true
    111111getreq = store.get(cursor.key)
    112 PASS getreq.result === count++ is true
     112PASS getreq.result is count++
    113113cursor = curreq.result
    114114PASS compare(cursor.key, new Date(1000)) is true
    115115getreq = store.get(cursor.key)
    116 PASS getreq.result === count++ is true
     116PASS getreq.result is count++
    117117cursor = curreq.result
    118118PASS compare(cursor.key, new Date(1317399931023)) is true
    119119getreq = store.get(cursor.key)
    120 PASS getreq.result === count++ is true
     120PASS getreq.result is count++
    121121cursor = curreq.result
    122122PASS compare(cursor.key, '') is true
    123123getreq = store.get(cursor.key)
    124 PASS getreq.result === count++ is true
     124PASS getreq.result is count++
    125125cursor = curreq.result
    126126PASS compare(cursor.key, '\0') is true
    127127getreq = store.get(cursor.key)
    128 PASS getreq.result === count++ is true
     128PASS getreq.result is count++
    129129cursor = curreq.result
    130130PASS compare(cursor.key, 'a') is true
    131131getreq = store.get(cursor.key)
    132 PASS getreq.result === count++ is true
     132PASS getreq.result is count++
    133133cursor = curreq.result
    134134PASS compare(cursor.key, 'aa') is true
    135135getreq = store.get(cursor.key)
    136 PASS getreq.result === count++ is true
     136PASS getreq.result is count++
    137137cursor = curreq.result
    138138PASS compare(cursor.key, 'b') is true
    139139getreq = store.get(cursor.key)
    140 PASS getreq.result === count++ is true
     140PASS getreq.result is count++
    141141cursor = curreq.result
    142142PASS compare(cursor.key, 'ba') is true
    143143getreq = store.get(cursor.key)
    144 PASS getreq.result === count++ is true
     144PASS getreq.result is count++
    145145cursor = curreq.result
    146146PASS compare(cursor.key, '¢') is true
    147147getreq = store.get(cursor.key)
    148 PASS getreq.result === count++ is true
     148PASS getreq.result is count++
    149149cursor = curreq.result
    150150PASS compare(cursor.key, '水') is true
    151151getreq = store.get(cursor.key)
    152 PASS getreq.result === count++ is true
     152PASS getreq.result is count++
    153153cursor = curreq.result
    154154PASS compare(cursor.key, '𝄞') is true
    155155getreq = store.get(cursor.key)
    156 PASS getreq.result === count++ is true
     156PASS getreq.result is count++
    157157cursor = curreq.result
    158158PASS compare(cursor.key, '�') is true
    159159getreq = store.get(cursor.key)
    160 PASS getreq.result === count++ is true
     160PASS getreq.result is count++
    161161cursor = curreq.result
    162162PASS compare(cursor.key, []) is true
    163163getreq = store.get(cursor.key)
    164 PASS getreq.result === count++ is true
     164PASS getreq.result is count++
    165165cursor = curreq.result
    166166PASS compare(cursor.key, [-Infinity]) is true
    167167getreq = store.get(cursor.key)
    168 PASS getreq.result === count++ is true
     168PASS getreq.result is count++
    169169cursor = curreq.result
    170170PASS compare(cursor.key, [-Number.MAX_VALUE]) is true
    171171getreq = store.get(cursor.key)
    172 PASS getreq.result === count++ is true
     172PASS getreq.result is count++
    173173cursor = curreq.result
    174174PASS compare(cursor.key, [-1]) is true
    175175getreq = store.get(cursor.key)
    176 PASS getreq.result === count++ is true
     176PASS getreq.result is count++
    177177cursor = curreq.result
    178178PASS compare(cursor.key, [-Number.MIN_VALUE]) is true
    179179getreq = store.get(cursor.key)
    180 PASS getreq.result === count++ is true
     180PASS getreq.result is count++
    181181cursor = curreq.result
    182182PASS compare(cursor.key, [0]) is true
    183183getreq = store.get(cursor.key)
    184 PASS getreq.result === count++ is true
     184PASS getreq.result is count++
    185185cursor = curreq.result
    186186PASS compare(cursor.key, [Number.MIN_VALUE]) is true
    187187getreq = store.get(cursor.key)
    188 PASS getreq.result === count++ is true
     188PASS getreq.result is count++
    189189cursor = curreq.result
    190190PASS compare(cursor.key, [1]) is true
    191191getreq = store.get(cursor.key)
    192 PASS getreq.result === count++ is true
     192PASS getreq.result is count++
    193193cursor = curreq.result
    194194PASS compare(cursor.key, [Number.MAX_VALUE]) is true
    195195getreq = store.get(cursor.key)
    196 PASS getreq.result === count++ is true
     196PASS getreq.result is count++
    197197cursor = curreq.result
    198198PASS compare(cursor.key, [Infinity]) is true
    199199getreq = store.get(cursor.key)
    200 PASS getreq.result === count++ is true
     200PASS getreq.result is count++
    201201cursor = curreq.result
    202202PASS compare(cursor.key, [new Date(0)]) is true
    203203getreq = store.get(cursor.key)
    204 PASS getreq.result === count++ is true
     204PASS getreq.result is count++
    205205cursor = curreq.result
    206206PASS compare(cursor.key, [new Date(1000)]) is true
    207207getreq = store.get(cursor.key)
    208 PASS getreq.result === count++ is true
     208PASS getreq.result is count++
    209209cursor = curreq.result
    210210PASS compare(cursor.key, [new Date(1317399931023)]) is true
    211211getreq = store.get(cursor.key)
    212 PASS getreq.result === count++ is true
     212PASS getreq.result is count++
    213213cursor = curreq.result
    214214PASS compare(cursor.key, ['']) is true
    215215getreq = store.get(cursor.key)
    216 PASS getreq.result === count++ is true
     216PASS getreq.result is count++
    217217cursor = curreq.result
    218218PASS compare(cursor.key, ['\0']) is true
    219219getreq = store.get(cursor.key)
    220 PASS getreq.result === count++ is true
     220PASS getreq.result is count++
    221221cursor = curreq.result
    222222PASS compare(cursor.key, ['a']) is true
    223223getreq = store.get(cursor.key)
    224 PASS getreq.result === count++ is true
     224PASS getreq.result is count++
    225225cursor = curreq.result
    226226PASS compare(cursor.key, ['aa']) is true
    227227getreq = store.get(cursor.key)
    228 PASS getreq.result === count++ is true
     228PASS getreq.result is count++
    229229cursor = curreq.result
    230230PASS compare(cursor.key, ['b']) is true
    231231getreq = store.get(cursor.key)
    232 PASS getreq.result === count++ is true
     232PASS getreq.result is count++
    233233cursor = curreq.result
    234234PASS compare(cursor.key, ['ba']) is true
    235235getreq = store.get(cursor.key)
    236 PASS getreq.result === count++ is true
     236PASS getreq.result is count++
    237237cursor = curreq.result
    238238PASS compare(cursor.key, ['¢']) is true
    239239getreq = store.get(cursor.key)
    240 PASS getreq.result === count++ is true
     240PASS getreq.result is count++
    241241cursor = curreq.result
    242242PASS compare(cursor.key, ['水']) is true
    243243getreq = store.get(cursor.key)
    244 PASS getreq.result === count++ is true
     244PASS getreq.result is count++
    245245cursor = curreq.result
    246246PASS compare(cursor.key, ['𝄞']) is true
    247247getreq = store.get(cursor.key)
    248 PASS getreq.result === count++ is true
     248PASS getreq.result is count++
    249249cursor = curreq.result
    250250PASS compare(cursor.key, ['�']) is true
    251251getreq = store.get(cursor.key)
    252 PASS getreq.result === count++ is true
     252PASS getreq.result is count++
    253253cursor = curreq.result
    254254PASS compare(cursor.key, [[]]) is true
    255255getreq = store.get(cursor.key)
    256 PASS getreq.result === count++ is true
     256PASS getreq.result is count++
    257257cursor = curreq.result
    258258PASS compare(cursor.key, [[], []]) is true
    259259getreq = store.get(cursor.key)
    260 PASS getreq.result === count++ is true
     260PASS getreq.result is count++
    261261cursor = curreq.result
    262262PASS compare(cursor.key, [[], [], []]) is true
    263263getreq = store.get(cursor.key)
    264 PASS getreq.result === count++ is true
     264PASS getreq.result is count++
    265265cursor = curreq.result
    266266PASS compare(cursor.key, [[[]]]) is true
    267267getreq = store.get(cursor.key)
    268 PASS getreq.result === count++ is true
     268PASS getreq.result is count++
    269269cursor = curreq.result
    270270PASS compare(cursor.key, [[[[]]]]) is true
    271271getreq = store.get(cursor.key)
    272 PASS getreq.result === count++ is true
    273 PASS count === keys.length is true
     272PASS getreq.result is count++
     273PASS count is keys.length
    274274
    275275validate compare function

  • trunk/LayoutTests/storage/indexeddb/cursor-primary-key-order-expected.txt

    r116337 r117702  
    8787PASS cursor.key is 0
    8888PASS cursor.primaryKey is 'c'
    89 PASS count === keys.length is true
     89PASS count is keys.length
    9090PASS successfullyParsed is true
    9191

  • trunk/LayoutTests/storage/indexeddb/cursor-skip-deleted-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('store', {keyPath: 'id'})

  • trunk/LayoutTests/storage/indexeddb/cursor-update-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('basicStore')
    … …  
    159159PASS event.target.result.key is counter + 100
    160160PASS event.target.result.primaryKey is counter
    161 event.target.result.update({id: counter, number: counter + 200})
     161Expecting exception from event.target.result.update({id: counter, number: counter + 200})
     162PASS Exception was thrown.
    162163PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
    163164keyCursor()
    164165PASS event.target.result.key is counter + 100
    165166PASS event.target.result.primaryKey is counter
    166 event.target.result.update({id: counter, number: counter + 200})
     167Expecting exception from event.target.result.update({id: counter, number: counter + 200})
     168PASS Exception was thrown.
    167169PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
    168170keyCursor()
    169171PASS event.target.result.key is counter + 100
    170172PASS event.target.result.primaryKey is counter
    171 event.target.result.update({id: counter, number: counter + 200})
     173Expecting exception from event.target.result.update({id: counter, number: counter + 200})
     174PASS Exception was thrown.
    172175PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
    173176keyCursor()
    174177PASS event.target.result.key is counter + 100
    175178PASS event.target.result.primaryKey is counter
    176 event.target.result.update({id: counter, number: counter + 200})
     179Expecting exception from event.target.result.update({id: counter, number: counter + 200})
     180PASS Exception was thrown.
    177181PASS code is IDBDatabaseException.NOT_ALLOWED_ERR
    178182keyCursor()

  • trunk/LayoutTests/storage/indexeddb/data-corruption-expected.txt

    r116337 r117702  
    1212setVersionSuccess():
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616db.createObjectStore('storeName')
    … …  
    2121transaction = db.transaction(['storeName'], 'readonly')
    2222request = transaction.objectStore('storeName').get('key')
    23 PASS event.target.result.x.toString() == testDate.toString() is true
     23PASS event.target.result.x.toString() is testDate.toString()
    2424PASS successfullyParsed is true
    2525

  • trunk/LayoutTests/storage/indexeddb/database-basics-expected.txt

    r112490 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515Testing setVersion.
    … …  
    3939db.createObjectStore("test456")
    4040setVersionTrans = event.target.result
    41 PASS setVersionTrans !== null is true
     41PASS setVersionTrans is non-null.
    4242PASS db.version is "version b"
    4343PASS db.objectStoreNames is ['test123']

  • trunk/LayoutTests/storage/indexeddb/duplicates-expected.txt

    r112490 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515db.createObjectStore('storeName', null)
    … …  
    2727PASS event.target.result is undefined
    2828indexObject.openKeyCursor()
    29 PASS event.target.result === null is false
     29PASS event.target.result is non-null.
    3030PASS event.target.result.key is "value"
    3131PASS event.target.result.primaryKey is "key"
    3232event.target.result.continue()
    33 PASS event.target.result === null is false
     33PASS event.target.result is non-null.
    3434PASS event.target.result.key is "value2"
    3535PASS event.target.result.primaryKey is "key2"
    3636event.target.result.continue()
    37 PASS event.target.result === null is true
     37PASS event.target.result is null
    3838indexObject.openCursor()
    39 PASS event.target.result === null is false
     39PASS event.target.result is non-null.
    4040PASS event.target.result.key is "value"
    4141PASS event.target.result.value.x is "value"
    4242PASS event.target.result.value.y is "zzz"
    4343event.target.result.continue()
    44 PASS event.target.result === null is false
     44PASS event.target.result is non-null.
    4545PASS event.target.result.key is "value2"
    4646PASS event.target.result.value.x is "value2"
    4747PASS event.target.result.value.y is "zzz2"
    4848event.target.result.continue()
    49 PASS event.target.result === null is true
     49PASS event.target.result is null
    5050indexedDB.open('duplicates-2')
    5151db = event.target.result
    … …  
    5353setVersionSuccess():
    5454trans = event.target.result
    55 PASS trans !== null is true
     55PASS trans is non-null.
    5656Deleted all object stores.
    5757db.createObjectStore('storeName', null)
    … …  
    6969PASS event.target.result is undefined
    7070indexObject.openKeyCursor()
    71 PASS event.target.result === null is false
     71PASS event.target.result is non-null.
    7272PASS event.target.result.key is "value"
    7373PASS event.target.result.primaryKey is "key"
    7474event.target.result.continue()
    75 PASS event.target.result === null is false
     75PASS event.target.result is non-null.
    7676PASS event.target.result.key is "value2"
    7777PASS event.target.result.primaryKey is "key2"
    7878event.target.result.continue()
    79 PASS event.target.result === null is true
     79PASS event.target.result is null
    8080indexObject.openCursor()
    81 PASS event.target.result === null is false
     81PASS event.target.result is non-null.
    8282PASS event.target.result.key is "value"
    8383PASS event.target.result.value.x is "value"
    8484PASS event.target.result.value.y is "zzz"
    8585event.target.result.continue()
    86 PASS event.target.result === null is false
     86PASS event.target.result is non-null.
    8787PASS event.target.result.key is "value2"
    8888PASS event.target.result.value.x is "value2"
    8989PASS event.target.result.value.y is "zzz2"
    9090event.target.result.continue()
    91 PASS event.target.result === null is true
     91PASS event.target.result is null
    9292PASS successfullyParsed is true
    9393

  • trunk/LayoutTests/storage/indexeddb/error-causes-abort-by-default-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414trans.oncomplete = addData
    1515Deleted all object stores.

  • trunk/LayoutTests/storage/indexeddb/exception-in-event-aborts-expected.txt

    r116337 r117702  
    1313setVersionSuccess():
    1414trans = event.target.result
    15 PASS trans !== null is true
     15PASS trans is non-null.
    1616trans.oncomplete = startTest
    1717Deleted all object stores.

  • trunk/LayoutTests/storage/indexeddb/factory-basics-expected.txt

    r114672 r117702  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 PASS typeof indexedDB.open === 'function' is true
    9 PASS typeof indexedDB.cmp === 'function' is true
    10 PASS typeof indexedDB.getDatabaseNames === 'function' is true
    11 PASS typeof indexedDB.deleteDatabase === 'function' is true
     8PASS typeof indexedDB.open is "function"
     9PASS typeof indexedDB.cmp is "function"
     10PASS typeof indexedDB.getDatabaseNames is "function"
     11PASS typeof indexedDB.deleteDatabase is "function"
    1212indexedDB.getDatabaseNames()
    1313databaseNames = event.target.result

  • trunk/LayoutTests/storage/indexeddb/factory-cmp-expected.txt

    r112490 r117702  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 PASS typeof indexedDB.cmp === 'function' is true
     8PASS typeof indexedDB.cmp is "function"
    99
    1010compare valid keys
    11 PASS indexedDB.cmp(-Infinity,-Number.MAX_VALUE) === -1 is true
    12 PASS indexedDB.cmp(-Number.MAX_VALUE,-Infinity) === 1 is true
    13 PASS indexedDB.cmp(-Infinity,-Infinity) === 0 is true
    14 PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) === 0 is true
    15 PASS indexedDB.cmp(-Number.MAX_VALUE,-1) === -1 is true
    16 PASS indexedDB.cmp(-1,-Number.MAX_VALUE) === 1 is true
    17 PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) === 0 is true
    18 PASS indexedDB.cmp(-1,-1) === 0 is true
    19 PASS indexedDB.cmp(-1,-Number.MIN_VALUE) === -1 is true
    20 PASS indexedDB.cmp(-Number.MIN_VALUE,-1) === 1 is true
    21 PASS indexedDB.cmp(-1,-1) === 0 is true
    22 PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) === 0 is true
    23 PASS indexedDB.cmp(-Number.MIN_VALUE,0) === -1 is true
    24 PASS indexedDB.cmp(0,-Number.MIN_VALUE) === 1 is true
    25 PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) === 0 is true
    26 PASS indexedDB.cmp(0,0) === 0 is true
    27 PASS indexedDB.cmp(0,Number.MIN_VALUE) === -1 is true
    28 PASS indexedDB.cmp(Number.MIN_VALUE,0) === 1 is true
    29 PASS indexedDB.cmp(0,0) === 0 is true
    30 PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) === 0 is true
    31 PASS indexedDB.cmp(Number.MIN_VALUE,1) === -1 is true
    32 PASS indexedDB.cmp(1,Number.MIN_VALUE) === 1 is true
    33 PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) === 0 is true
    34 PASS indexedDB.cmp(1,1) === 0 is true
    35 PASS indexedDB.cmp(1,Number.MAX_VALUE) === -1 is true
    36 PASS indexedDB.cmp(Number.MAX_VALUE,1) === 1 is true
    37 PASS indexedDB.cmp(1,1) === 0 is true
    38 PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) === 0 is true
    39 PASS indexedDB.cmp(Number.MAX_VALUE,Infinity) === -1 is true
    40 PASS indexedDB.cmp(Infinity,Number.MAX_VALUE) === 1 is true
    41 PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) === 0 is true
    42 PASS indexedDB.cmp(Infinity,Infinity) === 0 is true
    43 PASS indexedDB.cmp(Infinity,new Date(0)) === -1 is true
    44 PASS indexedDB.cmp(new Date(0),Infinity) === 1 is true
    45 PASS indexedDB.cmp(Infinity,Infinity) === 0 is true
    46 PASS indexedDB.cmp(new Date(0),new Date(0)) === 0 is true
    47 PASS indexedDB.cmp(new Date(0),new Date(1000)) === -1 is true
    48 PASS indexedDB.cmp(new Date(1000),new Date(0)) === 1 is true
    49 PASS indexedDB.cmp(new Date(0),new Date(0)) === 0 is true
    50 PASS indexedDB.cmp(new Date(1000),new Date(1000)) === 0 is true
    51 PASS indexedDB.cmp(new Date(1000),new Date(1317399931023)) === -1 is true
    52 PASS indexedDB.cmp(new Date(1317399931023),new Date(1000)) === 1 is true
    53 PASS indexedDB.cmp(new Date(1000),new Date(1000)) === 0 is true
    54 PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) === 0 is true
    55 PASS indexedDB.cmp(new Date(1317399931023),'') === -1 is true
    56 PASS indexedDB.cmp('',new Date(1317399931023)) === 1 is true
    57 PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) === 0 is true
    58 PASS indexedDB.cmp('','') === 0 is true
    59 PASS indexedDB.cmp('','\0') === -1 is true
    60 PASS indexedDB.cmp('\0','') === 1 is true
    61 PASS indexedDB.cmp('','') === 0 is true
    62 PASS indexedDB.cmp('\0','\0') === 0 is true
    63 PASS indexedDB.cmp('\0','a') === -1 is true
    64 PASS indexedDB.cmp('a','\0') === 1 is true
    65 PASS indexedDB.cmp('\0','\0') === 0 is true
    66 PASS indexedDB.cmp('a','a') === 0 is true
    67 PASS indexedDB.cmp('a','aa') === -1 is true
    68 PASS indexedDB.cmp('aa','a') === 1 is true
    69 PASS indexedDB.cmp('a','a') === 0 is true
    70 PASS indexedDB.cmp('aa','aa') === 0 is true
    71 PASS indexedDB.cmp('aa','b') === -1 is true
    72 PASS indexedDB.cmp('b','aa') === 1 is true
    73 PASS indexedDB.cmp('aa','aa') === 0 is true
    74 PASS indexedDB.cmp('b','b') === 0 is true
    75 PASS indexedDB.cmp('b','ba') === -1 is true
    76 PASS indexedDB.cmp('ba','b') === 1 is true
    77 PASS indexedDB.cmp('b','b') === 0 is true
    78 PASS indexedDB.cmp('ba','ba') === 0 is true
    79 PASS indexedDB.cmp('ba','¢') === -1 is true
    80 PASS indexedDB.cmp('¢','ba') === 1 is true
    81 PASS indexedDB.cmp('ba','ba') === 0 is true
    82 PASS indexedDB.cmp('¢','¢') === 0 is true
    83 PASS indexedDB.cmp('¢','水') === -1 is true
    84 PASS indexedDB.cmp('水','¢') === 1 is true
    85 PASS indexedDB.cmp('¢','¢') === 0 is true
    86 PASS indexedDB.cmp('水','水') === 0 is true
    87 PASS indexedDB.cmp('水','𝄞') === -1 is true
    88 PASS indexedDB.cmp('𝄞','水') === 1 is true
    89 PASS indexedDB.cmp('水','水') === 0 is true
    90 PASS indexedDB.cmp('𝄞','𝄞') === 0 is true
    91 PASS indexedDB.cmp('𝄞','�') === -1 is true
    92 PASS indexedDB.cmp('�','𝄞') === 1 is true
    93 PASS indexedDB.cmp('𝄞','𝄞') === 0 is true
    94 PASS indexedDB.cmp('�','�') === 0 is true
    95 PASS indexedDB.cmp('�',[]) === -1 is true
    96 PASS indexedDB.cmp([],'�') === 1 is true
    97 PASS indexedDB.cmp('�','�') === 0 is true
    98 PASS indexedDB.cmp([],[]) === 0 is true
    99 PASS indexedDB.cmp([],[-Infinity]) === -1 is true
    100 PASS indexedDB.cmp([-Infinity],[]) === 1 is true
    101 PASS indexedDB.cmp([],[]) === 0 is true
    102 PASS indexedDB.cmp([-Infinity],[-Infinity]) === 0 is true
    103 PASS indexedDB.cmp([-Infinity],[-Number.MAX_VALUE]) === -1 is true
    104 PASS indexedDB.cmp([-Number.MAX_VALUE],[-Infinity]) === 1 is true
    105 PASS indexedDB.cmp([-Infinity],[-Infinity]) === 0 is true
    106 PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) === 0 is true
    107 PASS indexedDB.cmp([-Number.MAX_VALUE],[-1]) === -1 is true
    108 PASS indexedDB.cmp([-1],[-Number.MAX_VALUE]) === 1 is true
    109 PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) === 0 is true
    110 PASS indexedDB.cmp([-1],[-1]) === 0 is true
    111 PASS indexedDB.cmp([-1],[-Number.MIN_VALUE]) === -1 is true
    112 PASS indexedDB.cmp([-Number.MIN_VALUE],[-1]) === 1 is true
    113 PASS indexedDB.cmp([-1],[-1]) === 0 is true
    114 PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) === 0 is true
    115 PASS indexedDB.cmp([-Number.MIN_VALUE],[0]) === -1 is true
    116 PASS indexedDB.cmp([0],[-Number.MIN_VALUE]) === 1 is true
    117 PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) === 0 is true
    118 PASS indexedDB.cmp([0],[0]) === 0 is true
    119 PASS indexedDB.cmp([0],[Number.MIN_VALUE]) === -1 is true
    120 PASS indexedDB.cmp([Number.MIN_VALUE],[0]) === 1 is true
    121 PASS indexedDB.cmp([0],[0]) === 0 is true
    122 PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) === 0 is true
    123 PASS indexedDB.cmp([Number.MIN_VALUE],[1]) === -1 is true
    124 PASS indexedDB.cmp([1],[Number.MIN_VALUE]) === 1 is true
    125 PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) === 0 is true
    126 PASS indexedDB.cmp([1],[1]) === 0 is true
    127 PASS indexedDB.cmp([1],[Number.MAX_VALUE]) === -1 is true
    128 PASS indexedDB.cmp([Number.MAX_VALUE],[1]) === 1 is true
    129 PASS indexedDB.cmp([1],[1]) === 0 is true
    130 PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) === 0 is true
    131 PASS indexedDB.cmp([Number.MAX_VALUE],[Infinity]) === -1 is true
    132 PASS indexedDB.cmp([Infinity],[Number.MAX_VALUE]) === 1 is true
    133 PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) === 0 is true
    134 PASS indexedDB.cmp([Infinity],[Infinity]) === 0 is true
    135 PASS indexedDB.cmp([Infinity],[new Date(0)]) === -1 is true
    136 PASS indexedDB.cmp([new Date(0)],[Infinity]) === 1 is true
    137 PASS indexedDB.cmp([Infinity],[Infinity]) === 0 is true
    138 PASS indexedDB.cmp([new Date(0)],[new Date(0)]) === 0 is true
    139 PASS indexedDB.cmp([new Date(0)],[new Date(1000)]) === -1 is true
    140 PASS indexedDB.cmp([new Date(1000)],[new Date(0)]) === 1 is true
    141 PASS indexedDB.cmp([new Date(0)],[new Date(0)]) === 0 is true
    142 PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) === 0 is true
    143 PASS indexedDB.cmp([new Date(1000)],[new Date(1317399931023)]) === -1 is true
    144 PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1000)]) === 1 is true
    145 PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) === 0 is true
    146 PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) === 0 is true
    147 PASS indexedDB.cmp([new Date(1317399931023)],['']) === -1 is true
    148 PASS indexedDB.cmp([''],[new Date(1317399931023)]) === 1 is true
    149 PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) === 0 is true
    150 PASS indexedDB.cmp([''],['']) === 0 is true
    151 PASS indexedDB.cmp([''],['\0']) === -1 is true
    152 PASS indexedDB.cmp(['\0'],['']) === 1 is true
    153 PASS indexedDB.cmp([''],['']) === 0 is true
    154 PASS indexedDB.cmp(['\0'],['\0']) === 0 is true
    155 PASS indexedDB.cmp(['\0'],['a']) === -1 is true
    156 PASS indexedDB.cmp(['a'],['\0']) === 1 is true
    157 PASS indexedDB.cmp(['\0'],['\0']) === 0 is true
    158 PASS indexedDB.cmp(['a'],['a']) === 0 is true
    159 PASS indexedDB.cmp(['a'],['aa']) === -1 is true
    160 PASS indexedDB.cmp(['aa'],['a']) === 1 is true
    161 PASS indexedDB.cmp(['a'],['a']) === 0 is true
    162 PASS indexedDB.cmp(['aa'],['aa']) === 0 is true
    163 PASS indexedDB.cmp(['aa'],['b']) === -1 is true
    164 PASS indexedDB.cmp(['b'],['aa']) === 1 is true
    165 PASS indexedDB.cmp(['aa'],['aa']) === 0 is true
    166 PASS indexedDB.cmp(['b'],['b']) === 0 is true
    167 PASS indexedDB.cmp(['b'],['ba']) === -1 is true
    168 PASS indexedDB.cmp(['ba'],['b']) === 1 is true
    169 PASS indexedDB.cmp(['b'],['b']) === 0 is true
    170 PASS indexedDB.cmp(['ba'],['ba']) === 0 is true
    171 PASS indexedDB.cmp(['ba'],['¢']) === -1 is true
    172 PASS indexedDB.cmp(['¢'],['ba']) === 1 is true
    173 PASS indexedDB.cmp(['ba'],['ba']) === 0 is true
    174 PASS indexedDB.cmp(['¢'],['¢']) === 0 is true
    175 PASS indexedDB.cmp(['¢'],['水']) === -1 is true
    176 PASS indexedDB.cmp(['水'],['¢']) === 1 is true
    177 PASS indexedDB.cmp(['¢'],['¢']) === 0 is true
    178 PASS indexedDB.cmp(['水'],['水']) === 0 is true
    179 PASS indexedDB.cmp(['水'],['𝄞']) === -1 is true
    180 PASS indexedDB.cmp(['𝄞'],['水']) === 1 is true
    181 PASS indexedDB.cmp(['水'],['水']) === 0 is true
    182 PASS indexedDB.cmp(['𝄞'],['𝄞']) === 0 is true
    183 PASS indexedDB.cmp(['𝄞'],['�']) === -1 is true
    184 PASS indexedDB.cmp(['�'],['𝄞']) === 1 is true
    185 PASS indexedDB.cmp(['𝄞'],['𝄞']) === 0 is true
    186 PASS indexedDB.cmp(['�'],['�']) === 0 is true
    187 PASS indexedDB.cmp(['�'],[[]]) === -1 is true
    188 PASS indexedDB.cmp([[]],['�']) === 1 is true
    189 PASS indexedDB.cmp(['�'],['�']) === 0 is true
    190 PASS indexedDB.cmp([[]],[[]]) === 0 is true
    191 PASS indexedDB.cmp([[]],[[], []]) === -1 is true
    192 PASS indexedDB.cmp([[], []],[[]]) === 1 is true
    193 PASS indexedDB.cmp([[]],[[]]) === 0 is true
    194 PASS indexedDB.cmp([[], []],[[], []]) === 0 is true
    195 PASS indexedDB.cmp([[], []],[[], [], []]) === -1 is true
    196 PASS indexedDB.cmp([[], [], []],[[], []]) === 1 is true
    197 PASS indexedDB.cmp([[], []],[[], []]) === 0 is true
    198 PASS indexedDB.cmp([[], [], []],[[], [], []]) === 0 is true
    199 PASS indexedDB.cmp([[], [], []],[[[]]]) === -1 is true
    200 PASS indexedDB.cmp([[[]]],[[], [], []]) === 1 is true
    201 PASS indexedDB.cmp([[], [], []],[[], [], []]) === 0 is true
    202 PASS indexedDB.cmp([[[]]],[[[]]]) === 0 is true
    203 PASS indexedDB.cmp([[[]]],[[[[]]]]) === -1 is true
    204 PASS indexedDB.cmp([[[[]]]],[[[]]]) === 1 is true
    205 PASS indexedDB.cmp([[[]]],[[[]]]) === 0 is true
    206 PASS indexedDB.cmp([[[[]]]],[[[[]]]]) === 0 is true
     11PASS indexedDB.cmp(-Infinity,-Number.MAX_VALUE) is -1
     12PASS indexedDB.cmp(-Number.MAX_VALUE,-Infinity) is 1
     13PASS indexedDB.cmp(-Infinity,-Infinity) is 0
     14PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) is 0
     15PASS indexedDB.cmp(-Number.MAX_VALUE,-1) is -1
     16PASS indexedDB.cmp(-1,-Number.MAX_VALUE) is 1
     17PASS indexedDB.cmp(-Number.MAX_VALUE,-Number.MAX_VALUE) is 0
     18PASS indexedDB.cmp(-1,-1) is 0
     19PASS indexedDB.cmp(-1,-Number.MIN_VALUE) is -1
     20PASS indexedDB.cmp(-Number.MIN_VALUE,-1) is 1
     21PASS indexedDB.cmp(-1,-1) is 0
     22PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) is 0
     23PASS indexedDB.cmp(-Number.MIN_VALUE,0) is -1
     24PASS indexedDB.cmp(0,-Number.MIN_VALUE) is 1
     25PASS indexedDB.cmp(-Number.MIN_VALUE,-Number.MIN_VALUE) is 0
     26PASS indexedDB.cmp(0,0) is 0
     27PASS indexedDB.cmp(0,Number.MIN_VALUE) is -1
     28PASS indexedDB.cmp(Number.MIN_VALUE,0) is 1
     29PASS indexedDB.cmp(0,0) is 0
     30PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) is 0
     31PASS indexedDB.cmp(Number.MIN_VALUE,1) is -1
     32PASS indexedDB.cmp(1,Number.MIN_VALUE) is 1
     33PASS indexedDB.cmp(Number.MIN_VALUE,Number.MIN_VALUE) is 0
     34PASS indexedDB.cmp(1,1) is 0
     35PASS indexedDB.cmp(1,Number.MAX_VALUE) is -1
     36PASS indexedDB.cmp(Number.MAX_VALUE,1) is 1
     37PASS indexedDB.cmp(1,1) is 0
     38PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) is 0
     39PASS indexedDB.cmp(Number.MAX_VALUE,Infinity) is -1
     40PASS indexedDB.cmp(Infinity,Number.MAX_VALUE) is 1
     41PASS indexedDB.cmp(Number.MAX_VALUE,Number.MAX_VALUE) is 0
     42PASS indexedDB.cmp(Infinity,Infinity) is 0
     43PASS indexedDB.cmp(Infinity,new Date(0)) is -1
     44PASS indexedDB.cmp(new Date(0),Infinity) is 1
     45PASS indexedDB.cmp(Infinity,Infinity) is 0
     46PASS indexedDB.cmp(new Date(0),new Date(0)) is 0
     47PASS indexedDB.cmp(new Date(0),new Date(1000)) is -1
     48PASS indexedDB.cmp(new Date(1000),new Date(0)) is 1
     49PASS indexedDB.cmp(new Date(0),new Date(0)) is 0
     50PASS indexedDB.cmp(new Date(1000),new Date(1000)) is 0
     51PASS indexedDB.cmp(new Date(1000),new Date(1317399931023)) is -1
     52PASS indexedDB.cmp(new Date(1317399931023),new Date(1000)) is 1
     53PASS indexedDB.cmp(new Date(1000),new Date(1000)) is 0
     54PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) is 0
     55PASS indexedDB.cmp(new Date(1317399931023),'') is -1
     56PASS indexedDB.cmp('',new Date(1317399931023)) is 1
     57PASS indexedDB.cmp(new Date(1317399931023),new Date(1317399931023)) is 0
     58PASS indexedDB.cmp('','') is 0
     59PASS indexedDB.cmp('','\0') is -1
     60PASS indexedDB.cmp('\0','') is 1
     61PASS indexedDB.cmp('','') is 0
     62PASS indexedDB.cmp('\0','\0') is 0
     63PASS indexedDB.cmp('\0','a') is -1
     64PASS indexedDB.cmp('a','\0') is 1
     65PASS indexedDB.cmp('\0','\0') is 0
     66PASS indexedDB.cmp('a','a') is 0
     67PASS indexedDB.cmp('a','aa') is -1
     68PASS indexedDB.cmp('aa','a') is 1
     69PASS indexedDB.cmp('a','a') is 0
     70PASS indexedDB.cmp('aa','aa') is 0
     71PASS indexedDB.cmp('aa','b') is -1
     72PASS indexedDB.cmp('b','aa') is 1
     73PASS indexedDB.cmp('aa','aa') is 0
     74PASS indexedDB.cmp('b','b') is 0
     75PASS indexedDB.cmp('b','ba') is -1
     76PASS indexedDB.cmp('ba','b') is 1
     77PASS indexedDB.cmp('b','b') is 0
     78PASS indexedDB.cmp('ba','ba') is 0
     79PASS indexedDB.cmp('ba','¢') is -1
     80PASS indexedDB.cmp('¢','ba') is 1
     81PASS indexedDB.cmp('ba','ba') is 0
     82PASS indexedDB.cmp('¢','¢') is 0
     83PASS indexedDB.cmp('¢','水') is -1
     84PASS indexedDB.cmp('水','¢') is 1
     85PASS indexedDB.cmp('¢','¢') is 0
     86PASS indexedDB.cmp('水','水') is 0
     87PASS indexedDB.cmp('水','𝄞') is -1
     88PASS indexedDB.cmp('𝄞','水') is 1
     89PASS indexedDB.cmp('水','水') is 0
     90PASS indexedDB.cmp('𝄞','𝄞') is 0
     91PASS indexedDB.cmp('𝄞','�') is -1
     92PASS indexedDB.cmp('�','𝄞') is 1
     93PASS indexedDB.cmp('𝄞','𝄞') is 0
     94PASS indexedDB.cmp('�','�') is 0
     95PASS indexedDB.cmp('�',[]) is -1
     96PASS indexedDB.cmp([],'�') is 1
     97PASS indexedDB.cmp('�','�') is 0
     98PASS indexedDB.cmp([],[]) is 0
     99PASS indexedDB.cmp([],[-Infinity]) is -1
     100PASS indexedDB.cmp([-Infinity],[]) is 1
     101PASS indexedDB.cmp([],[]) is 0
     102PASS indexedDB.cmp([-Infinity],[-Infinity]) is 0
     103PASS indexedDB.cmp([-Infinity],[-Number.MAX_VALUE]) is -1
     104PASS indexedDB.cmp([-Number.MAX_VALUE],[-Infinity]) is 1
     105PASS indexedDB.cmp([-Infinity],[-Infinity]) is 0
     106PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) is 0
     107PASS indexedDB.cmp([-Number.MAX_VALUE],[-1]) is -1
     108PASS indexedDB.cmp([-1],[-Number.MAX_VALUE]) is 1
     109PASS indexedDB.cmp([-Number.MAX_VALUE],[-Number.MAX_VALUE]) is 0
     110PASS indexedDB.cmp([-1],[-1]) is 0
     111PASS indexedDB.cmp([-1],[-Number.MIN_VALUE]) is -1
     112PASS indexedDB.cmp([-Number.MIN_VALUE],[-1]) is 1
     113PASS indexedDB.cmp([-1],[-1]) is 0
     114PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) is 0
     115PASS indexedDB.cmp([-Number.MIN_VALUE],[0]) is -1
     116PASS indexedDB.cmp([0],[-Number.MIN_VALUE]) is 1
     117PASS indexedDB.cmp([-Number.MIN_VALUE],[-Number.MIN_VALUE]) is 0
     118PASS indexedDB.cmp([0],[0]) is 0
     119PASS indexedDB.cmp([0],[Number.MIN_VALUE]) is -1
     120PASS indexedDB.cmp([Number.MIN_VALUE],[0]) is 1
     121PASS indexedDB.cmp([0],[0]) is 0
     122PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) is 0
     123PASS indexedDB.cmp([Number.MIN_VALUE],[1]) is -1
     124PASS indexedDB.cmp([1],[Number.MIN_VALUE]) is 1
     125PASS indexedDB.cmp([Number.MIN_VALUE],[Number.MIN_VALUE]) is 0
     126PASS indexedDB.cmp([1],[1]) is 0
     127PASS indexedDB.cmp([1],[Number.MAX_VALUE]) is -1
     128PASS indexedDB.cmp([Number.MAX_VALUE],[1]) is 1
     129PASS indexedDB.cmp([1],[1]) is 0
     130PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) is 0
     131PASS indexedDB.cmp([Number.MAX_VALUE],[Infinity]) is -1
     132PASS indexedDB.cmp([Infinity],[Number.MAX_VALUE]) is 1
     133PASS indexedDB.cmp([Number.MAX_VALUE],[Number.MAX_VALUE]) is 0
     134PASS indexedDB.cmp([Infinity],[Infinity]) is 0
     135PASS indexedDB.cmp([Infinity],[new Date(0)]) is -1
     136PASS indexedDB.cmp([new Date(0)],[Infinity]) is 1
     137PASS indexedDB.cmp([Infinity],[Infinity]) is 0
     138PASS indexedDB.cmp([new Date(0)],[new Date(0)]) is 0
     139PASS indexedDB.cmp([new Date(0)],[new Date(1000)]) is -1
     140PASS indexedDB.cmp([new Date(1000)],[new Date(0)]) is 1
     141PASS indexedDB.cmp([new Date(0)],[new Date(0)]) is 0
     142PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) is 0
     143PASS indexedDB.cmp([new Date(1000)],[new Date(1317399931023)]) is -1
     144PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1000)]) is 1
     145PASS indexedDB.cmp([new Date(1000)],[new Date(1000)]) is 0
     146PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) is 0
     147PASS indexedDB.cmp([new Date(1317399931023)],['']) is -1
     148PASS indexedDB.cmp([''],[new Date(1317399931023)]) is 1
     149PASS indexedDB.cmp([new Date(1317399931023)],[new Date(1317399931023)]) is 0
     150PASS indexedDB.cmp([''],['']) is 0
     151PASS indexedDB.cmp([''],['\0']) is -1
     152PASS indexedDB.cmp(['\0'],['']) is 1
     153PASS indexedDB.cmp([''],['']) is 0
     154PASS indexedDB.cmp(['\0'],['\0']) is 0
     155PASS indexedDB.cmp(['\0'],['a']) is -1
     156PASS indexedDB.cmp(['a'],['\0']) is 1
     157PASS indexedDB.cmp(['\0'],['\0']) is 0
     158PASS indexedDB.cmp(['a'],['a']) is 0
     159PASS indexedDB.cmp(['a'],['aa']) is -1
     160PASS indexedDB.cmp(['aa'],['a']) is 1
     161PASS indexedDB.cmp(['a'],['a']) is 0
     162PASS indexedDB.cmp(['aa'],['aa']) is 0
     163PASS indexedDB.cmp(['aa'],['b']) is -1
     164PASS indexedDB.cmp(['b'],['aa']) is 1
     165PASS indexedDB.cmp(['aa'],['aa']) is 0
     166PASS indexedDB.cmp(['b'],['b']) is 0
     167PASS indexedDB.cmp(['b'],['ba']) is -1
     168PASS indexedDB.cmp(['ba'],['b']) is 1
     169PASS indexedDB.cmp(['b'],['b']) is 0
     170PASS indexedDB.cmp(['ba'],['ba']) is 0
     171PASS indexedDB.cmp(['ba'],['¢']) is -1
     172PASS indexedDB.cmp(['¢'],['ba']) is 1
     173PASS indexedDB.cmp(['ba'],['ba']) is 0
     174PASS indexedDB.cmp(['¢'],['¢']) is 0
     175PASS indexedDB.cmp(['¢'],['水']) is -1
     176PASS indexedDB.cmp(['水'],['¢']) is 1
     177PASS indexedDB.cmp(['¢'],['¢']) is 0
     178PASS indexedDB.cmp(['水'],['水']) is 0
     179PASS indexedDB.cmp(['水'],['𝄞']) is -1
     180PASS indexedDB.cmp(['𝄞'],['水']) is 1
     181PASS indexedDB.cmp(['水'],['水']) is 0
     182PASS indexedDB.cmp(['𝄞'],['𝄞']) is 0
     183PASS indexedDB.cmp(['𝄞'],['�']) is -1
     184PASS indexedDB.cmp(['�'],['𝄞']) is 1
     185PASS indexedDB.cmp(['𝄞'],['𝄞']) is 0
     186PASS indexedDB.cmp(['�'],['�']) is 0
     187PASS indexedDB.cmp(['�'],[[]]) is -1
     188PASS indexedDB.cmp([[]],['�']) is 1
     189PASS indexedDB.cmp(['�'],['�']) is 0
     190PASS indexedDB.cmp([[]],[[]]) is 0
     191PASS indexedDB.cmp([[]],[[], []]) is -1
     192PASS indexedDB.cmp([[], []],[[]]) is 1
     193PASS indexedDB.cmp([[]],[[]]) is 0
     194PASS indexedDB.cmp([[], []],[[], []]) is 0
     195PASS indexedDB.cmp([[], []],[[], [], []]) is -1
     196PASS indexedDB.cmp([[], [], []],[[], []]) is 1
     197PASS indexedDB.cmp([[], []],[[], []]) is 0
     198PASS indexedDB.cmp([[], [], []],[[], [], []]) is 0
     199PASS indexedDB.cmp([[], [], []],[[[]]]) is -1
     200PASS indexedDB.cmp([[[]]],[[], [], []]) is 1
     201PASS indexedDB.cmp([[], [], []],[[], [], []]) is 0
     202PASS indexedDB.cmp([[[]]],[[[]]]) is 0
     203PASS indexedDB.cmp([[[]]],[[[[]]]]) is -1
     204PASS indexedDB.cmp([[[[]]]],[[[]]]) is 1
     205PASS indexedDB.cmp([[[]]],[[[]]]) is 0
     206PASS indexedDB.cmp([[[[]]]],[[[[]]]]) is 0
    207207
    208208compare invalid keys
    … …  
    407407
    408408compare identical keys
    409 PASS indexedDB.cmp(0, -0) === 0 is true
     409PASS indexedDB.cmp(0, -0) is 0
    410410PASS successfullyParsed is true
    411411

  • trunk/LayoutTests/storage/indexeddb/factory-deletedatabase-expected.txt

    r116337 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313store = db.createObjectStore('storeName', null)
    1414store.createIndex('indexName', '')

  • trunk/LayoutTests/storage/indexeddb/get-keyrange-expected.txt

    r114805 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414db.createObjectStore('someObjectStore')

  • trunk/LayoutTests/storage/indexeddb/index-basics-expected.txt

    r112490 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515db.createObjectStore('storeName', null)
    … …  
    6767indexObject.openKeyCursor()
    6868PASS event.target.source is indexObject
    69 PASS event.target.result === null is false
     69PASS event.target.result is non-null.
    7070PASS event.target.result.key is "value"
    7171PASS event.target.result.primaryKey is "key"
    7272event.target.result.continue()
    73 PASS event.target.result === null is false
     73PASS event.target.result is non-null.
    7474PASS event.target.result.key is "value2"
    7575PASS event.target.result.primaryKey is "key2"
    7676event.target.result.continue()
    77 PASS event.target.result === null is false
     77PASS event.target.result is non-null.
    7878PASS event.target.result.key is "value3"
    7979PASS event.target.result.primaryKey is "key3"
    8080event.target.result.continue()
    81 PASS event.target.result === null is true
     81PASS event.target.result is null
    8282indexObject.openCursor()
    8383PASS event.target.source is indexObject
    84 PASS event.target.result === null is false
     84PASS event.target.result is non-null.
    8585PASS event.target.result.key is "value"
    8686PASS event.target.result.value.x is "value"
    8787PASS event.target.result.value.y is "zzz"
    8888event.target.result.continue()
    89 PASS event.target.result === null is false
     89PASS event.target.result is non-null.
    9090PASS event.target.result.key is "value2"
    9191PASS event.target.result.value.x is "value2"
    9292PASS event.target.result.value.y is "zzz2"
    9393event.target.result.continue()
    94 PASS event.target.result === null is false
     94PASS event.target.result is non-null.
    9595PASS event.target.result.key is "value3"
    9696PASS event.target.result.value.x is "value3"
    9797PASS event.target.result.value.y is "456"
    9898event.target.result.continue()
    99 PASS event.target.result === null is true
     99PASS event.target.result is null
    100100Passing an invalid key into indexObject.get({}).
    101 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     101Expecting exception from indexObject.get({})
     102PASS Exception was thrown.
     103PASS code is IDBDatabaseException.DATA_ERR
    102104Passing an invalid key into indexObject.getKey({}).
    103 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     105Expecting exception from indexObject.getKey({})
     106PASS Exception was thrown.
     107PASS code is IDBDatabaseException.DATA_ERR
    104108PASS successfullyParsed is true
    105109

  • trunk/LayoutTests/storage/indexeddb/index-basics-workers-expected.txt

    r112490 r117702  
    1212[Worker] setVersionSuccess():
    1313[Worker] trans = event.target.result
    14 PASS [Worker] trans !== null is true
     14PASS [Worker] trans is non-null.
    1515[Worker] Deleted all object stores.
    1616[Worker] db.createObjectStore('storeName', null)
    … …  
    6868[Worker] indexObject.openKeyCursor()
    6969PASS [Worker] event.target.source is indexObject
    70 PASS [Worker] event.target.result === null is false
     70PASS [Worker] event.target.result is non-null.
    7171PASS [Worker] event.target.result.key is "value"
    7272PASS [Worker] event.target.result.primaryKey is "key"
    7373[Worker] event.target.result.continue()
    74 PASS [Worker] event.target.result === null is false
     74PASS [Worker] event.target.result is non-null.
    7575PASS [Worker] event.target.result.key is "value2"
    7676PASS [Worker] event.target.result.primaryKey is "key2"
    7777[Worker] event.target.result.continue()
    78 PASS [Worker] event.target.result === null is false
     78PASS [Worker] event.target.result is non-null.
    7979PASS [Worker] event.target.result.key is "value3"
    8080PASS [Worker] event.target.result.primaryKey is "key3"
    8181[Worker] event.target.result.continue()
    82 PASS [Worker] event.target.result === null is true
     82PASS [Worker] event.target.result is null
    8383[Worker] indexObject.openCursor()
    8484PASS [Worker] event.target.source is indexObject
    85 PASS [Worker] event.target.result === null is false
     85PASS [Worker] event.target.result is non-null.
    8686PASS [Worker] event.target.result.key is "value"
    8787PASS [Worker] event.target.result.value.x is "value"
    8888PASS [Worker] event.target.result.value.y is "zzz"
    8989[Worker] event.target.result.continue()
    90 PASS [Worker] event.target.result === null is false
     90PASS [Worker] event.target.result is non-null.
    9191PASS [Worker] event.target.result.key is "value2"
    9292PASS [Worker] event.target.result.value.x is "value2"
    9393PASS [Worker] event.target.result.value.y is "zzz2"
    9494[Worker] event.target.result.continue()
    95 PASS [Worker] event.target.result === null is false
     95PASS [Worker] event.target.result is non-null.
    9696PASS [Worker] event.target.result.key is "value3"
    9797PASS [Worker] event.target.result.value.x is "value3"
    9898PASS [Worker] event.target.result.value.y is "456"
    9999[Worker] event.target.result.continue()
    100 PASS [Worker] event.target.result === null is true
     100PASS [Worker] event.target.result is null
    101101[Worker] Passing an invalid key into indexObject.get({}).
    102 PASS [Worker] Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     102[Worker] Expecting exception from indexObject.get({})
     103PASS [Worker] Exception was thrown.
     104PASS [Worker] code is IDBDatabaseException.DATA_ERR
    103105[Worker] Passing an invalid key into indexObject.getKey({}).
    104 PASS [Worker] Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     106[Worker] Expecting exception from indexObject.getKey({})
     107PASS [Worker] Exception was thrown.
     108PASS [Worker] code is IDBDatabaseException.DATA_ERR
    105109PASS successfullyParsed is true
    106110

  • trunk/LayoutTests/storage/indexeddb/index-count-expected.txt

    r116337 r117702  
    1212preparing database
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616store = db.createObjectStore('storeName', null)
    … …  
    2121verifying count without range
    2222trans = db.transaction('storeName', 'readonly')
    23 PASS trans != null is true
     23PASS trans is non-null.
    2424store = trans.objectStore('storeName')
    25 PASS store != null is true
     25PASS store is non-null.
    2626index = store.index('indexName')
    27 PASS index != null is true
     27PASS index is non-null.
    2828request = index.count()
    29 PASS typeof request.result == 'number' is true
     29PASS typeof request.result is "number"
    3030PASS request.result is 100
    3131
    3232verifying count with range
    3333trans = db.transaction('storeName', 'readonly')
    34 PASS trans != null is true
     34PASS trans is non-null.
    3535store = trans.objectStore('storeName')
    36 PASS store != null is true
     36PASS store is non-null.
    3737index = trans.objectStore('storeName').index('indexName')
    38 PASS index != null is true
     38PASS index is non-null.
    3939
    4040test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":false,"expected":100}
    4141request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    42 PASS typeof request.result == 'number' is true
     42PASS typeof request.result is "number"
    4343PASS request.result is 100
    4444
    4545test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":false,"expected":99}
    4646request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    47 PASS typeof request.result == 'number' is true
     47PASS typeof request.result is "number"
    4848PASS request.result is 99
    4949
    5050test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":true,"expected":99}
    5151request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    52 PASS typeof request.result == 'number' is true
     52PASS typeof request.result is "number"
    5353PASS request.result is 99
    5454
    5555test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":true,"expected":98}
    5656request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    57 PASS typeof request.result == 'number' is true
     57PASS typeof request.result is "number"
    5858PASS request.result is 98
    5959
    6060test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
    6161request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    62 PASS typeof request.result == 'number' is true
     62PASS typeof request.result is "number"
    6363PASS request.result is 100
    6464
    6565test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
    6666request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    67 PASS typeof request.result == 'number' is true
     67PASS typeof request.result is "number"
    6868PASS request.result is 100
    6969
    7070test = {"lower":10,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":90}
    7171request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    72 PASS typeof request.result == 'number' is true
     72PASS typeof request.result is "number"
    7373PASS request.result is 90
    7474
    7575test = {"lower":0,"lowerOpen":false,"upper":0,"upperOpen":false,"expected":1}
    7676request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    77 PASS typeof request.result == 'number' is true
     77PASS typeof request.result is "number"
    7878PASS request.result is 1
    7979
    8080test = {"lower":500,"lowerOpen":false,"upper":500,"upperOpen":false,"expected":0}
    8181request = index.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    82 PASS typeof request.result == 'number' is true
     82PASS typeof request.result is "number"
    8383PASS request.result is 0
    8484
    8585verifying count with key
    8686trans = db.transaction('storeName', 'readonly')
    87 PASS trans != null is true
     87PASS trans is non-null.
    8888store = trans.objectStore('storeName')
    89 PASS store != null is true
     89PASS store is non-null.
    9090index = trans.objectStore('storeName').index('indexName')
    91 PASS index != null is true
     91PASS index is non-null.
    9292Expecting exception from index.count(NaN)
    9393PASS Exception was thrown.
    … …  
    102102test = {"key":0,"expected":1}
    103103request = index.count(test.key)
    104 PASS typeof request.result == 'number' is true
     104PASS typeof request.result is "number"
    105105PASS request.result is 1
    106106
    107107test = {"key":100,"expected":0}
    108108request = index.count(test.key)
    109 PASS typeof request.result == 'number' is true
     109PASS typeof request.result is "number"
    110110PASS request.result is 0
    111111
    112112test = {"key":null,"expected":100}
    113113request = index.count(test.key)
    114 PASS typeof request.result == 'number' is true
     114PASS typeof request.result is "number"
    115115PASS request.result is 100
    116116PASS successfullyParsed is true

  • trunk/LayoutTests/storage/indexeddb/index-cursor-expected.txt

    r112490 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414db.createObjectStore('someObjectStore')

  • trunk/LayoutTests/storage/indexeddb/index-multientry-expected.txt

    r116337 r117702  
    1212Creating empty stores and indexes
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616store = db.createObjectStore('store')
    … …  
    3131transaction.objectStore('store').index('index').openCursor()
    3232cursor = event.target.result
    33 PASS ex != null is true
     33PASS ex is non-null.
    3434PASS cursor.key is 1
    3535PASS cursor.primaryKey is "foo"
    3636PASS cursor.value.y is "a"
    3737cursor = event.target.result
    38 PASS ex != null is true
     38PASS ex is non-null.
    3939PASS cursor.key is 2
    4040PASS cursor.primaryKey is "foo"
    4141PASS cursor.value.y is "a"
    4242cursor = event.target.result
    43 PASS ex != null is true
     43PASS ex is non-null.
    4444PASS cursor.key is 3
    4545PASS cursor.primaryKey is "foo"
    4646PASS cursor.value.y is "a"
    4747cursor = event.target.result
    48 PASS ex != null is true
     48PASS ex is non-null.
    4949PASS cursor.key is 4
    5050PASS cursor.primaryKey is "bar"
    5151PASS cursor.value.y is "b"
    5252cursor = event.target.result
    53 PASS ex != null is true
     53PASS ex is non-null.
    5454PASS cursor.key is 5
    5555PASS cursor.primaryKey is "bar"
    5656PASS cursor.value.y is "b"
    5757cursor = event.target.result
    58 PASS ex != null is true
     58PASS ex is non-null.
    5959PASS cursor.key is 6
    6060PASS cursor.primaryKey is "bar"
    6161PASS cursor.value.y is "b"
    6262cursor = event.target.result
    63 PASS expected.length === 0 is true
     63PASS expected.length is 0
    6464
    6565Verifying unique constraint on multiEntry index
    … …  
    7878db.setVersion('2')
    7979trans = event.target.result
    80 PASS trans !== null is true
     80PASS trans is non-null.
    8181store = trans.objectStore('store')
    8282store.createIndex('index-new', 'x', {multiEntry: true})
    … …  
    8686transaction.objectStore('store').index('index-new').openCursor()
    8787cursor = event.target.result
    88 PASS ex != null is true
     88PASS ex is non-null.
    8989PASS cursor.key is 1
    9090PASS cursor.primaryKey is "foo"
    9191PASS cursor.value.y is "a"
    9292cursor = event.target.result
    93 PASS ex != null is true
     93PASS ex is non-null.
    9494PASS cursor.key is 2
    9595PASS cursor.primaryKey is "foo"
    9696PASS cursor.value.y is "a"
    9797cursor = event.target.result
    98 PASS ex != null is true
     98PASS ex is non-null.
    9999PASS cursor.key is 3
    100100PASS cursor.primaryKey is "foo"
    101101PASS cursor.value.y is "a"
    102102cursor = event.target.result
    103 PASS ex != null is true
     103PASS ex is non-null.
    104104PASS cursor.key is 4
    105105PASS cursor.primaryKey is "bar"
    106106PASS cursor.value.y is "b"
    107107cursor = event.target.result
    108 PASS ex != null is true
     108PASS ex is non-null.
    109109PASS cursor.key is 5
    110110PASS cursor.primaryKey is "bar"
    111111PASS cursor.value.y is "b"
    112112cursor = event.target.result
    113 PASS ex != null is true
     113PASS ex is non-null.
    114114PASS cursor.key is 6
    115115PASS cursor.primaryKey is "bar"
    116116PASS cursor.value.y is "b"
    117117cursor = event.target.result
    118 PASS expected.length === 0 is true
     118PASS expected.length is 0
    119119PASS successfullyParsed is true
    120120

  • trunk/LayoutTests/storage/indexeddb/index-population-expected.txt

    r112490 r117702  
    4242setVersion2Abort():
    4343PASS db.objectStoreNames.length is 1
    44 PASS db.objectStoreNames[0] is 'store1'
     44PASS db.objectStoreNames[0] is "store1"
    4545PASS successfullyParsed is true
    4646

  • trunk/LayoutTests/storage/indexeddb/index-unique-expected.txt

    r116337 r117702  
    1111deleteExisting():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515db.createObjectStore('store')

  • trunk/LayoutTests/storage/indexeddb/key-type-array-expected.txt

    r116337 r117702  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 IDBTransaction = self.IDBTransaction || self.IDBTransaction;
    9 PASS IDBTransaction == null is false
    10 IDBDatabaseException = self.IDBDatabaseException || self.IDBDatabaseException;
    11 PASS IDBDatabaseException == null is false
    128indexedDB.open(name)
    139db = openreq.result

  • trunk/LayoutTests/storage/indexeddb/keyrange-expected.txt

    r112490 r117702  
    211211PASS keyRange.upperOpen is true
    212212Passing an invalid key into only({})
    213 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     213Expecting exception from IDBKeyRange.only({})
     214PASS Exception was thrown.
     215PASS code is IDBDatabaseException.DATA_ERR
    214216Passing an invalid key into upperBound({})
    215 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     217Expecting exception from IDBKeyRange.upperBound({})
     218PASS Exception was thrown.
     219PASS code is IDBDatabaseException.DATA_ERR
    216220Passing an invalid key into lowerBound({})
    217 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     221Expecting exception from IDBKeyRange.lowerBound({})
     222PASS Exception was thrown.
     223PASS code is IDBDatabaseException.DATA_ERR
    218224Passing an invalid key into bound(null, {})
    219 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     225Expecting exception from IDBKeyRange.bound(null, {})
     226PASS Exception was thrown.
     227PASS code is IDBDatabaseException.DATA_ERR
    220228Passing an invalid key into bound({},null)
    221 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     229Expecting exception from IDBKeyRange.bound({}, null)
     230PASS Exception was thrown.
     231PASS code is IDBDatabaseException.DATA_ERR
    222232Passing an invalid key into bound({}, {})
    223 PASS Caught exception: Error: DATA_ERR: DOM IDBDatabase Exception 5
     233Expecting exception from IDBKeyRange.bound({}, {})
     234PASS Exception was thrown.
     235PASS code is IDBDatabaseException.DATA_ERR
    224236Lower key greater than higher key, bound(4, 3)
    225237Expecting exception from IDBKeyRange.bound(4, 3)

  • trunk/LayoutTests/storage/indexeddb/legacy-constants-expected.txt

    r116337 r117702  
    2525populating store...
    2626trans = db.transaction('store', IDBTransaction.READ_WRITE)
    27 PASS trans.mode is 'readwrite'
     27PASS trans.mode is "readwrite"
    2828store = trans.objectStore('store');
    2929store.put({value: 111}, 1)
    3030store.put({value: 222}, 2)
    3131trans = db.transaction('store', IDBTransaction.READ_ONLY)
    32 PASS trans.mode is 'readonly'
     32PASS trans.mode is "readonly"
    3333request = store.openCursor(null, IDBCursor.NEXT)
    34 PASS cursor.direction is 'next'
     34PASS cursor.direction is "next"
    3535cursor.continue();
    36 PASS cursor.direction is 'next'
     36PASS cursor.direction is "next"
    3737cursor.continue();
    3838trans = db.transaction('store', IDBTransaction.READ_ONLY)
    39 PASS trans.mode is 'readonly'
     39PASS trans.mode is "readonly"
    4040request = store.openCursor(null, IDBCursor.NEXT_NO_DUPLICATE)
    41 PASS cursor.direction is 'nextunique'
     41PASS cursor.direction is "nextunique"
    4242cursor.continue();
    43 PASS cursor.direction is 'nextunique'
     43PASS cursor.direction is "nextunique"
    4444cursor.continue();
    4545trans = db.transaction('store', IDBTransaction.READ_ONLY)
    46 PASS trans.mode is 'readonly'
     46PASS trans.mode is "readonly"
    4747request = store.openCursor(null, IDBCursor.PREV)
    48 PASS cursor.direction is 'prev'
     48PASS cursor.direction is "prev"
    4949cursor.continue();
    50 PASS cursor.direction is 'prev'
     50PASS cursor.direction is "prev"
    5151cursor.continue();
    5252trans = db.transaction('store', IDBTransaction.READ_ONLY)
    53 PASS trans.mode is 'readonly'
     53PASS trans.mode is "readonly"
    5454request = store.openCursor(null, IDBCursor.NEXT)
    55 PASS cursor.direction is 'next'
     55PASS cursor.direction is "next"
    5656cursor.continue();
    57 PASS cursor.direction is 'next'
     57PASS cursor.direction is "next"
    5858cursor.continue();
    5959PASS successfullyParsed is true

  • trunk/LayoutTests/storage/indexeddb/mutating-cursor-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('store')

  • trunk/LayoutTests/storage/indexeddb/objectstore-autoincrement-expected.txt

    r116337 r117702  
    1212setVersionSuccess():
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616createObjectStore():
    … …  
    2121storeNames = db.objectStoreNames
    2222PASS store.name is "StoreWithKeyPath"
    23 PASS store.keyPath is 'id'
     23PASS store.keyPath is "id"
    2424PASS storeNames.contains('StoreWithKeyPath') is true
    2525PASS storeNames.contains('StoreWithAutoIncrement') is true
    … …  
    7777count = 0
    7878expected = cursor.value.a.b.c.id + 1
    79 PASS cursor.value.foo is 'bar'
     79PASS cursor.value.foo is "bar"
    8080PASS cursor.value.a.b.c.id is expected
    8181expected = cursor.value.a.b.c.id + 1
    82 PASS cursor.value.foo is 'bar'
     82PASS cursor.value.foo is "bar"
    8383PASS cursor.value.a.b.c.id is expected
    8484expected = cursor.value.a.b.c.id + 1
    85 PASS cursor.value.foo is 'bar'
     85PASS cursor.value.foo is "bar"
    8686PASS cursor.value.a.b.c.id is expected
    8787expected = cursor.value.a.b.c.id + 1

  • trunk/LayoutTests/storage/indexeddb/objectstore-basics-expected.txt

    r117509 r117702  
    1212setVersionSuccess():
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616createObjectStore():
    … …  
    5050PASS db.createObjectStore('storeWithKeyGenerator', {autoIncrement: true}).autoIncrement is true
    5151Ask for an index that doesn't exist:
    52 index = store.index('asdf')
    53 PASS Exception thrown.
     52Expecting exception from store.index('asdf')
     53PASS Exception was thrown.
    5454PASS code is IDBDatabaseException.NOT_FOUND_ERR
    5555createIndex():
    5656index = store.createIndex('indexName', 'x', {unique: true})
    57 PASS index !== null is true
     57PASS index is non-null.
    5858PASS store.indexNames.contains('indexName') is true
    5959index = store.index('indexName')
    60 PASS index !== null is true
     60PASS index is non-null.
    6161Ask for an index that doesn't exist:
    62 index = store.index('asdf')
    63 PASS Exception thrown.
     62Expecting exception from store.index('asdf')
     63PASS Exception was thrown.
    6464PASS code is IDBDatabaseException.NOT_FOUND_ERR
    6565db.setVersion("version fail")
    6666PASS db.version is "version fail"
    6767setVersionTrans = event.target.result
    68 PASS setVersionTrans !== null is true
     68PASS setVersionTrans is non-null.
    6969store = setVersionTrans.objectStore('storeName')
    7070index = store.createIndex('indexFail', 'x')
    … …  
    8686store.add({x: 'foo'}, testDate)
    8787Try to insert a value not handled by structured clone:
    88 store.add({x: 'bar', y: self}, 'bar')
    89 PASS Exception thrown
    90 PASS code is 25
     88Expecting exception from store.add({x: 'bar', y: self}, 'bar')
     89PASS Exception was thrown.
     90PASS code is DOMException.DATA_CLONE_ERR
    9191Try to insert data where key path yields a Date key:
    9292store.add({x: testDateB, y: 'value'}, 'key')

  • trunk/LayoutTests/storage/indexeddb/objectstore-basics-workers-expected.txt

    r117509 r117702  
    1313[Worker] setVersionSuccess():
    1414[Worker] trans = event.target.result
    15 PASS [Worker] trans !== null is true
     15PASS [Worker] trans is non-null.
    1616[Worker] Deleted all object stores.
    1717[Worker] createObjectStore():
    … …  
    5151PASS [Worker] db.createObjectStore('storeWithKeyGenerator', {autoIncrement: true}).autoIncrement is true
    5252[Worker] Ask for an index that doesn't exist:
    53 [Worker] index = store.index('asdf')
    54 PASS [Worker] Exception thrown.
     53[Worker] Expecting exception from store.index('asdf')
     54PASS [Worker] Exception was thrown.
    5555PASS [Worker] code is IDBDatabaseException.NOT_FOUND_ERR
    5656[Worker] createIndex():
    5757[Worker] index = store.createIndex('indexName', 'x', {unique: true})
    58 PASS [Worker] index !== null is true
     58PASS [Worker] index is non-null.
    5959PASS [Worker] store.indexNames.contains('indexName') is true
    6060[Worker] index = store.index('indexName')
    61 PASS [Worker] index !== null is true
     61PASS [Worker] index is non-null.
    6262[Worker] Ask for an index that doesn't exist:
    63 [Worker] index = store.index('asdf')
    64 PASS [Worker] Exception thrown.
     63[Worker] Expecting exception from store.index('asdf')
     64PASS [Worker] Exception was thrown.
    6565PASS [Worker] code is IDBDatabaseException.NOT_FOUND_ERR
    6666[Worker] db.setVersion("version fail")
    6767PASS [Worker] db.version is "version fail"
    6868[Worker] setVersionTrans = event.target.result
    69 PASS [Worker] setVersionTrans !== null is true
     69PASS [Worker] setVersionTrans is non-null.
    7070[Worker] store = setVersionTrans.objectStore('storeName')
    7171[Worker] index = store.createIndex('indexFail', 'x')
    … …  
    8787[Worker] store.add({x: 'foo'}, testDate)
    8888[Worker] Try to insert a value not handled by structured clone:
    89 [Worker] store.add({x: 'bar', y: self}, 'bar')
    90 PASS [Worker] Exception thrown
    91 PASS [Worker] code is 25
     89[Worker] Expecting exception from store.add({x: 'bar', y: self}, 'bar')
     90PASS [Worker] Exception was thrown.
     91PASS [Worker] code is DOMException.DATA_CLONE_ERR
    9292[Worker] Try to insert data where key path yields a Date key:
    9393[Worker] store.add({x: testDateB, y: 'value'}, 'key')

  • trunk/LayoutTests/storage/indexeddb/objectstore-clear-expected.txt

    r112490 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414store = db.createObjectStore('storeName', null)

  • trunk/LayoutTests/storage/indexeddb/objectstore-count-expected.txt

    r116337 r117702  
    1212preparing database
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515Deleted all object stores.
    1616store = db.createObjectStore('storeName', null)
    … …  
    1919verifying count without range
    2020trans = db.transaction('storeName', 'readonly')
    21 PASS trans != null is true
     21PASS trans is non-null.
    2222store = trans.objectStore('storeName')
    23 PASS store != null is true
     23PASS store is non-null.
    2424request = store.count()
    25 PASS typeof request.result == 'number' is true
     25PASS typeof request.result is "number"
    2626PASS request.result is 100
    2727
    2828verifying count with range
    2929trans = db.transaction('storeName', 'readonly')
    30 PASS trans != null is true
     30PASS trans is non-null.
    3131store = trans.objectStore('storeName')
    32 PASS store != null is true
     32PASS store is non-null.
    3333
    3434test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":false,"expected":100}
    3535request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    36 PASS typeof request.result == 'number' is true
     36PASS typeof request.result is "number"
    3737PASS request.result is 100
    3838
    3939test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":false,"expected":99}
    4040request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    41 PASS typeof request.result == 'number' is true
     41PASS typeof request.result is "number"
    4242PASS request.result is 99
    4343
    4444test = {"lower":0,"lowerOpen":false,"upper":99,"upperOpen":true,"expected":99}
    4545request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    46 PASS typeof request.result == 'number' is true
     46PASS typeof request.result is "number"
    4747PASS request.result is 99
    4848
    4949test = {"lower":0,"lowerOpen":true,"upper":99,"upperOpen":true,"expected":98}
    5050request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    51 PASS typeof request.result == 'number' is true
     51PASS typeof request.result is "number"
    5252PASS request.result is 98
    5353
    5454test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
    5555request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    56 PASS typeof request.result == 'number' is true
     56PASS typeof request.result is "number"
    5757PASS request.result is 100
    5858
    5959test = {"lower":0,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":100}
    6060request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    61 PASS typeof request.result == 'number' is true
     61PASS typeof request.result is "number"
    6262PASS request.result is 100
    6363
    6464test = {"lower":10,"lowerOpen":false,"upper":100,"upperOpen":false,"expected":90}
    6565request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    66 PASS typeof request.result == 'number' is true
     66PASS typeof request.result is "number"
    6767PASS request.result is 90
    6868
    6969test = {"lower":0,"lowerOpen":false,"upper":0,"upperOpen":false,"expected":1}
    7070request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    71 PASS typeof request.result == 'number' is true
     71PASS typeof request.result is "number"
    7272PASS request.result is 1
    7373
    7474test = {"lower":500,"lowerOpen":false,"upper":500,"upperOpen":false,"expected":0}
    7575request = store.count(IDBKeyRange.bound(test.lower, test.upper, test.lowerOpen, test.upperOpen))
    76 PASS typeof request.result == 'number' is true
     76PASS typeof request.result is "number"
    7777PASS request.result is 0
    7878
    7979verifying count with key
    8080trans = db.transaction('storeName', 'readonly')
    81 PASS trans != null is true
     81PASS trans is non-null.
    8282store = trans.objectStore('storeName')
    83 PASS store != null is true
     83PASS store is non-null.
    8484Expecting exception from store.count(NaN)
    8585PASS Exception was thrown.
    … …  
    9494test = {"key":0,"expected":1}
    9595request = store.count(test.key)
    96 PASS typeof request.result == 'number' is true
     96PASS typeof request.result is "number"
    9797PASS request.result is 1
    9898
    9999test = {"key":100,"expected":0}
    100100request = store.count(test.key)
    101 PASS typeof request.result == 'number' is true
     101PASS typeof request.result is "number"
    102102PASS request.result is 0
    103103
    104104test = {"key":null,"expected":100}
    105105request = store.count(test.key)
    106 PASS typeof request.result == 'number' is true
     106PASS typeof request.result is "number"
    107107PASS request.result is 100
    108108PASS successfullyParsed is true

  • trunk/LayoutTests/storage/indexeddb/objectstore-cursor-expected.txt

    r112490 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414db.createObjectStore('someObjectStore')

  • trunk/LayoutTests/storage/indexeddb/objectstore-removeobjectstore-expected.txt

    r112490 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313Deleted all object stores.
    1414store = db.createObjectStore('storeName', null)
    … …  
    2222db.setVersion('new version')
    2323trans = event.target.result
    24 PASS trans !== null is true
     24PASS trans is non-null.
    2525db.deleteObjectStore('storeName')
    2626db.createObjectStore('storeName', null)

  • trunk/LayoutTests/storage/indexeddb/open-cursor-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515objectStore = db.createObjectStore('test')
    … …  
    1818event.target.source.openCursor(keyRange)
    1919Cursor opened successfully.
    20 PASS cursor.direction is 'next'
    21 PASS cursor.key is 'myKey'
    22 PASS cursor.value is 'myValue'
     20PASS cursor.direction is "next"
     21PASS cursor.key is "myKey"
     22PASS cursor.value is "myValue"
    2323
    2424Passing an invalid key into .continue({}).
    … …  
    3434event.target.source.openCursor("myKey")
    3535Cursor opened successfully.
    36 PASS cursor.direction is 'next'
    37 PASS cursor.key is 'myKey'
    38 PASS cursor.value is 'myValue'
     36PASS cursor.direction is "next"
     37PASS cursor.key is "myKey"
     38PASS cursor.value is "myValue"
    3939
    4040Passing an invalid key into .continue({}).

  • trunk/LayoutTests/storage/indexeddb/opencursor-key-expected.txt

    r116337 r117702  
    3434objectStore = trans.objectStore(objectStoreName)
    3535request = objectStore.openCursor('237-23-7739')
    36 PASS cursor.key is '237-23-7739'
     36PASS cursor.key is "237-23-7739"
    3737PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[7].value)
    3838PASS cursor.primaryKey is cursor.key
    … …  
    4545PASS cursor.key is 180
    4646PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[2].value)
    47 PASS cursor.primaryKey is '237-23-7734'
     47PASS cursor.primaryKey is "237-23-7734"
    4848cursor.continue()
    4949PASS cursor.key is 180
    5050PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[6].value)
    51 PASS cursor.primaryKey is '237-23-7738'
     51PASS cursor.primaryKey is "237-23-7738"
    5252cursor.continue()
    5353PASS cursor.key is 180
    5454PASS JSON.stringify(cursor.value) is JSON.stringify(objectStoreData[10].value)
    55 PASS cursor.primaryKey is '237-23-7742'
     55PASS cursor.primaryKey is "237-23-7742"
    5656cursor.continue()
    5757PASS cursor is null
    … …  
    6161request = index.openKeyCursor(180)
    6262PASS cursor.key is 180
    63 PASS cursor.primaryKey is '237-23-7734'
     63PASS cursor.primaryKey is "237-23-7734"
    6464cursor.continue()
    6565PASS cursor.key is 180
    66 PASS cursor.primaryKey is '237-23-7738'
     66PASS cursor.primaryKey is "237-23-7738"
    6767cursor.continue()
    6868PASS cursor.key is 180
    69 PASS cursor.primaryKey is '237-23-7742'
     69PASS cursor.primaryKey is "237-23-7742"
    7070cursor.continue()
    7171PASS cursor is null

  • trunk/LayoutTests/storage/indexeddb/prefetch-bugfix-108071-expected.txt

    r116337 r117702  
    1212setVersionSuccess():
    1313trans = event.target.result
    14 PASS trans !== null is true
     14PASS trans is non-null.
    1515objectStore = db.createObjectStore('store', {keyPath: 'id'})
    1616

  • trunk/LayoutTests/storage/indexeddb/queued-commands-expected.txt

    r112490 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414Deleted all object stores.
    1515db.createObjectStore('storeName')

  • trunk/LayoutTests/storage/indexeddb/request-event-propagation-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414trans.oncomplete = startTest
    1515Deleted all object stores.

  • trunk/LayoutTests/storage/indexeddb/resources/basics.js

    r116337 r117702  
    2121    shouldBeNull("request.transaction");
    2222    shouldBeTrue("'readyState' in request");
    23     shouldBe("request.readyState", "'pending'");
     23    shouldBeEqualToString("request.readyState", "pending");
    2424    shouldBeTrue("'onsuccess' in request");
    2525    shouldBeNull("request.onsuccess");
    … …  
    4444    shouldBeNull("event.target.transaction");
    4545    shouldBeTrue("'readyState' in request");
    46     shouldBe("event.target.readyState", "'done'");
     46    shouldBeEqualToString("event.target.readyState", "done");
    4747    shouldBeTrue("'onsuccess' in event.target");
    4848    shouldBeTrue("'onerror' in event.target");

  • trunk/LayoutTests/storage/indexeddb/resources/create-object-store-options.js

    r116337 r117702  
    3939{
    4040    trans = evalAndLog("trans = db.transaction(['a', 'b'], 'readwrite')");
    41     shouldBe("trans.mode", "'readwrite'");
     41    shouldBeEqualToString("trans.mode", "readwrite");
    4242
    4343    req = evalAndLog("trans.objectStore('a').put({'a': 0})");

  • trunk/LayoutTests/storage/indexeddb/resources/createObjectStore-null-name.js

    r114672 r117702  
    3030
    3131    objectStore = evalAndLog("db.createObjectStore(null);");
    32     shouldBe("objectStore.name", "'null'");
     32    shouldBeEqualToString("objectStore.name", "null");
    3333    finishJSTest();
    3434}

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-added-bug.js

    r116337 r117702  
    2828{
    2929    trans = evalAndLog("trans = event.target.result");
    30     shouldBeTrue("trans !== null");
     30    shouldBeNonNull("trans");
    3131    trans.onabort = unexpectedAbortCallback;
    3232    trans.oncomplete = openCursor;

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-continue-validity.js

    r116337 r117702  
    3737{
    3838    self.trans = evalAndLog("trans = event.target.result");
    39     shouldBeTrue("trans !== null");
     39    shouldBeNonNull("trans");
    4040    trans.onabort = unexpectedAbortCallback;
    4141

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-continue.js

    r116337 r117702  
    5555{
    5656    self.trans = evalAndLog("trans = event.target.result");
    57     shouldBeTrue("trans !== null");
     57    shouldBeNonNull("trans");
    5858    trans.onabort = unexpectedAbortCallback;
    5959

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-delete.js

    r116337 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333    trans.oncomplete = openCursor;

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-inconsistency.js

    r116337 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333    trans.oncomplete = openBasicCursor;
    … …  
    7070      storedCursor = evalAndLog("storedCursor = event.target.result");
    7171
    72     shouldBeTrue("storedCursor === event.target.result");
     72    shouldBe("storedCursor", "event.target.result");
    7373    shouldBeEqualToString("storedCursor.key", "someKey" + counter);
    7474    shouldBeEqualToString("event.target.result.key", "someKey" + counter);

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-index-delete.js

    r116337 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333    trans.oncomplete = openCursor;

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-key-order.js

    r116337 r117702  
    164164            getreq.onerror = unexpectedErrorCallback;
    165165            getreq.onsuccess = function() {
    166                 shouldBeTrue("getreq.result === count++");
     166                shouldBe("getreq.result", "count++");
    167167                cursor.continue();
    168168            };
    169169        } else {
    170             shouldBeTrue("count === keys.length");
     170            shouldBe("count", "keys.length");
    171171            finishUp();
    172172        }

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-primary-key-order.js

    r116337 r117702  
    9090            cursor.continue();
    9191        } else {
    92             shouldBeTrue("count === keys.length");
     92            shouldBe("count", "keys.length");
    9393            finishJSTest();
    9494        }

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-skip-deleted.js

    r116337 r117702  
    3434    debug("setVersionSuccess():");
    3535    self.trans = evalAndLog("trans = event.target.result");
    36     shouldBeTrue("trans !== null");
     36    shouldBeNonNull("trans");
    3737    trans.onabort = unexpectedAbortCallback;
    3838    trans.oncomplete = basicCursorTest;

  • trunk/LayoutTests/storage/indexeddb/resources/cursor-update.js

    r116337 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333    trans.oncomplete = openBasicCursor;
    … …  
    4141    evalAndLog("objectStore.add('myValue4', 'myKey4').onerror = unexpectedErrorCallback");
    4242
    43     var objectStore = evalAndLog("objectStore = db.createObjectStore('autoIncrementStore', {autoIncrement: true})");
     43    objectStore = evalAndLog("objectStore = db.createObjectStore('autoIncrementStore', {autoIncrement: true})");
    4444    evalAndLog("objectStore.add('foo1').onerror = unexpectedErrorCallback");
    4545    evalAndLog("objectStore.add('foo2').onerror = unexpectedErrorCallback");
    … …  
    4747    evalAndLog("objectStore.add('foo4').onerror = unexpectedErrorCallback");
    4848
    49     var objectStore = evalAndLog("objectStore = db.createObjectStore('keyPathStore', {keyPath: 'id'})");
     49    objectStore = evalAndLog("objectStore = db.createObjectStore('keyPathStore', {keyPath: 'id'})");
    5050    evalAndLog("objectStore.createIndex('numberIndex', 'number')");
    5151    evalAndLog("objectStore.add({number: 1, id: 1}).onerror = unexpectedErrorCallback");
    … …  
    8585
    8686    request = evalAndLog("event.target.result.update('myUpdatedValue' + counter++)");
    87     request.onsuccess = function() { evalAndLog("event.target.source.continue()"); }
     87    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
    8888    request.onerror = unexpectedErrorCallback;
    8989}
    … …  
    122122
    123123    request = evalAndLog("event.target.result.update('myUpdatedFoo' + counter++)");
    124     request.onsuccess = function() { evalAndLog("event.target.source.continue()"); }
     124    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
    125125    request.onerror = unexpectedErrorCallback;
    126126}
    … …  
    161161
    162162    request = evalAndLog("event.target.result.update({id: counter, number: 100 + counter++})");
    163     request.onsuccess = function() { evalAndLog("event.target.source.continue()") };
     163    request.onsuccess = function() { evalAndLog("event.target.source.continue()"); };
    164164    request.onerror = unexpectedErrorCallback;
    165165}
    … …  
    197197    shouldBe("event.target.result.primaryKey", "counter");
    198198
    199     try {
    200         debug("event.target.result.update({id: counter, number: counter + 200})");
    201         event.target.result.update({id: counter, number: counter + 200});
    202         testFailed("Expected exception.");
    203     } catch (e) {
    204         code = e.code;
    205         shouldBe("code", "IDBDatabaseException.NOT_ALLOWED_ERR");
    206     }
     199    evalAndExpectException("event.target.result.update({id: counter, number: counter + 200})",
     200                           "IDBDatabaseException.NOT_ALLOWED_ERR");
    207201
    208202    counter++;

  • trunk/LayoutTests/storage/indexeddb/resources/data-corruption.js

    r116337 r117702  
    2828    debug("setVersionSuccess():");
    2929    self.trans = evalAndLog("trans = event.target.result");
    30     shouldBeTrue("trans !== null");
     30    shouldBeNonNull("trans");
    3131    trans.onabort = unexpectedAbortCallback;
    3232    trans.oncomplete = addData;
    … …  
    5959function doCheck()
    6060{
    61     shouldBeTrue("event.target.result.x.toString() == testDate.toString()");
     61    shouldBe("event.target.result.x.toString()", "testDate.toString()");
    6262    finishJSTest();
    6363}

  • trunk/LayoutTests/storage/indexeddb/resources/database-basics.js

    r112202 r117702  
    2828    debug("setVersionSuccess():");
    2929    self.trans = evalAndLog("trans = event.target.result");
    30     shouldBeTrue("trans !== null");
     30    shouldBeNonNull("trans");
    3131    trans.onabort = unexpectedAbortCallback;
    3232
    … …  
    9090    objectStore = evalAndLog('db.createObjectStore("test456")');
    9191    var setVersionTrans = evalAndLog("setVersionTrans = event.target.result");
    92     shouldBeTrue("setVersionTrans !== null");
     92    shouldBeNonNull("setVersionTrans");
    9393    setVersionTrans.oncomplete = unexpectedCompleteCallback;
    9494    setVersionTrans.onabort = checkMetadata;

  • trunk/LayoutTests/storage/indexeddb/resources/database-quota.js

    r116337 r117702  
    2727    debug("setVersionSuccess():");
    2828    self.trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131    trans.oncomplete = checkQuotaEnforcing;

  • trunk/LayoutTests/storage/indexeddb/resources/duplicates.js

    r112202 r117702  
    3030    debug("setVersionSuccess():");
    3131    self.trans = evalAndLog("trans = event.target.result");
    32     shouldBeTrue("trans !== null");
     32    shouldBeNonNull("trans");
    3333    trans.onabort = unexpectedAbortCallback;
    3434
    … …  
    100100function cursor1Continue()
    101101{
    102     shouldBeFalse("event.target.result === null");
     102    shouldBeNonNull("event.target.result");
    103103    shouldBeEqualToString("event.target.result.key", "value");
    104104    shouldBeEqualToString("event.target.result.primaryKey", "key");
    … …  
    111111function cursor1Continue2()
    112112{
    113     shouldBeFalse("event.target.result === null");
     113    shouldBeNonNull("event.target.result");
    114114    shouldBeEqualToString("event.target.result.key", "value2");
    115115    shouldBeEqualToString("event.target.result.primaryKey", "key2");
    … …  
    122122function openObjectCursor()
    123123{
    124     shouldBeTrue("event.target.result === null");
     124    shouldBeNull("event.target.result");
    125125
    126126    self.request = evalAndLog("indexObject.openCursor()");
    … …  
    131131function cursor2Continue()
    132132{
    133     shouldBeFalse("event.target.result === null");
     133    shouldBeNonNull("event.target.result");
    134134    shouldBeEqualToString("event.target.result.key", "value");
    135135    shouldBeEqualToString("event.target.result.value.x", "value");
    … …  
    143143function cursor2Continue2()
    144144{
    145     shouldBeFalse("event.target.result === null");
     145    shouldBeNonNull("event.target.result");
    146146    shouldBeEqualToString("event.target.result.key", "value2");
    147     shouldBeEqualToString("event.target.result.value.x", "value2");   
     147    shouldBeEqualToString("event.target.result.value.x", "value2");
    148148    shouldBeEqualToString("event.target.result.value.y", "zzz2");
    149149
    … …  
    155155function last()
    156156{
    157     shouldBeTrue("event.target.result === null");
     157    shouldBeNull("event.target.result");
    158158
    159159    if (testCount == 1)

  • trunk/LayoutTests/storage/indexeddb/resources/error-causes-abort-by-default.js

    r116337 r117702  
    2727    debug("setVersionSuccess():");
    2828    self.trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131    evalAndLog("trans.oncomplete = addData");

  • trunk/LayoutTests/storage/indexeddb/resources/exception-in-event-aborts.js

    r116337 r117702  
    2727    debug("setVersionSuccess():");
    2828    self.trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131    evalAndLog("trans.oncomplete = startTest");

  • trunk/LayoutTests/storage/indexeddb/resources/factory-basics.js

    r114672 r117702  
    1010    removeVendorPrefixes();
    1111
    12     shouldBeTrue("typeof indexedDB.open === 'function'");
    13     shouldBeTrue("typeof indexedDB.cmp === 'function'");
    14     shouldBeTrue("typeof indexedDB.getDatabaseNames === 'function'");
     12    shouldBeEqualToString("typeof indexedDB.open", "function");
     13    shouldBeEqualToString("typeof indexedDB.cmp", "function");
     14    shouldBeEqualToString("typeof indexedDB.getDatabaseNames", "function");
    1515
    16     shouldBeTrue("typeof indexedDB.deleteDatabase === 'function'");
     16    shouldBeEqualToString("typeof indexedDB.deleteDatabase", "function");
    1717
    1818    name = 'storage/indexeddb/factory-basics';

  • trunk/LayoutTests/storage/indexeddb/resources/factory-cmp.js

    r112202 r117702  
    1010    removeVendorPrefixes();
    1111
    12     shouldBeTrue("typeof indexedDB.cmp === 'function'");
     12    shouldBeEqualToString("typeof indexedDB.cmp", "function");
    1313
    1414    testValidKeys();
    … …  
    9191        key1 = keys[i];
    9292        key2 = keys[i + 1];
    93         shouldBeTrue("indexedDB.cmp(" + key1 + "," + key2 + ") === -1");
    94         shouldBeTrue("indexedDB.cmp(" + key2 + "," + key1 + ") === 1");
    95         shouldBeTrue("indexedDB.cmp(" + key1 + "," + key1 + ") === 0");
    96         shouldBeTrue("indexedDB.cmp(" + key2 + "," + key2 + ") === 0");
     93        shouldBe("indexedDB.cmp(" + key1 + "," + key2 + ")", "-1");
     94        shouldBe("indexedDB.cmp(" + key2 + "," + key1 + ")", "1");
     95        shouldBe("indexedDB.cmp(" + key1 + "," + key1 + ")", "0");
     96        shouldBe("indexedDB.cmp(" + key2 + "," + key2 + ")", "0");
    9797    }
    9898}
    … …  
    136136    debug("compare identical keys");
    137137
    138     shouldBeTrue("indexedDB.cmp(0, -0) === 0");
     138    shouldBe("indexedDB.cmp(0, -0)", "0");
    139139}
    140140

  • trunk/LayoutTests/storage/indexeddb/resources/factory-deletedatabase.js

    r116337 r117702  
    2626{
    2727    self.trans = evalAndLog("trans = event.target.result");
    28     shouldBeTrue("trans !== null");
     28    shouldBeNonNull("trans");
    2929
    3030    store = evalAndLog("store = db.createObjectStore('storeName', null)");

  • trunk/LayoutTests/storage/indexeddb/resources/get-keyrange.js

    r114805 r117702  
    3131{
    3232    self.trans = evalAndLog("trans = event.target.result");
    33     shouldBeTrue("trans !== null");
     33    shouldBeNonNull("trans");
    3434    trans.onabort = unexpectedAbortCallback;
    3535

  • trunk/LayoutTests/storage/indexeddb/resources/index-basics.js

    r110750 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333
    … …  
    175175    event = evt;
    176176    shouldBe("event.target.source", "indexObject");
    177     shouldBeFalse("event.target.result === null");
     177    shouldBeNonNull("event.target.result");
    178178    shouldBeEqualToString("event.target.result.key", "value");
    179179    shouldBeEqualToString("event.target.result.primaryKey", "key");
    … …  
    187187{
    188188    event = evt;
    189     shouldBeFalse("event.target.result === null");
     189    shouldBeNonNull("event.target.result");
    190190    shouldBeEqualToString("event.target.result.key", "value2");
    191191    shouldBeEqualToString("event.target.result.primaryKey", "key2");
    … …  
    199199{
    200200    event = evt;
    201     shouldBeFalse("event.target.result === null");
     201    shouldBeNonNull("event.target.result");
    202202    shouldBeEqualToString("event.target.result.key", "value3");
    203203    shouldBeEqualToString("event.target.result.primaryKey", "key3");
    … …  
    211211{
    212212    event = evt;
    213     shouldBeTrue("event.target.result === null");
     213    shouldBeNull("event.target.result");
    214214
    215215    self.request = evalAndLog("indexObject.openCursor()");
    … …  
    222222    event = evt;
    223223    shouldBe("event.target.source", "indexObject");
    224     shouldBeFalse("event.target.result === null");
     224    shouldBeNonNull("event.target.result");
    225225    shouldBeEqualToString("event.target.result.key", "value");
    226226    shouldBeEqualToString("event.target.result.value.x", "value");
    … …  
    235235{
    236236    event = evt;
    237     shouldBeFalse("event.target.result === null");
     237    shouldBeNonNull("event.target.result");
    238238    shouldBeEqualToString("event.target.result.key", "value2");
    239239    shouldBeEqualToString("event.target.result.value.x", "value2");
    … …  
    248248{
    249249    event = evt;
    250     shouldBeFalse("event.target.result === null");
     250    shouldBeNonNull("event.target.result");
    251251    shouldBeEqualToString("event.target.result.key", "value3");
    252252    shouldBeEqualToString("event.target.result.value.x", "value3");
    … …  
    261261{
    262262    event = evt;
    263     shouldBeTrue("event.target.result === null");
    264 
    265     try {
    266         debug("Passing an invalid key into indexObject.get({}).");
    267         indexObject.get({});
    268         testFailed("No exception thrown");
    269     } catch (e) {
    270         testPassed("Caught exception: " + e.toString());
    271     }
    272 
    273     try {
    274         debug("Passing an invalid key into indexObject.getKey({}).");
    275         indexObject.getKey({});
    276         testFailed("No exception thrown");
    277     } catch (e) {
    278         testPassed("Caught exception: " + e.toString());
    279     }
     263    shouldBeNull("event.target.result");
     264
     265    debug("Passing an invalid key into indexObject.get({}).");
     266    evalAndExpectException("indexObject.get({})", "IDBDatabaseException.DATA_ERR");
     267
     268    debug("Passing an invalid key into indexObject.getKey({}).");
     269    evalAndExpectException("indexObject.getKey({})", "IDBDatabaseException.DATA_ERR");
     270
    280271    finishJSTest();
    281272}

  • trunk/LayoutTests/storage/indexeddb/resources/index-count.js

    r116337 r117702  
    2424    debug("preparing database");
    2525    self.trans = evalAndLog("trans = event.target.result");
    26     shouldBeTrue("trans !== null");
     26    shouldBeNonNull("trans");
    2727
    2828    deleteAllObjectStores(db);
    … …  
    4646    debug("verifying count without range");
    4747    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    48     shouldBeTrue("trans != null");
     48    shouldBeNonNull("trans");
    4949    trans.onabort = unexpectedAbortCallback;
    5050    trans.oncomplete = verifyCountWithRange;
    5151
    5252    store = evalAndLog("store = trans.objectStore('storeName')");
    53     shouldBeTrue("store != null");
     53    shouldBeNonNull("store");
    5454    index = evalAndLog("index = store.index('indexName')");
    55     shouldBeTrue("index != null");
     55    shouldBeNonNull("index");
    5656
    5757    request = evalAndLog("request = index.count()");
    5858    request.onerror = unexpectedErrorCallback;
    5959    request.onsuccess = function() {
    60          shouldBeTrue("typeof request.result == 'number'");
     60         shouldBeEqualToString("typeof request.result", "number");
    6161         shouldBe("request.result", "100");
    6262         // let the transaction complete
    … …  
    6969    debug("verifying count with range");
    7070    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    71     shouldBeTrue("trans != null");
     71    shouldBeNonNull("trans");
    7272    trans.onabort = unexpectedAbortCallback;
    7373    trans.oncomplete = verifyCountWithKey;
    7474
    7575    store = evalAndLog("store = trans.objectStore('storeName')");
    76     shouldBeTrue("store != null");
     76    shouldBeNonNull("store");
    7777    store = evalAndLog("index = trans.objectStore('storeName').index('indexName')");
    78     shouldBeTrue("index != null");
     78    shouldBeNonNull("index");
    7979
    8080    var tests = [
    … …  
    9696        request.onerror = unexpectedErrorCallback;
    9797        request.onsuccess = function() {
    98              shouldBeTrue("typeof request.result == 'number'");
     98             shouldBeEqualToString("typeof request.result", "number");
    9999             shouldBe("request.result", String(test.expected));
    100100
    … …  
    114114    debug("verifying count with key");
    115115    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    116     shouldBeTrue("trans != null");
     116    shouldBeNonNull("trans");
    117117    trans.onabort = unexpectedAbortCallback;
    118118    trans.oncomplete = finishJSTest;
    119119
    120120    store = evalAndLog("store = trans.objectStore('storeName')");
    121     shouldBeTrue("store != null");
     121    shouldBeNonNull("store");
    122122    store = evalAndLog("index = trans.objectStore('storeName').index('indexName')");
    123     shouldBeTrue("index != null");
     123    shouldBeNonNull("index");
    124124
    125125    evalAndExpectException("index.count(NaN)", "IDBDatabaseException.DATA_ERR");
    … …  
    139139        request.onerror = unexpectedErrorCallback;
    140140        request.onsuccess = function() {
    141              shouldBeTrue("typeof request.result == 'number'");
     141             shouldBeEqualToString("typeof request.result", "number");
    142142             shouldBe("request.result", String(test.expected));
    143143

  • trunk/LayoutTests/storage/indexeddb/resources/index-cursor.js

    r116337 r117702  
    3838{
    3939    self.trans = evalAndLog("trans = event.target.result");
    40     shouldBeTrue("trans !== null");
     40    shouldBeNonNull("trans");
    4141    trans.onabort = unexpectedAbortCallback;
    4242

  • trunk/LayoutTests/storage/indexeddb/resources/index-multientry.js

    r116337 r117702  
    2626    debug("Creating empty stores and indexes");
    2727    var trans = evalAndLog("trans = event.target.result");
    28     shouldBeTrue("trans !== null");
     28    shouldBeNonNull("trans");
    2929    trans.onabort = unexpectedAbortCallback;
    3030    trans.oncomplete = addData;
    … …  
    8080        if (cursor) {
    8181            ex = expected.shift();
    82             shouldBeTrue("ex != null");
     82            shouldBeNonNull("ex");
    8383            shouldBe("cursor.key", String(ex.key));
    8484            shouldBeEqualToString("cursor.primaryKey", ex.primaryKey);
    … …  
    8686            cursor.continue();
    8787        } else {
    88             shouldBeTrue("expected.length === 0");
     88            shouldBe("expected.length", "0");
    8989        }
    9090    };
    … …  
    129129
    130130        var trans = evalAndLog("trans = event.target.result");
    131         shouldBeTrue("trans !== null");
     131        shouldBeNonNull("trans");
    132132        trans.onabort = unexpectedAbortCallback;
    133133        trans.oncomplete = function() { verifyIndexes('index-new', finishJSTest); };

  • trunk/LayoutTests/storage/indexeddb/resources/index-population.js

    r112202 r117702  
    8585    debug("setVersion2Abort():");
    8686    shouldBe("db.objectStoreNames.length", "1");
    87     shouldBe("db.objectStoreNames[0]", "'store1'");
     87    shouldBeEqualToString("db.objectStoreNames[0]", "store1");
    8888    finishJSTest();
    8989}

  • trunk/LayoutTests/storage/indexeddb/resources/index-unique.js

    r116337 r117702  
    2727    debug("deleteExisting():");
    2828    var trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131    trans.oncomplete = setVersionCompleted;
    … …  
    8787{
    8888    debug("cursorSuccess():");
    89     shouldBe("event.target.result", "null");
     89    shouldBeNull("event.target.result");
    9090
    9191    // A key cursor starting at 1 should not find anything.
    … …  
    9898{
    9999    debug("keyCursorSuccess():");
    100     shouldBe("event.target.result", "null");
     100    shouldBeNull("event.target.result");
    101101
    102102    // Now we should be able to add a value with x: 1.

  • trunk/LayoutTests/storage/indexeddb/resources/key-type-array.js

    r116337 r117702  
    99{
    1010    removeVendorPrefixes();
    11 
    12     evalAndLog("IDBTransaction = self.IDBTransaction || self.IDBTransaction;");
    13     shouldBeFalse("IDBTransaction == null");
    14 
    15     evalAndLog("IDBDatabaseException = self.IDBDatabaseException || self.IDBDatabaseException;");
    16     shouldBeFalse("IDBDatabaseException == null");
    1711
    1812    name = self.location.pathname;

  • trunk/LayoutTests/storage/indexeddb/resources/keyrange.js

    r112202 r117702  
    119119    checkBoundKeyRange("'aaf'", "'abf'", true, true);
    120120
    121     try {
    122         debug("Passing an invalid key into only({})");
    123         IDBKeyRange.only({});
    124         testFailed("No exception thrown");
    125     } catch (e) {
    126         testPassed("Caught exception: " + e.toString());
    127     }
     121    debug("Passing an invalid key into only({})");
     122    evalAndExpectException("IDBKeyRange.only({})", "IDBDatabaseException.DATA_ERR");
    128123
    129     try {
    130         debug("Passing an invalid key into upperBound({})");
    131         IDBKeyRange.upperBound({});
    132         testFailed("No exception thrown");
    133     } catch (e) {
    134         testPassed("Caught exception: " + e.toString());
    135     }
     124    debug("Passing an invalid key into upperBound({})");
     125    evalAndExpectException("IDBKeyRange.upperBound({})", "IDBDatabaseException.DATA_ERR");
    136126
    137     try {
    138         debug("Passing an invalid key into lowerBound({})");
    139         IDBKeyRange.lowerBound({});
    140         testFailed("No exception thrown");
    141     } catch (e) {
    142         testPassed("Caught exception: " + e.toString());
    143     }
     127    debug("Passing an invalid key into lowerBound({})");
     128    evalAndExpectException("IDBKeyRange.lowerBound({})", "IDBDatabaseException.DATA_ERR");
    144129
    145     try {
    146         debug("Passing an invalid key into bound(null, {})");
    147         IDBKeyRange.bound(null, {});
    148         testFailed("No exception thrown");
    149     } catch (e) {
    150         testPassed("Caught exception: " + e.toString());
    151     }
     130    debug("Passing an invalid key into bound(null, {})");
     131    evalAndExpectException("IDBKeyRange.bound(null, {})", "IDBDatabaseException.DATA_ERR");
    152132
    153     try {
    154         debug("Passing an invalid key into bound({},null)");
    155         IDBKeyRange.bound({}, null);
    156         testFailed("No exception thrown");
    157     } catch (e) {
    158         testPassed("Caught exception: " + e.toString());
    159     }
     133    debug("Passing an invalid key into bound({},null)");
     134    evalAndExpectException("IDBKeyRange.bound({}, null)", "IDBDatabaseException.DATA_ERR");
    160135
    161     try {
    162         debug("Passing an invalid key into bound({}, {})");
    163         IDBKeyRange.bound({}, {});
    164         testFailed("No exception thrown");
    165     } catch (e) {
    166         testPassed("Caught exception: " + e.toString());
    167     }
     136    debug("Passing an invalid key into bound({}, {})");
     137    evalAndExpectException("IDBKeyRange.bound({}, {})", "IDBDatabaseException.DATA_ERR");
    168138
    169139    debug("Lower key greater than higher key, bound(4, 3)");

  • trunk/LayoutTests/storage/indexeddb/resources/legacy-constants.js

    r116337 r117702  
    3636    debug("populating store...");
    3737    evalAndLog("trans = db.transaction('store', IDBTransaction.READ_WRITE)");
    38     shouldBe("trans.mode", "'readwrite'");
     38    shouldBeEqualToString("trans.mode", "readwrite");
    3939    evalAndLog("store = trans.objectStore('store');");
    4040    trans.onerror = unexpectedErrorCallback;
    … …  
    4949{
    5050    evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
    51     shouldBe("trans.mode", "'readonly'");
     51    shouldBeEqualToString("trans.mode", "readonly");
    5252    store = trans.objectStore('store');
    5353    evalAndLog("request = store.openCursor(null, IDBCursor.NEXT)");
    … …  
    5757        if (!cursor)
    5858            return;
    59         shouldBe("cursor.direction", "'next'");
     59        shouldBeEqualToString("cursor.direction", "next");
    6060        evalAndLog("cursor.continue();");
    6161    };
    … …  
    6666{
    6767    evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
    68     shouldBe("trans.mode", "'readonly'");
     68    shouldBeEqualToString("trans.mode", "readonly");
    6969    store = trans.objectStore('store');
    7070    evalAndLog("request = store.openCursor(null, IDBCursor.NEXT_NO_DUPLICATE)");
    … …  
    7474        if (!cursor)
    7575            return;
    76         shouldBe("cursor.direction", "'nextunique'");
     76        shouldBeEqualToString("cursor.direction", "nextunique");
    7777        evalAndLog("cursor.continue();");
    7878    };
    … …  
    8383{
    8484    evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
    85     shouldBe("trans.mode", "'readonly'");
     85    shouldBeEqualToString("trans.mode", "readonly");
    8686    store = trans.objectStore('store');
    8787    evalAndLog("request = store.openCursor(null, IDBCursor.PREV)");
    … …  
    9191        if (!cursor)
    9292            return;
    93         shouldBe("cursor.direction", "'prev'");
     93        shouldBeEqualToString("cursor.direction", "prev");
    9494        evalAndLog("cursor.continue();");
    9595    };
    … …  
    100100{
    101101    evalAndLog("trans = db.transaction('store', IDBTransaction.READ_ONLY)");
    102     shouldBe("trans.mode", "'readonly'");
     102    shouldBeEqualToString("trans.mode", "readonly");
    103103    store = trans.objectStore('store');
    104104    evalAndLog("request = store.openCursor(null, IDBCursor.NEXT)");
    … …  
    108108        if (!cursor)
    109109            return;
    110         shouldBe("cursor.direction", "'next'");
     110        shouldBeEqualToString("cursor.direction", "next");
    111111        evalAndLog("cursor.continue();");
    112112    };

  • trunk/LayoutTests/storage/indexeddb/resources/mutating-cursor.js

    r116337 r117702  
    2929    debug("setVersionSuccess():");
    3030    self.trans = evalAndLog("trans = event.target.result");
    31     shouldBeTrue("trans !== null");
     31    shouldBeNonNull("trans");
    3232    trans.onabort = unexpectedAbortCallback;
    3333    trans.oncomplete = openForwardCursor;

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-autoincrement.js

    r116337 r117702  
    2828    debug("setVersionSuccess():");
    2929    self.trans = evalAndLog("trans = event.target.result");
    30     shouldBeTrue("trans !== null");
     30    shouldBeNonNull("trans");
    3131    trans.onabort = unexpectedAbortCallback;
    3232    trans.oncomplete = setVersionCompleted;
    … …  
    4242
    4343    shouldBeEqualToString("store.name", "StoreWithKeyPath");
    44     shouldBe("store.keyPath", "'id'");
     44    shouldBeEqualToString("store.keyPath", "id");
    4545    shouldBe("storeNames.contains('StoreWithKeyPath')", "true");
    4646    shouldBe("storeNames.contains('StoreWithAutoIncrement')", "true");
    … …  
    182182            evalAndLog("expected = cursor.value.a.b.c.id + 1");
    183183        } else {
    184             shouldBe("cursor.value.foo", "'bar'");
     184            shouldBeEqualToString("cursor.value.foo", "bar");
    185185            shouldBe("cursor.value.a.b.c.id", "expected");
    186186            evalAndLog("expected = cursor.value.a.b.c.id + 1");

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-basics.js

    r117509 r117702  
    3030    debug("setVersionSuccess():");
    3131    self.trans = evalAndLog("trans = event.target.result");
    32     shouldBeTrue("trans !== null");
     32    shouldBeNonNull("trans");
    3333    trans.onabort = unexpectedAbortCallback;
    3434
    … …  
    7777
    7878    debug("Ask for an index that doesn't exist:");
    79     try {
    80         debug("index = store.index('asdf')");
    81         index = store.index('asdf');
    82         testFailed("Asking for a store that doesn't exist should have thrown.");
    83     } catch (err) {
    84         testPassed("Exception thrown.");
    85         code = err.code;
    86         shouldBe("code", "IDBDatabaseException.NOT_FOUND_ERR");
    87     }
    88 
     79    evalAndExpectException("store.index('asdf')", "IDBDatabaseException.NOT_FOUND_ERR");
    8980    createIndex();
    9081}
    … …  
    9485    debug("createIndex():");
    9586    var index = evalAndLog("index = store.createIndex('indexName', 'x', {unique: true})"); // true == unique requirement.
    96     shouldBeTrue("index !== null");
     87    shouldBeNonNull("index");
    9788    shouldBeTrue("store.indexNames.contains('indexName')");
    9889    index = evalAndLog("index = store.index('indexName')");
    99     shouldBeTrue("index !== null");
     90    shouldBeNonNull("index");
    10091
    10192    debug("Ask for an index that doesn't exist:");
    102     try {
    103         debug("index = store.index('asdf')");
    104         index = store.index('asdf');
    105         testFailed("Asking for a store that doesn't exist should have thrown.");
    106     } catch (err) {
    107         testPassed("Exception thrown.");
    108         code = err.code
    109         shouldBe("code", "IDBDatabaseException.NOT_FOUND_ERR");
    110     }
     93    evalAndExpectException("store.index('asdf')", "IDBDatabaseException.NOT_FOUND_ERR");
    11194    trans.oncomplete = testSetVersionAbort;
    11295}
    … …  
    125108
    126109    var setVersionTrans = evalAndLog("setVersionTrans = event.target.result");
    127     shouldBeTrue("setVersionTrans !== null");
     110    shouldBeNonNull("setVersionTrans");
    128111    setVersionTrans.oncomplete = unexpectedCompleteCallback;
    129112    setVersionTrans.onabort = checkMetadata;
    … …  
    170153    event = evt;
    171154    debug("Try to insert a value not handled by structured clone:");
    172     try {
    173         debug("store.add({x: 'bar', y: self}, 'bar')");
    174         store.add({x: 'bar', y: self}, 'bar');
    175         testFailed("Passing a DOM node as value should have thrown.");
    176     } catch (err) {
    177         testPassed("Exception thrown");
    178         code = err.code;
    179         // FIXME: When we move to DOM4-style exceptions this should look for the
    180         // name "DataCloneError".
    181         shouldBe("code", "25");
    182     }
     155    evalAndExpectException("store.add({x: 'bar', y: self}, 'bar')", "DOMException.DATA_CLONE_ERR");
    183156
    184157    debug("Try to insert data where key path yields a Date key:");
    … …  
    216189    transaction = evalAndLog("db.transaction(['storeName'], 'readwrite')");
    217190    transaction.onabort = unexpectedErrorCallback;
    218     var store = evalAndLog("store = transaction.objectStore('storeName')");
     191    store = evalAndLog("store = transaction.objectStore('storeName')");
    219192
    220193    evalAndExpectException("store.add({x: null}, 'validkey')", "IDBDatabaseException.DATA_ERR");
    … …  
    222195    transaction = evalAndLog("db.transaction(['storeName'], 'readwrite')");
    223196    transaction.onabort = unexpectedErrorCallback;
    224     var store = evalAndLog("store = transaction.objectStore('storeName')");
     197    store = evalAndLog("store = transaction.objectStore('storeName')");
    225198
    226199    request = evalAndLog("store.get('key')");

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-clear.js

    r112202 r117702  
    2626{
    2727    self.trans = evalAndLog("trans = event.target.result");
    28     shouldBeTrue("trans !== null");
     28    shouldBeNonNull("trans");
    2929
    3030    deleteAllObjectStores(db);

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-count.js

    r116337 r117702  
    2424    debug("preparing database");
    2525    self.trans = evalAndLog("trans = event.target.result");
    26     shouldBeTrue("trans !== null");
     26    shouldBeNonNull("trans");
    2727
    2828    deleteAllObjectStores(db);
    … …  
    4343    debug("verifying count without range");
    4444    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    45     shouldBeTrue("trans != null");
     45    shouldBeNonNull("trans");
    4646    trans.onabort = unexpectedAbortCallback;
    4747    trans.oncomplete = verifyCountWithRange;
    4848
    4949    store = evalAndLog("store = trans.objectStore('storeName')");
    50     shouldBeTrue("store != null");
     50    shouldBeNonNull("store");
    5151
    5252    request = evalAndLog("request = store.count()");
    5353    request.onerror = unexpectedErrorCallback;
    5454    request.onsuccess = function() {
    55          shouldBeTrue("typeof request.result == 'number'");
     55         shouldBeEqualToString("typeof request.result", "number");
    5656         shouldBe("request.result", "100");
    5757         // let the transaction complete
    … …  
    6464    debug("verifying count with range");
    6565    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    66     shouldBeTrue("trans != null");
     66    shouldBeNonNull("trans");
    6767    trans.onabort = unexpectedAbortCallback;
    6868    trans.oncomplete = verifyCountWithKey;
    6969
    7070    store = evalAndLog("store = trans.objectStore('storeName')");
    71     shouldBeTrue("store != null");
     71    shouldBeNonNull("store");
    7272
    7373    var tests = [
    … …  
    8989        request.onerror = unexpectedErrorCallback;
    9090        request.onsuccess = function() {
    91              shouldBeTrue("typeof request.result == 'number'");
     91             shouldBeEqualToString("typeof request.result", "number");
    9292             shouldBe("request.result", String(test.expected));
    9393
    … …  
    107107    debug("verifying count with key");
    108108    trans = evalAndLog("trans = db.transaction('storeName', 'readonly')");
    109     shouldBeTrue("trans != null");
     109    shouldBeNonNull("trans");
    110110    trans.onabort = unexpectedAbortCallback;
    111111    trans.oncomplete = finishJSTest;
    112112
    113113    store = evalAndLog("store = trans.objectStore('storeName')");
    114     shouldBeTrue("store != null");
     114    shouldBeNonNull("store");
    115115
    116116    evalAndExpectException("store.count(NaN)", "IDBDatabaseException.DATA_ERR");
    … …  
    130130        request.onerror = unexpectedErrorCallback;
    131131        request.onsuccess = function() {
    132             shouldBeTrue("typeof request.result == 'number'");
     132            shouldBeEqualToString("typeof request.result", "number");
    133133            shouldBe("request.result", String(test.expected));
    134134             if (tests.length) {

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-cursor.js

    r116337 r117702  
    3737{
    3838    self.trans = evalAndLog("trans = event.target.result");
    39     shouldBeTrue("trans !== null");
     39    shouldBeNonNull("trans");
    4040    trans.onabort = unexpectedAbortCallback;
    4141

  • trunk/LayoutTests/storage/indexeddb/resources/objectstore-removeobjectstore.js

    r112202 r117702  
    2626{
    2727    self.trans = evalAndLog("trans = event.target.result");
    28     shouldBeTrue("trans !== null");
     28    shouldBeNonNull("trans");
    2929
    3030    deleteAllObjectStores(db);
    … …  
    6363{
    6464    self.trans = evalAndLog("trans = event.target.result");
    65     shouldBeTrue("trans !== null");
     65    shouldBeNonNull("trans");
    6666    trans.onabort = unexpectedAbortCallback;
    6767

  • trunk/LayoutTests/storage/indexeddb/resources/open-cursor.js

    r116337 r117702  
    2828    // FIXME: check that we can iterate the cursor.
    2929    cursor = event.target.result;
    30     shouldBe("cursor.direction", "'next'");
    31     shouldBe("cursor.key", "'myKey'");
    32     shouldBe("cursor.value", "'myValue'");
     30    shouldBeEqualToString("cursor.direction", "next");
     31    shouldBeEqualToString("cursor.key", "myKey");
     32    shouldBeEqualToString("cursor.value", "myValue");
    3333    debug("");
    3434    debug("Passing an invalid key into .continue({}).");
    … …  
    6868    // FIXME: check that we can iterate the cursor.
    6969    cursor = event.target.result;
    70     shouldBe("cursor.direction", "'next'");
    71     shouldBe("cursor.key", "'myKey'");
    72     shouldBe("cursor.value", "'myValue'");
     70    shouldBeEqualToString("cursor.direction", "next");
     71    shouldBeEqualToString("cursor.key", "myKey");
     72    shouldBeEqualToString("cursor.value", "myValue");
    7373    debug("");
    7474    debug("Passing an invalid key into .continue({}).");
    … …  
    9191    debug("setVersionSuccess():");
    9292    self.trans = evalAndLog("trans = event.target.result");
    93     shouldBeTrue("trans !== null");
     93    shouldBeNonNull("trans");
    9494    trans.onabort = unexpectedAbortCallback;
    9595

  • trunk/LayoutTests/storage/indexeddb/resources/opencursor-key.js

    r116337 r117702  
    9393
    9494        if (count == 0) {
    95             shouldBe("cursor.key", "'237-23-7739'");
     95            shouldBeEqualToString("cursor.key", "237-23-7739");
    9696            shouldBe("JSON.stringify(cursor.value)", "JSON.stringify(objectStoreData[7].value)");
    9797            shouldBe("cursor.primaryKey", "cursor.key");
    … …  
    123123            shouldBe("JSON.stringify(cursor.value)",
    124124                     "JSON.stringify(objectStoreData[2].value)");
    125             shouldBe("cursor.primaryKey", "'237-23-7734'");
     125            shouldBeEqualToString("cursor.primaryKey", "237-23-7734");
    126126            evalAndLog("cursor.continue()");
    127127        } else if (count == 1) {
    … …  
    129129            shouldBe("JSON.stringify(cursor.value)",
    130130                     "JSON.stringify(objectStoreData[6].value)");
    131             shouldBe("cursor.primaryKey", "'237-23-7738'");
     131            shouldBeEqualToString("cursor.primaryKey", "237-23-7738");
    132132            evalAndLog("cursor.continue()");
    133133        } else if (count == 2) {
    … …  
    135135            shouldBe("JSON.stringify(cursor.value)",
    136136                     "JSON.stringify(objectStoreData[10].value)");
    137             shouldBe("cursor.primaryKey", "'237-23-7742'");
     137            shouldBeEqualToString("cursor.primaryKey", "237-23-7742");
    138138            evalAndLog("cursor.continue()");
    139139        } else if (count == 3) {
    … …  
    161161        if (count == 0) {
    162162            shouldBe("cursor.key", '180');
    163             shouldBe("cursor.primaryKey", "'237-23-7734'");
     163            shouldBeEqualToString("cursor.primaryKey", "237-23-7734");
    164164            evalAndLog("cursor.continue()");
    165165        } else if (count == 1) {
    166166            shouldBe("cursor.key", '180');
    167             shouldBe("cursor.primaryKey", "'237-23-7738'");
     167            shouldBeEqualToString("cursor.primaryKey", "237-23-7738");
    168168            evalAndLog("cursor.continue()");
    169169        } else if (count == 2) {
    170170            shouldBe("cursor.key", '180');
    171             shouldBe("cursor.primaryKey", "'237-23-7742'");
     171            shouldBeEqualToString("cursor.primaryKey", "237-23-7742");
    172172            evalAndLog("cursor.continue()");
    173173        } else if (count == 3) {

  • trunk/LayoutTests/storage/indexeddb/resources/prefetch-bugfix-108071.js

    r116337 r117702  
    3737    debug("setVersionSuccess():");
    3838    self.trans = evalAndLog("trans = event.target.result");
    39     shouldBeTrue("trans !== null");
     39    shouldBeNonNull("trans");
    4040    trans.onabort = unexpectedAbortCallback;
    4141    trans.oncomplete = iterateAndDeleteFirstElement;

  • trunk/LayoutTests/storage/indexeddb/resources/queued-commands.js

    r112202 r117702  
    2727    debug("setVersionSuccess():");
    2828    self.trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131

  • trunk/LayoutTests/storage/indexeddb/resources/request-event-propagation.js

    r116337 r117702  
    2727    debug("setVersionSuccess():");
    2828    self.trans = evalAndLog("trans = event.target.result");
    29     shouldBeTrue("trans !== null");
     29    shouldBeNonNull("trans");
    3030    trans.onabort = unexpectedAbortCallback;
    3131    evalAndLog("trans.oncomplete = startTest");

  • trunk/LayoutTests/storage/indexeddb/resources/setVersion-null.js

    r114672 r117702  
    2727function postSetVersion()
    2828{
    29     shouldBe("db.version", "'null'");
     29    shouldBeEqualToString("db.version", "null");
    3030    finishJSTest();
    3131}

  • trunk/LayoutTests/storage/indexeddb/resources/shared.js

    r115255 r117702  
    9292        testFailed("No exception thrown!" );
    9393    } catch (e) {
    94                 testPassed("Exception was thrown.");
    95                 if (eval("e instanceof " + expected))
    96                         testPassed(cmd + " threw " + e);
    97                 else
    98                         testFailed("Expected " + expected + " but saw " + e);
     94        testPassed("Exception was thrown.");
     95        if (eval("e instanceof " + expected))
     96            testPassed(cmd + " threw " + e);
     97        else
     98            testFailed("Expected " + expected + " but saw " + e);
    9999    }
    100100}
    … …  
    113113    debug("Deleted all object stores.");
    114114}
     115
     116// For Workers
     117if (!self.DOMException) {
     118    self.DOMException = {
     119        INDEX_SIZE_ERR: 1,
     120        DOMSTRING_SIZE_ERR: 2,
     121        HIERARCHY_REQUEST_ERR: 3,
     122        WRONG_DOCUMENT_ERR: 4,
     123        INVALID_CHARACTER_ERR: 5,
     124        NO_DATA_ALLOWED_ERR: 6,
     125        NO_MODIFICATION_ALLOWED_ERR: 7,
     126        NOT_FOUND_ERR: 8,
     127        NOT_SUPPORTED_ERR: 9,
     128        INUSE_ATTRIBUTE_ERR: 10,
     129        INVALID_STATE_ERR: 11,
     130        SYNTAX_ERR: 12,
     131        INVALID_MODIFICATION_ERR: 13,
     132        NAMESPACE_ERR: 14,
     133        INVALID_ACCESS_ERR: 15,
     134        VALIDATION_ERR: 16,
     135        TYPE_MISMATCH_ERR: 17,
     136        SECURITY_ERR: 18,
     137        NETWORK_ERR: 19,
     138        ABORT_ERR: 20,
     139        URL_MISMATCH_ERR: 21,
     140        QUOTA_EXCEEDED_ERR: 22,
     141        TIMEOUT_ERR: 23,
     142        INVALID_NODE_TYPE_ERR: 24,
     143        DATA_CLONE_ERR: 25
     144    };
     145}

  • trunk/LayoutTests/storage/indexeddb/resources/transaction-abort.js

    r116337 r117702  
    2828    debug("setVersionSuccess():");
    2929    self.trans = evalAndLog("trans = event.target.result");
    30     shouldBeTrue("trans !== null");
     30    shouldBeNonNull("trans");
    3131    trans.onabort = unexpectedAbortCallback;
    3232    evalAndLog("trans.oncomplete = startTest");

  • trunk/LayoutTests/storage/indexeddb/resources/transaction-and-objectstore-calls.js

    r114672 r117702  
    102102
    103103    trans = evalAndLog("trans = db.transaction(['store'])");
    104     shouldBeTrue("trans != null");
     104    shouldBeNonNull("trans");
    105105    trans.onabort = unexpectedAbortCallback;
    106106    trans.onerror = unexpectedErrorCallback;
    107107    trans.oncomplete = afterComplete;
    108108    evalAndLog("store = trans.objectStore('store')");
    109     shouldBeTrue("store != null");
     109    shouldBeNonNull("store");
    110110    evalAndLog("store.get('some_key')");
    111111}
    … …  
    114114{
    115115    debug("transaction complete, ensuring methods fail");
    116     shouldBeTrue("trans != null");
    117     shouldBeTrue("store != null");
     116    shouldBeNonNull("trans");
     117    shouldBeNonNull("store");
    118118    evalAndExpectException("trans.objectStore('store')", "IDBDatabaseException.NOT_ALLOWED_ERR");
    119119    evalAndExpectException("store.index('index')", "IDBDatabaseException.NOT_ALLOWED_ERR");

  • trunk/LayoutTests/storage/indexeddb/resources/transaction-basics.js

    r116337 r117702  
    4141    debug("addRemoveIDBObjects():");
    4242    var trans = evalAndLog("trans = event.target.result");
    43     shouldBeTrue("trans !== null");
     43    shouldBeNonNull("trans");
    4444    trans.addEventListener('abort', testSetVersionAbort2, true);
    4545    trans.oncomplete = unexpectedCompleteCallback;
    … …  
    6767    debug("addRemoveAddIDBObjects():");
    6868    var trans = evalAndLog("trans = event.target.result");
    69     shouldBeTrue("trans !== null");
     69    shouldBeNonNull("trans");
    7070    trans.addEventListener('abort', testSetVersionAbort3, false);
    7171    trans.oncomplete = unexpectedCompleteCallback;
    … …  
    9898    shouldBeFalse("event.cancelable");
    9999    var trans = evalAndLog("trans = event.target.result");
    100     shouldBeTrue("trans !== null");
     100    shouldBeNonNull("trans");
    101101    trans.onabort = testInactiveAbortedTransaction;
    102102    trans.oncomplete = unexpectedCompleteCallback;
    … …  
    141141    debug("addIDBObjectsAndCommit():");
    142142    var trans = evalAndLog("trans = event.target.result");
    143     shouldBeTrue("trans !== null");
     143    shouldBeNonNull("trans");
    144144    trans.onabort = unexpectedAbortCallback;
    145145
    … …  
    183183    debug("removeIDBObjects():");
    184184    var trans = evalAndLog("trans = event.target.result");
    185     shouldBeTrue("trans !== null");
     185    shouldBeNonNull("trans");
    186186    trans.onabort = testSetVersionAbort6;
    187187    trans.oncomplete = unexpectedCompleteCallback;
    … …  
    235235    debug("setVersionSuccess():");
    236236    self.trans = evalAndLog("trans = event.target.result");
    237     shouldBeTrue("trans !== null");
     237    shouldBeNonNull("trans");
    238238    trans.onabort = unexpectedAbortCallback;
    239239    trans.addEventListener('complete', completeCallback, false);
    … …  
    270270    testPassed("no exception thrown");
    271271    for (var i = 0; i < db.objectStoreNames.length; ++i) {
    272       shouldBeTrue("transaction.objectStore(" + JSON.stringify(db.objectStoreNames[i]) + ") != null");
     272      shouldBeNonNull("transaction.objectStore(" + JSON.stringify(db.objectStoreNames[i]) + ")");
    273273    }
    274274    testPassed("all stores present in transaction");

  • trunk/LayoutTests/storage/indexeddb/resources/transaction-event-propagation.js

    r116337 r117702  
    2626{
    2727    self.trans = evalAndLog("trans = event.target.result");
    28     shouldBeTrue("trans !== null");
     28    shouldBeNonNull("trans");
    2929    trans.onabort = unexpectedAbortCallback;
    3030    evalAndLog("trans.oncomplete = startTest");

  • trunk/LayoutTests/storage/indexeddb/resources/transaction-rollback.js

    r116337 r117702  
    5353{
    5454    debug("addSuccess():");
    55     shouldBe("event.target.result", "'rollbackKey123'");
     55    shouldBeEqualToString("event.target.result", "rollbackKey123");
    5656
    5757    request = evalAndLog("store.openCursor()");
    … …  
    8585    shouldBe("event.target.result", "undefined");
    8686
    87     shouldBe("cursor.value", "'rollbackValue'");
     87    shouldBeEqualToString("cursor.value", "rollbackValue");
    8888    finishJSTest();
    8989}

  • trunk/LayoutTests/storage/indexeddb/resources/two-version-changes.js

    r112202 r117702  
    99    removeVendorPrefixes();
    1010
    11     shouldBeFalse("indexedDB == null");
    12     shouldBeFalse("IDBTransaction == null");
     11    shouldBeNonNull("indexedDB");
     12    shouldBeNonNull("IDBTransaction");
    1313    openDBConnection();
    1414}

  • trunk/LayoutTests/storage/indexeddb/resources/values-odd-types.js

    r114672 r117702  
    6161            shouldBe("cursor.value.toString()", "validTypes[valueIndex].value.toString()");
    6262            if (valueIndex == 1) {
    63                 shouldBe("cursor.value.toUTCString()", "'Thu, 01 Jan 1970 00:00:00 GMT'");
     63                shouldBeEqualToString("cursor.value.toUTCString()", "Thu, 01 Jan 1970 00:00:00 GMT");
    6464            }
    6565            if (valueIndex == 3) {

  • trunk/LayoutTests/storage/indexeddb/setVersion-null-expected.txt

    r114672 r117702  
    99db = event.target.result
    1010db.setVersion(null);
    11 PASS db.version is 'null'
     11PASS db.version is "null"
    1212PASS successfullyParsed is true
    1313

  • trunk/LayoutTests/storage/indexeddb/transaction-abort-expected.txt

    r116337 r117702  
    1111setVersionSuccess():
    1212trans = event.target.result
    13 PASS trans !== null is true
     13PASS trans is non-null.
    1414trans.oncomplete = startTest
    1515Deleted all object stores.

  • trunk/LayoutTests/storage/indexeddb/transaction-and-objectstore-calls-expected.txt

    r114672 r117702  
    110110
    111111trans = db.transaction(['store'])
    112 PASS trans != null is true
     112PASS trans is non-null.
    113113store = trans.objectStore('store')
    114 PASS store != null is true
     114PASS store is non-null.
    115115store.get('some_key')
    116116transaction complete, ensuring methods fail
    117 PASS trans != null is true
    118 PASS store != null is true
     117PASS trans is non-null.
     118PASS store is non-null.
    119119Expecting exception from trans.objectStore('store')
    120120PASS Exception was thrown.

  • trunk/LayoutTests/storage/indexeddb/transaction-basics-expected.txt

    r116337 r117702  
    1717addRemoveIDBObjects():
    1818trans = event.target.result
    19 PASS trans !== null is true
     19PASS trans is non-null.
    2020store = db.createObjectStore('storeFail', null)
    2121index = store.createIndex('indexFail', 'x')
    … …  
    3030addRemoveAddIDBObjects():
    3131trans = event.target.result
    32 PASS trans !== null is true
     32PASS trans is non-null.
    3333store = db.createObjectStore('storeFail', null)
    3434index = store.createIndex('indexFail', 'x')
    … …  
    4747PASS event.cancelable is false
    4848trans = event.target.result
    49 PASS trans !== null is true
     49PASS trans is non-null.
    5050store = db.createObjectStore('storeFail', null)
    5151index = store.createIndex('indexFail', 'x')
    … …  
    9393addIDBObjectsAndCommit():
    9494trans = event.target.result
    95 PASS trans !== null is true
     95PASS trans is non-null.
    9696store = db.createObjectStore('storeFail', null)
    9797index = store.createIndex('indexFail', 'x')
    … …  
    139139removeIDBObjects():
    140140trans = event.target.result
    141 PASS trans !== null is true
     141PASS trans is non-null.
    142142store = trans.objectStore('storeFail')
    143143store.deleteIndex('indexFail')
    … …  
    152152setVersionSuccess():
    153153trans = event.target.result
    154 PASS trans !== null is true
     154PASS trans is non-null.
    155155Deleted all object stores.
    156156db.createObjectStore('storeName', null)
    … …  
    167167transaction = db.transaction(db.objectStoreNames)
    168168PASS no exception thrown
    169 PASS transaction.objectStore("storeName") != null is true
     169PASS transaction.objectStore("storeName") is non-null.
    170170PASS all stores present in transaction
    171171

  • trunk/LayoutTests/storage/indexeddb/transaction-event-propagation-expected.txt

    r116337 r117702  
    1010db.setVersion('new version')
    1111trans = event.target.result
    12 PASS trans !== null is true
     12PASS trans is non-null.
    1313trans.oncomplete = startTest
    1414Deleted all object stores.

  • trunk/LayoutTests/storage/indexeddb/transaction-rollback-expected.txt

    r116337 r117702  
    2020store.add('rollbackValue', 'rollbackKey123')
    2121addSuccess():
    22 PASS event.target.result is 'rollbackKey123'
     22PASS event.target.result is "rollbackKey123"
    2323store.openCursor()
    2424openCursorSuccess():
    … …  
    3131getSuccess():
    3232PASS event.target.result is undefined
    33 PASS cursor.value is 'rollbackValue'
     33PASS cursor.value is "rollbackValue"
    3434PASS successfullyParsed is true
    3535

  • trunk/LayoutTests/storage/indexeddb/two-version-changes-expected.txt

    r112490 r117702  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 PASS indexedDB == null is false
    9 PASS IDBTransaction == null is false
     8PASS indexedDB is non-null.
     9PASS IDBTransaction is non-null.
    1010self.state = 'starting'
    1111indexedDB.open('two-versions-one-connection')

  • trunk/LayoutTests/storage/indexeddb/values-odd-types-expected.txt

    r114672 r117702  
    2626cursor = event.target.result;
    2727PASS cursor.value.toString() is validTypes[valueIndex].value.toString()
    28 PASS cursor.value.toUTCString() is 'Thu, 01 Jan 1970 00:00:00 GMT'
     28PASS cursor.value.toUTCString() is "Thu, 01 Jan 1970 00:00:00 GMT"
    2929cursor.continue();
    3030valueIndex++;
Note: See TracChangeset for help on using the changeset viewer.