| /* | |
| 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. | |
| */ | |
| ; | |
| (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*/); | |