1 files changed, 66 insertions, 68 deletions

diff --git a/ext/wasm/testing2.js b/ext/wasm/testing2.js
index 3a279513f..0a31c470a 100644
--- a/ext/wasm/testing2.js
+++ b/ext/wasm/testing2.js
@@ -10,17 +10,17 @@
 
   ***********************************************************************
 
-  A basic test script for sqlite3-worker.js.
+  A basic test script for sqlite3-worker1.js.
 */
 'use strict';
 (function(){
   const T = self.SqliteTestUtil;
-  const SW = new Worker("api/sqlite3-worker.js");
+  const SW = new Worker("sqlite3-worker1.js");
   const DbState = {
     id: undefined
   };
   const eOutput = document.querySelector('#test-output');
-  const log = console.log.bind(console)
+  const log = console.log.bind(console);
   const logHtml = function(cssClass,...args){
     log.apply(this, args);
     const ln = document.createElement('div');
@@ -31,24 +31,13 @@
   const warn = console.warn.bind(console);
   const error = console.error.bind(console);
   const toss = (...args)=>{throw new Error(args.join(' '))};
-  /** Posts a worker message as {type:type, data:data}. */
-  const wMsg = function(type,data){
-    log("Posting message to worker dbId="+(DbState.id||'default')+':',data);
-    SW.postMessage({
-      type,
-      dbId: DbState.id,
-      data,
-      departureTime: performance.now()
-    });
-    return SW;
-  };
 
   SW.onerror = function(event){
     error("onerror",event);
   };
 
   let startTime;
-  
+
   /**
      A queue for callbacks which are to be run in response to async
      DB commands. See the notes in runTests() for why we need
@@ -74,28 +63,37 @@
     logHtml("","Total test count:",T.counter+". Total time =",(performance.now() - startTime),"ms");
   };
 
-  const logEventResult = function(evd){
+  const logEventResult = function(ev){
+    const evd = ev.result;
     logHtml(evd.errorClass ? 'error' : '',
-            "runOneTest",evd.messageId,"Worker time =",
-            (evd.workerRespondTime - evd.workerReceivedTime),"ms.",
+            "runOneTest",ev.messageId,"Worker time =",
+            (ev.workerRespondTime - ev.workerReceivedTime),"ms.",
             "Round-trip event time =",
-            (performance.now() - evd.departureTime),"ms.",
-            (evd.errorClass ? evd.message : "")
+            (performance.now() - ev.departureTime),"ms.",
+            (evd.errorClass ? ev.message : "")//, JSON.stringify(evd)
            );
   };
 
-  const runOneTest = function(eventType, eventData, callback){
-    T.assert(eventData && 'object'===typeof eventData);
+  const runOneTest = function(eventType, eventArgs, callback){
+    T.assert(eventArgs && 'object'===typeof eventArgs);
     /* ^^^ that is for the testing and messageId-related code, not
        a hard requirement of all of the Worker-exposed APIs. */
-    eventData.messageId = MsgHandlerQueue.push(eventType,function(ev){
-      logEventResult(ev.data);
+    const messageId = MsgHandlerQueue.push(eventType,function(ev){
+      logEventResult(ev);
       if(callback instanceof Function){
         callback(ev);
         testCount();
       }
     });
-    wMsg(eventType, eventData);
+    const msg = {
+      type: eventType,
+      args: eventArgs,
+      dbId: DbState.id,
+      messageId: messageId,
+      departureTime: performance.now()
+    };
+    log("Posting",eventType,"message to worker dbId="+(DbState.id||'default')+':',msg);
+    SW.postMessage(msg);
   };
 
   /** Methods which map directly to onmessage() event.type keys.
@@ -103,23 +101,31 @@
   const dbMsgHandler = {
     open: function(ev){
       DbState.id = ev.dbId;
-      log("open result",ev.data);
+      log("open result",ev);
     },
     exec: function(ev){
-      log("exec result",ev.data);
+      log("exec result",ev);
     },
     export: function(ev){
-      log("export result",ev.data);
+      log("export result",ev);
     },
     error: function(ev){
-      error("ERROR from the worker:",ev.data);
-      logEventResult(ev.data);
+      error("ERROR from the worker:",ev);
+      logEventResult(ev);
     },
     resultRowTest1: function f(ev){
       if(undefined === f.counter) f.counter = 0;
-      if(ev.data) ++f.counter;
-      //log("exec() result row:",ev.data);
-      T.assert(null===ev.data || 'number' === typeof ev.data.b);
+      if(null === ev.rowNumber){
+        /* End of result set. */
+        T.assert(undefined === ev.row)
+          .assert(Array.isArray(ev.columnNames))
+          .assert(ev.columnNames.length);
+      }else{
+        T.assert(ev.rowNumber > 0);
+        ++f.counter;
+      }
+      //log("exec() result row:",ev);
+      T.assert(null === ev.rowNumber || 'number' === typeof ev.row.b);
     }
   };
 
@@ -143,33 +149,33 @@
       throw new Error("This is not supposed to be reached.");
     };
     runOneTest('exec',{
-      sql: ["create table t(a,b)",
+      sql: ["create table t(a,b);",
             "insert into t(a,b) values(1,2),(3,4),(5,6)"
-           ].join(';'),
-      multi: true,
+           ],
       resultRows: [], columnNames: []
     }, function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(0===ev.resultRows.length)
         .assert(0===ev.columnNames.length);
     });
     runOneTest('exec',{
       sql: 'select a a, b b from t order by a',
-      resultRows: [], columnNames: [],
+      resultRows: [], columnNames: [], saveSql:[]
     }, function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(3===ev.resultRows.length)
         .assert(1===ev.resultRows[0][0])
         .assert(6===ev.resultRows[2][1])
         .assert(2===ev.columnNames.length)
         .assert('b'===ev.columnNames[1]);
     });
+    //if(1){ error("Returning prematurely for testing."); return; }
     runOneTest('exec',{
       sql: 'select a a, b b from t order by a',
       resultRows: [], columnNames: [],
       rowMode: 'object'
     }, function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(3===ev.resultRows.length)
         .assert(1===ev.resultRows[0].a)
         .assert(6===ev.resultRows[2].b)
@@ -181,7 +187,7 @@
       resultRows: [],
       //rowMode: 'array', // array is the default in the Worker interface
     }, function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(1 === ev.resultRows.length)
         .assert(1 === ev.resultRows[0][0]);
     });
@@ -194,19 +200,19 @@
       dbMsgHandler.resultRowTest1.counter = 0;
     });
     runOneTest('exec',{
-      multi: true,
       sql:[
-        'pragma foreign_keys=0;',
+        "pragma foreign_keys=0;",
         // ^^^ arbitrary query with no result columns
-        'select a, b from t order by a desc; select a from t;'
-        // multi-exec only honors results from the first
+        "select a, b from t order by a desc;",
+        "select a from t;"
+        // multi-statement exec only honors results from the first
         // statement with result columns (regardless of whether)
         // it has any rows).
       ],
       rowMode: 1,
       resultRows: []
     },function(ev){
-      const rows = ev.data.resultRows;
+      const rows = ev.result.resultRows;
       T.assert(3===rows.length).
         assert(6===rows[0]);
     });
@@ -215,14 +221,14 @@
       sql: 'select count(a) from t',
       resultRows: []
     },function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(1===ev.resultRows.length)
         .assert(2===ev.resultRows[0][0]);
     });
     if(0){
       // export requires reimpl. for portability reasons.
       runOneTest('export',{}, function(ev){
-        ev = ev.data;
+        ev = ev.result;
         T.assert('string' === typeof ev.filename)
           .assert(ev.buffer instanceof Uint8Array)
           .assert(ev.buffer.length > 1024)
@@ -231,11 +237,11 @@
     }
     /***** close() tests must come last. *****/
     runOneTest('close',{unlink:true},function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert('string' === typeof ev.filename);
     });
     runOneTest('close',{unlink:true},function(ev){
-      ev = ev.data;
+      ev = ev.result;
       T.assert(undefined === ev.filename);
     });
   };
@@ -261,16 +267,8 @@
        will fail and we have no way of cancelling them once they've
        been posted to the worker.
 
-       We currently do (2) because (A) it's certainly the most
-       client-friendly thing to do and (B) it seems likely that most
-       apps using this API will only have a single db to work with so
-       won't need to juggle multiple DB ids. If we revert to (1) then
-       the following call to runTests2() needs to be moved into the
-       callback function of the runOneTest() check for the 'open'
-       command. Note, also, that using approach (2) does not keep the
-       user from instead using approach (1), noting that doing so
-       requires explicit handling of the 'open' message to account for
-       it.
+       Which approach we use below depends on the boolean value of
+       waitForOpen.
     */
     const waitForOpen = 1,
           simulateOpenError = 0 /* if true, the remaining tests will
@@ -284,11 +282,11 @@
       filename:'testing2.sqlite3',
       simulateError: simulateOpenError
     }, function(ev){
-      //log("open result",ev);
-      T.assert('testing2.sqlite3'===ev.data.filename)
-        .assert(ev.data.dbId)
-        .assert(ev.data.messageId);
-      DbState.id = ev.data.dbId;
+      log("open result",ev);
+      T.assert('testing2.sqlite3'===ev.result.filename)
+        .assert(ev.dbId)
+        .assert(ev.messageId);
+      DbState.id = ev.dbId;
       if(waitForOpen) setTimeout(runTests2, 0);
     });
     if(!waitForOpen) runTests2();
@@ -301,7 +299,7 @@
     }
     ev = ev.data/*expecting a nested object*/;
     //log("main window onmessage:",ev);
-    if(ev.data && ev.data.messageId){
+    if(ev.result && ev.messageId){
       /* We're expecting a queued-up callback handler. */
       const f = MsgHandlerQueue.shift();
       if('error'===ev.type){
@@ -314,8 +312,8 @@
     }
     switch(ev.type){
         case 'sqlite3-api':
-          switch(ev.data){
-              case 'worker-ready':
+          switch(ev.result){
+              case 'worker1-ready':
                 log("Message:",ev);
                 self.sqlite3TestModule.setStatus(null);
                 runTests();