| /* |
| 2022-05-22 |
| |
| The author disclaims copyright to this source code. In place of a |
| legal notice, here is a blessing: |
| |
| * May you do good and not evil. |
| * May you find forgiveness for yourself and forgive others. |
| * May you share freely, never taking more than you give. |
| |
| *********************************************************************** |
| |
| This file contains bootstrapping code used by various test scripts |
| which live in this file's directory. |
| */ |
| 'use strict'; |
| (function(self){ |
| /* querySelectorAll() proxy */ |
| const EAll = function(/*[element=document,] cssSelector*/){ |
| return (arguments.length>1 ? arguments[0] : document) |
| .querySelectorAll(arguments[arguments.length-1]); |
| }; |
| /* querySelector() proxy */ |
| const E = function(/*[element=document,] cssSelector*/){ |
| return (arguments.length>1 ? arguments[0] : document) |
| .querySelector(arguments[arguments.length-1]); |
| }; |
| |
| /** |
| Helpers for writing sqlite3-specific tests. |
| */ |
| self.SqliteTestUtil = { |
| /** Running total of the number of tests run via |
| this API. */ |
| counter: 0, |
| /** |
| If expr is a function, it is called and its result |
| is returned, coerced to a bool, else expr, coerced to |
| a bool, is returned. |
| */ |
| toBool: function(expr){ |
| return (expr instanceof Function) ? !!expr() : !!expr; |
| }, |
| /** abort() if expr is false. If expr is a function, it |
| is called and its result is evaluated. |
| */ |
| assert: function f(expr, msg){ |
| if(!f._){ |
| f._ = ('undefined'===typeof abort |
| ? (msg)=>{throw new Error(msg)} |
| : abort); |
| } |
| ++this.counter; |
| if(!this.toBool(expr)){ |
| f._(msg || "Assertion failed."); |
| } |
| return this; |
| }, |
| /** Identical to assert() but throws instead of calling |
| abort(). */ |
| affirm: function(expr, msg){ |
| ++this.counter; |
| if(!this.toBool(expr)) throw new Error(msg || "Affirmation failed."); |
| return this; |
| }, |
| /** Calls f() and squelches any exception it throws. If it |
| does not throw, this function throws. */ |
| mustThrow: function(f, msg){ |
| ++this.counter; |
| let err; |
| try{ f(); } catch(e){err=e;} |
| if(!err) throw new Error(msg || "Expected exception."); |
| return this; |
| }, |
| /** |
| Works like mustThrow() but expects filter to be a regex, |
| function, or string to match/filter the resulting exception |
| against. If f() does not throw, this test fails and an Error is |
| thrown. If filter is a regex, the test passes if |
| filter.test(error.message) passes. If it's a function, the test |
| passes if filter(error) returns truthy. If it's a string, the |
| test passes if the filter matches the exception message |
| precisely. In all other cases the test fails, throwing an |
| Error. |
| |
| If it throws, msg is used as the error report unless it's falsy, |
| in which case a default is used. |
| */ |
| mustThrowMatching: function(f, filter, msg){ |
| ++this.counter; |
| let err; |
| try{ f(); } catch(e){err=e;} |
| if(!err) throw new Error(msg || "Expected exception."); |
| let pass = false; |
| if(filter instanceof RegExp) pass = filter.test(err.message); |
| else if(filter instanceof Function) pass = filter(err); |
| else if('string' === typeof filter) pass = (err.message === filter); |
| if(!pass){ |
| throw new Error(msg || ("Filter rejected this exception: "+err.message)); |
| } |
| return this; |
| }, |
| /** Throws if expr is truthy or expr is a function and expr() |
| returns truthy. */ |
| throwIf: function(expr, msg){ |
| ++this.counter; |
| if(this.toBool(expr)) throw new Error(msg || "throwIf() failed"); |
| return this; |
| }, |
| /** Throws if expr is falsy or expr is a function and expr() |
| returns falsy. */ |
| throwUnless: function(expr, msg){ |
| ++this.counter; |
| if(!this.toBool(expr)) throw new Error(msg || "throwUnless() failed"); |
| return this; |
| }, |
| |
| /** |
| Parses window.location.search-style string into an object |
| containing key/value pairs of URL arguments (already |
| urldecoded). The object is created using Object.create(null), |
| so contains only parsed-out properties and has no prototype |
| (and thus no inherited properties). |
| |
| If the str argument is not passed (arguments.length==0) then |
| window.location.search.substring(1) is used by default. If |
| neither str is passed in nor window exists then false is returned. |
| |
| On success it returns an Object containing the key/value pairs |
| parsed from the string. Keys which have no value are treated |
| has having the boolean true value. |
| |
| Pedantic licensing note: this code has appeared in other source |
| trees, but was originally written by the same person who pasted |
| it into those trees. |
| */ |
| processUrlArgs: function(str) { |
| if( 0 === arguments.length ) { |
| if( ('undefined' === typeof window) || |
| !window.location || |
| !window.location.search ) return false; |
| else str = (''+window.location.search).substring(1); |
| } |
| if( ! str ) return false; |
| str = (''+str).split(/#/,2)[0]; // remove #... to avoid it being added as part of the last value. |
| const args = Object.create(null); |
| const sp = str.split(/&+/); |
| const rx = /^([^=]+)(=(.+))?/; |
| var i, m; |
| for( i in sp ) { |
| m = rx.exec( sp[i] ); |
| if( ! m ) continue; |
| args[decodeURIComponent(m[1])] = (m[3] ? decodeURIComponent(m[3]) : true); |
| } |
| return args; |
| } |
| }; |
| |
| /** |
| This is a module object for use with the emscripten-installed |
| sqlite3InitModule() factory function. |
| */ |
| self.sqlite3TestModule = { |
| /** |
| Array of functions to call after Emscripten has initialized the |
| wasm module. Each gets passed the Emscripten module object |
| (which is _this_ object). |
| */ |
| postRun: [ |
| /* function(theModule){...} */ |
| ], |
| //onRuntimeInitialized: function(){}, |
| /* Proxy for C-side stdout output. */ |
| print: (...args)=>{console.log(...args)}, |
| /* Proxy for C-side stderr output. */ |
| printErr: (...args)=>{console.error(...args)}, |
| /** |
| Called by the Emscripten module init bits to report loading |
| progress. It gets passed an empty argument when loading is done |
| (after onRuntimeInitialized() and any this.postRun callbacks |
| have been run). |
| */ |
| setStatus: function f(text){ |
| if(!f.last){ |
| f.last = { text: '', step: 0 }; |
| f.ui = { |
| status: E('#module-status'), |
| progress: E('#module-progress'), |
| spinner: E('#module-spinner') |
| }; |
| } |
| if(text === f.last.text) return; |
| f.last.text = text; |
| if(f.ui.progress){ |
| f.ui.progress.value = f.last.step; |
| f.ui.progress.max = f.last.step + 1; |
| } |
| ++f.last.step; |
| if(text) { |
| f.ui.status.classList.remove('hidden'); |
| f.ui.status.innerText = text; |
| }else{ |
| if(f.ui.progress){ |
| f.ui.progress.remove(); |
| f.ui.spinner.remove(); |
| delete f.ui.progress; |
| delete f.ui.spinner; |
| } |
| f.ui.status.classList.add('hidden'); |
| } |
| }, |
| /** |
| Config options used by the Emscripten-dependent initialization |
| which happens via this.initSqlite3(). This object gets |
| (indirectly) passed to sqlite3ApiBootstrap() to configure the |
| sqlite3 API. |
| */ |
| sqlite3ApiConfig: { |
| wasmfsOpfsDir: "/opfs" |
| }, |
| /** |
| Intended to be called by apps which need to call the |
| Emscripten-installed sqlite3InitModule() routine. This function |
| temporarily installs this.sqlite3ApiConfig into the self |
| object, calls it sqlite3InitModule(), and removes |
| self.sqlite3ApiConfig after initialization is done. Returns the |
| promise from sqlite3InitModule(), and the next then() handler |
| will get the sqlite3 API object as its argument. |
| */ |
| initSqlite3: function(){ |
| self.sqlite3ApiConfig = this.sqlite3ApiConfig; |
| return self.sqlite3InitModule(this).finally(()=>delete self.sqlite3ApiConfig); |
| } |
| }; |
| })(self/*window or worker*/); |
