risei 1.0.0

package/public/javascript/TestTuple.js

@@ -0,0 +1,244 @@
+/**/
+
+/* Defines what is found in a test-definition tuple (TDT).  Actual TDTs don't need to be instances of this class. */
+
+export class TestTuple {
+    // region Static fields
+
+    static longsByShort = new Map([
+        [ "for", "nature" ],
+        [ "on", "type" ],
+        [ "with", "initors" ],
+        [ "of", "method" ],
+        [ "plus", "spoofed" ],
+        [ "in", "inputs" ],
+        [ "out", "output" ],
+        [ "from", "source" ],
+        [ "and", "factors" ]
+    ]);
+
+    // endregion Static fields
+
+    // region Private fields
+
+    /* These longer names match the constructor-arg names. 
+       The short-name properties use the same fields. */
+
+    nature;
+    type;
+    initors;
+    method;
+    spoofed;
+    inputs;
+    output;
+    source;
+    factors;
+    
+    // endregion Private fields
+
+    // region Properties
+
+    // region Test definition, short names
+
+    /* These short names make JSON-like definitions easier. */
+
+    get for() {
+        return this.nature;
+    }
+
+    set for(value) {
+        this.nature = value;
+    }
+
+    get on() {
+        return this.type;
+    }
+
+    set on(value) {
+        this.type = value;
+    }
+
+    get with() {
+        return this.initors;
+    }
+
+    set with(value) {
+        this.initors = value;
+    }
+
+    get of() {
+        return this.method;
+    }
+
+    set of(value) {
+        this.method = value;
+    }
+
+    get plus() {
+        return this.spoofed;
+    }
+
+    set plus(value) {
+        this.spoofed = value;
+    }
+
+    get in() {
+        return this.inputs;
+    }
+
+    set in(value) {
+        this.inputs = value;
+    }
+
+    get out() {
+        return this.output;
+    }
+
+    set out(value) {
+        this.output = value;
+    }
+
+    get from() {
+        return this.source;
+    }
+
+    set from(value) {
+        this.source = value;
+    }
+    
+    get and() {
+        return this.factors;
+    }
+    
+    set and(value) {
+        this.factors = value;
+    }
+
+    // endregion Test definition, short names
+
+    // region Tuple state
+
+    get isRunnable() {
+        let isRunnable
+            = this.nature !== undefined
+            && this.type !== undefined
+            && this.initors !== undefined
+            && this.method !== undefined
+            && this.inputs !== undefined
+            && this.output !== undefined;
+
+        return isRunnable;
+    }
+
+    // endregion Tuple state
+
+    // endregion Properties
+
+    // region Initing, including constructor()
+
+    /* Constructor can't use param names like `for`, because when not .-prefixed, they are keywords. */
+
+    constructor(nature, type, spoofed, initors, method, inputs, output, source, factors) {
+        this.nature = nature;
+        this.type = type;
+        this.spoofed = spoofed;
+        this.initors = initors;
+        this.method = method;
+        this.inputs = inputs;
+        this.output = output;
+        this.source = source;
+        this.factors = factors;
+    }
+
+    static fromNonceTuples(nonces) {
+        // Throughput and output.
+        let full = new TestTuple();
+        let tuples = [];
+
+        // Looping over all.
+        for (let nonce of nonces) {
+            // Get latest test definition.
+            let latest = TestTuple.fromNonceTuple(nonce);
+
+            // Restarting test definitions when desired.
+            full = TestTuple.maybeRestartFull(full, latest);
+
+            // Merge any previous 
+            // values into latest.
+            latest.combineWith(full);
+
+            // Make latest the tuple for 
+            // combining with next time.
+            full = latest;
+
+            // Add latest only if it's 
+            // ready to run as a test.
+            if (latest.isRunnable) {
+                tuples.push(latest);
+            }
+        }
+
+        // Back to caller.
+        return tuples;
+    }
+
+    static fromNonceTuple(nonce) {
+        // Empty, since properties can be set 
+        // by either of two nonce naming styles.
+        let tuple = new TestTuple();
+
+        let shortNames = TestTuple.longsByShort.keys();
+
+        // Traversing matching pairs of names and applying 
+        // whichever one is present as the tuple property;
+        // if neither is present, the property is undefined.
+        for (let shortName of shortNames) {
+            let longName = TestTuple.longsByShort.get(shortName);
+            tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+        }
+
+        // Back to caller.
+        return tuple;
+    }
+
+    // region Dependencies of nonce-tuple initing methods
+
+    static maybeRestartFull(full, latest) {
+        // When a (new) model class is named, 
+        // wipe out all reused test values.
+        if (latest.type !== undefined) {
+            full = new TestTuple();
+        }
+
+        // When a (new) model method is named, wipe out reused 
+        // test values except the general ones for its class.
+        if (latest.method !== undefined) {
+            full = new TestTuple(
+                full.nature, full.type,
+                full.spoofed, full.initors
+            );
+        }
+
+        return full;
+    }
+
+    combineWith(other) {
+        let shortNames = TestTuple.longsByShort.keys();
+
+        for (let shortName of shortNames) {
+            TestTuple.combineValues(this, other, shortName);
+        }
+    }
+
+    static combineValues(self, other, name) {
+        // Property may still end up undefined.
+        if (self[name] === undefined) {
+            self[name] = other[name];
+        }
+    }
+
+    // endregion Dependencies of nonce-tuple initing methods
+
+    // endregion Initing, including constructor()
+
+}

package/public/javascript/TotalComparer.js

@@ -0,0 +1,229 @@
+/**/
+
+import { AComparer } from "./AComparer.js";
+
+export class TotalComparer extends AComparer {
+    constructor() {
+        super();
+    }
+    
+    compare(expected, actual) /* passed */ {
+        return this.#recurse(expected, actual);
+    }
+    
+    // region Dependencies of compare()
+    
+    #recurse(expected, actual) /* verified */ {
+        // These have to be tried in this order, 
+        // given how JS type identities overlap.
+        if (Array.isArray(expected)) {
+            /* Traverse / recurse to leaves. */
+            return this.#recurseOverArrays(expected, actual);
+        }
+        
+        if (expected instanceof Map) {
+            /* Traverse / recurse to leaves. */
+            return this.#recurseOverMaps(expected, actual);
+        }
+        
+        if (expected instanceof Set) {
+            /* Traverse / recurse to leaves. */
+            return this.#recurseOverSets(expected, actual);
+        }
+        
+        if (expected instanceof Function) {
+            /* Leaf to compare directly. */
+            return this.#compareFunctions(expected, actual);
+        }
+        
+        if (expected instanceof Object) {
+            /* Traverse / recurse to leaves. */
+            return this.#recurseOverObjects(expected, actual);
+        }
+        
+        /* If neither a function leaf nor any 
+           fork type, compare as a leaf value. */
+        return this.#compareValues(expected, actual);
+    }
+    
+    #recurseOverObjects(expected, actual) /* verified */ {
+        // Both must be objects.
+        if (!(actual instanceof Object)) {
+            return false;
+        }
+        
+        // There must not be any extra members 
+        // of `actual`, its own or inherited.
+        for (let propertyName in actual) {
+            if (!(propertyName in expected)) {
+                return false;
+            }
+        }
+
+        // All members of `expected`, its own or inherited, 
+        // must exist in `actual` and match it recursively.
+        for (let propertyName in expected) {
+            // Members present must match.
+            if (!(propertyName in actual)) {
+                return false;
+            }
+            
+            // Cross-recursion.
+            let areEqual = this.#recurse(expected[propertyName], actual[propertyName]);
+            
+            // Exit only at first false.
+            switch (areEqual) {
+                case true: continue;
+                case false: return false;
+            }
+        }
+
+        // No mismatched or missing found.
+        return true;
+    }
+    
+    #recurseOverMaps(expected, actual) /* verified */ {
+        // Both must be Maps.
+        if (!(actual instanceof Map)) {
+            return false;
+        }
+
+        // Must have same number of elements.
+        if (expected.size !== actual.size) {
+            return false;
+        }
+
+        let expectedKeys = expected.keys();
+        
+        // Looking at content found for each key.
+        for (let key of expectedKeys) {
+            // Get expected and any matching actual.
+            let expValue = expected.get(key);
+            let acValue = actual.get(key);
+            
+            // Cross-recursion.
+            let areEqual = this.#recurse(expValue, acValue);
+            
+            // Exit only at first false.
+            switch (areEqual) {
+                case true: continue;
+                case false: return false;
+            }
+        }
+
+        // No mismatched or missing found.
+        return true;
+    }
+    
+    #recurseOverSets(expected, actual) /* verified */ {
+        // Both must be Sets.
+        if (!(actual instanceof Set)) {
+            return false;
+        }
+        
+        // Must have same number of elements.
+        if (expected.size !== actual.size) {
+            return false;
+        }
+        
+        // Local copies allow ablative approach.
+        let localExpected = new Set(expected);
+        let localActual = new Set(actual);
+
+        // Looking at each element.
+        for (let item of localExpected) {
+            // If this one matches, remove it from both Sets 
+            // so that it isn't unnecessarily traversed later.
+            if (localActual.has(item)) {
+                localExpected.delete(item);
+                localActual.delete(item);
+                continue;
+            }
+        
+            // If this element doesn't match by value / identity, 
+            // try to match it against all remaining by content.
+            for (let against of localActual) {
+                let areEqual = this.#recurse(item, against);
+
+                // If matched by content, remove it from 
+                // both Sets for fewer later comparisons.
+                if (areEqual) {
+                    localExpected.delete(item);
+                    localActual.delete(against);
+                }
+            }
+        }
+        
+        // If all matched, all were removed 
+        // from both of the Sets by now.
+        if (localExpected.size === 0 && localActual.size === 0) {
+            return true;
+        }
+       
+        // One or more mismatched or never found.
+        return false;
+    }
+    
+    #recurseOverArrays(expected, actual) /* verified */ {
+        // Both must be arrays.
+        if (!Array.isArray(actual)) {
+            return false;
+        }
+
+        // Must have same number of elements.
+        if (actual.length !== expected.length) {
+            return false;
+        }
+
+        // Looking at content found at each index.
+        for (let at = 0; at < expected.length; at++) {
+            // Cross-recursion.
+            let areEqual = this.#recurse(expected[at], actual[at]);
+
+            // Exit only at first false.
+            switch (areEqual) {
+                case true: continue;
+                case false: return false;
+            }
+        }
+
+        // No mismatched found.
+        return true;
+    }
+    
+    #compareValues(expected, actual) /* verified */ {
+        if (actual === expected) {
+            return true;
+        }
+
+        return false;
+    }
+
+    #compareFunctions(expected, actual) /* verified */ {
+        // `expected` is already known to be a function / method.
+        if (!(actual instanceof Function)) {
+            return false;
+        }
+        
+        // The code contents, name, and `function` vs. lambda 
+        // style are compared here, for pretty exact matching.
+        let expectedCode = expected.toString();
+        let actualCode = actual.toString();
+        
+        // The leading keyword `function` is needed to declare a non-lambda function in a test, 
+        // but may not be present in an otherwise-equal actual, so it's removed if present.
+        expectedCode = expectedCode.replace(/^function(?=\s|\()/, "");
+        actualCode = actualCode.replace(/^function(?=\s|\()/, "");
+        
+        // Any leading and trailing whitespace is removed, since it's meaningless.
+        expectedCode = expectedCode.trim();
+        actualCode = actualCode.trim();
+        
+        // Actually comparing.
+        return expectedCode === actualCode;
+    }
+
+    // endregion Dependencies of compare()
+
+}
+