This repository has no description
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277"use strict"
function clean(tree) { if ('string'==typeof tree) return tree let ret = {type:tree.type} if (tree.args) ret.args = tree.args if (tree.content) ret.content = tree.content.map(x=>clean(x)) return ret}
function make_env() { let x = document.createElement('iframe') x.srcdoc}
function INIT(th, defs) { Object.defineProperties(th, defs) Object.seal(th)}
class Test { constructor({name}, input, lang, correct) { INIT(this, { name: {value: name}, lang: {value: lang}, input: {value: input}, correct: {value: correct}, status: {writable: true}, result: {writable: true}, parse_time: {writable: true}, }) this.reset() //if (Test.all.find(test=>test.input == input)) // console.warn('duplicate test!', this) if (Test.set.has(this.input)) return Test.all.push(this) Test.set.add(this.input) } run() { this.reset() let t, p try { p = performance.now() t = Test.LANGS.parse(this.input, this.lang) this.parse_time = performance.now() - p } catch (e) { console.warn('parse error?') this.parse_time = performance.now() - p this.status = -2 this.result = "Error during parsing!\n"+e+"\n"+e.stack return false } try { let p = new Comparator(this.correct, t) p.run() } catch (e) { this.status = -1 this.result = e return false } this.status = 1 this.result = "ok" return true } reset() { this.status = 0 this.result = null this.parse_time = null } to_entry() { return `🟩 ${this.name}\n${this.input}\n🟩 ${JSON.stringify(clean(this.correct))}` } //static all = [] static run_all() { for (let test of this.all) { test.run() } } static clear() { this.all = [] this.set = new Set() } static load_text(text) { this.clear() text = text.replace(/\r/g, "") // todo: indent? (\t*) and then \1 backref match on other lines let r = /^🟩[ \t]?(.*)\n([^🟩]*)\n🟩[ \t]*([{].*)$|(🟩)/gum let m while (m = r.exec(text)) { let [, name, input, output, fail] = m if (fail) { let line = text.substr(0, m.index).match(/\n/g).length+1 console.warn("error parsing tests file:", line) } else { let test = new Test({name: name}, input, "12y2", clean(JSON.parse(output))) } } }}Test.clear()
class InvalidTree extends Error { constructor(msg) { super(msg) this.name = 'InvalidTree' }}
class Mismatch extends Error { constructor(tree, thing, correct, got) { super(thing) this.correct = correct this.got = got this.tree = tree this.thing = thing this.name = 'Mismatch' } message() { return `${this.tree}\n${this.thing}\nExpect: ${safe_string(this.correct)}\n Got: ${safe_string(this.got)}` }}
function safe_string(obj) { if (obj===undefined) return "<empty>" try { return JSON.stringify(obj) } catch(e) { return "<???>" }}
// todo: this could be more fancy. integrate it with Test directly. instead of making a new one// rather than keeping a stack, just add annotations onto `correct` once at the start, then reuse them.class Comparator { constructor(correct, got) { this.stack = [] this.correct = correct this.got = got } run() { this.compare_node(this.correct, this.got) } mismatch(msg, correct, got) { throw new Mismatch(this.print(), msg, correct, got) } push(correct) { this.stack.push({node:correct}) } index(i) { this.stack[this.stack.length-1].index = i } pop() { this.stack.pop() } print() { let s = "", i = 0 for (let {node, index} of this.stack) { if (!node) break index = index==null ? "" : ""+(index+1)+" of "+node.content.length+" in " node = 'string'==typeof node ? JSON.stringify(node) : node.type let prefix = i==0 ? "" : " ".repeat(i-1)+"└ " s += prefix+index+node+"\n" i++ } return s } is_object(x) { return x && Object.getPrototypeOf(x)==Object.prototype } json_type(x) { if (x===null || x===undefined) return 'null' let t = typeof x if (t=='number' || t=='boolean' || t=='string') return t if (t=='object') { if (Array.isArray(x)) return 'array' if (this.is_object(x)) return 'object' } throw new InvalidTree("value has illegal type") } compare_args(correct, got) { if (correct==null) { if (got!=null) this.mismatch("node.args", correct, got) return } if (!this.is_object(correct)) { this.mismatch("ref node.args", 'object', correct) } if (!this.is_object(got)) this.mismatch("node.args", correct, got) for (let obj of [correct, got]) for (let key in obj) if (correct[key] !== got[key]) this.mismatch(`node.args.${key}`, correct[key], got[key]) } compare_content(correct, got) { // todo: whether a node has .content depends on the node type // i.e. /italic/ always has content, --- <hr> never does, etc. // so instead of this check, perhaps we should have a table of which blocks have contents? if (correct==null) { if (got!=null) this.mismatch("node.content", correct, got) return } // if (!Array.isArray(correct)) throw new Error("invalid .content in reference tree") if (!Array.isArray(got)) this.mismatch("node.content", correct, got) for (let i=0; i<correct.length || i<got.length; i++) { this.index(i) if (i >= correct.length) this.mismatch("node", undefined, got[i]) this.compare_node(correct[i], got[i]) } } compare_node(correct, got) { // string node if ('string'==typeof correct) { if (got !== correct) this.mismatch("textnode", correct, got) } else { // object node if (!this.is_object(correct)) { this.mismatch("ref node", 'object', correct) } if (!this.is_object(got)) this.mismatch("node", correct, got) if (got.type !== correct.type) this.mismatch("node.type", correct.type, got.type) // this.compare_args(correct.args, got.args) // this.push(correct) this.compare_content(correct.content, got.content) this.pop() } }}
/* // this makes the tests/results render immediately when the page loads, // but it's actually /too fast/ and it's hard to tell whether the tests actually ran
let x = new MutationObserver((events, observer)=>{ let pt = events.find(e=>e.target.id=='$data') observer.disconnect() run(pt.target.textContent) }).observe(document.body, { childList: true, subtree: true, })*/