risei 3.3.1 → 3.3.3

package/system/TestDef.js

@@ -13,481 +13,436 @@ import TotalDisplayer from "./TotalDisplayer.js";
 export default class TestDef {
     // region Definitions
 
-    static staticName = "static";
-    static instanceName = "instance";
-    static throwName = "throw";
-    static polyName = "poly";
-    static constructorName = "constructor";
-    static nonceLocalCallableName = "nonce";
+        static staticName = "static";
+        static instanceName = "instance";
+        static throwName = "throw";
+        static polyName = "poly";
+        static constructorName = "constructor";
+        static nonceLocalCallableName = "nonce";
 
-    // endregion Definitions
+        // endregion Definitions
 
     // 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" ],
-        [ "do", "enact" ],
-        [ "undo", "counteract" ]
-    ]);
-
-    // endregion Static fields
+        static longsByShort = new Map([
+            [ "for", "nature" ],
+            [ "on", "type" ],
+            [ "with", "initors" ],
+            [ "of", "method" ],
+            [ "plus", "spoofed" ],
+            [ "in", "inputs" ],
+            [ "out", "output" ],
+            [ "from", "source" ],
+            [ "and", "factors" ],
+            [ "do", "enact" ],
+            [ "undo", "counteract" ]
+        ]);
+
+        // endregion Static fields
 
     // region 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;
-    enact;
-    counteract;
-
-    target;
-    
-    actual;
-    thrown;   // Throw in inner scope (tested code).
-    trouble;  // Throw in outer scope (test system or .do / .undo / .from).
-    
-    // endregion 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;
+        enact;
+        counteract;
+
+        target;
+        
+        actual;
+        thrown;   // Throw in inner scope (tested code).
+        trouble;  // Throw in outer scope (test system or .do / .undo / .from).
+        
+        // endregion Fields
 
     // region Definition properties 
 
-    /* These short names make JSON-like definitions easier. */
+        /* These short names make JSON-like definitions easier. */
 
-    get for() {
-        return this.nature;
-    }
+        get for() { return this.nature; }
 
-    set for(value) {
-        this.nature = value;
-    }
+        set for(value) { this.nature = value; }
 
-    get on() {
-        return this.type;
-    }
+        get on() { return this.type; }
 
-    set on(value) {
-        this.type = value;
-    }
+        set on(value) { this.type = value; }
 
-    get with() {
-        return this.initors;
-    }
+        get with() { return this.initors; }
 
-    set with(value) {
-        this.initors = value;
-    }
+        set with(value) { this.initors = value; }
 
-    get of() {
-        return this.method;
-    }
+        get of() { return this.method; }
 
-    set of(value) {
-        this.method = value;
-    }
+        set of(value) { this.method = value; }
 
-    get plus() {
-        return this.spoofed;
-    }
+        get plus() { return this.spoofed; }
 
-    set plus(value) {
-        this.spoofed = value;
-    }
-    
-    get in() {
-        return this.inputs;
-    }
+        set plus(value) { this.spoofed = value; }
+        
+        get in() { return this.inputs; }
 
-    set in(value) {
-        this.inputs = value;
-    }
+        set in(value) { this.inputs = value; }
 
-    get out() {
-        return this.output;
-    }
+        get out() { return this.output; }
 
-    set out(value) {
-        this.output = value;
-    }
+        set out(value) { this.output = value; }
 
-    get from() {
-        return this.source;
-    }
+        get from() { return this.source; }
 
-    set from(value) {
-        this.source = value;
-    }
-    
-    get and() {
-        return this.factors;
-    }
-    
-    set and(value) {
-        this.factors = value;
-    }
+        set from(value) { this.source = value; }
+        
+        get and() { return this.factors; }
+        
+        set and(value) { this.factors = value; }
 
-    get do() {
-        return this.enact;
-    }
-    
-    set do(value) {
-        this.enact = value;
-    }
-    
-    get undo() {
-        return this.counteract;
-    }
-    
-    set undo(value) {
-        this.counteract = value;
-    }
+        get do() { return this.enact; }
+        
+        set do(value) { this.enact = value; }
+        
+        get undo() { return this.counteract; }
+        
+        set undo(value) { this.counteract = value; }
 
-    // endregion Definition properties
+        // endregion Definition properties
 
     // region State properties
 
-    get isRunnable() /* passed */ {
-        let isRunnable
-            = this.nature !== undefined
-            && this.type !== undefined
-            && this.initors !== undefined
-            && this.method !== undefined
-            && this.inputs !== undefined
-            && this.output !== undefined;
+        get isRunnable() /* passed */ {
+            let isRunnable
+                = this.nature !== undefined
+                && this.type !== undefined
+                && this.initors !== undefined
+                && this.method !== undefined
+                && this.inputs !== undefined
+                && this.output !== undefined;
 
-        return isRunnable;
-    }
-
-    get isInstanceTest() /* passed */ {
-        return this.#isNamedTypeTest(
-            TestDef.instanceName, 
-            TestDef.staticName, 
-            TypeAnalyzer.isInstanceMember
-        );
-    }
+            return isRunnable;
+        }
 
-    get isStaticTest() /* passed */ {
-        return this.#isNamedTypeTest(
-            TestDef.staticName, 
-            TestDef.instanceName, 
-            TypeAnalyzer.isStaticMember
-        );
-    }
+        get isInstanceTest() /* passed */ {
+            return this.#isNamedTypeTest(
+                TestDef.instanceName, 
+                TestDef.staticName, 
+                TypeAnalyzer.isInstanceMember
+            );
+        }
 
-    get isThrowTest() /* passed */ {
-        let is = this.andStringContains(TestDef.throwName);
-        return is;
-    }
+        get isStaticTest() /* passed */ {
+            return this.#isNamedTypeTest(
+                TestDef.staticName, 
+                TestDef.instanceName, 
+                TypeAnalyzer.isStaticMember
+            );
+        }
 
-    get isMonoCallTest() /* passed */ {
-        return !this.isPolyCallTest;
-    }
+        get isThrowTest() /* passed */ {
+            let is = this.andStringContains(TestDef.throwName);
+            return is;
+        }
 
-    get isPolyCallTest() /* passed */ {
-        let is = this.andStringContains(TestDef.polyName);
-        return is;
-    }
+        get isMonoCallTest() /* passed */ {
+            return !this.isPolyCallTest;
+        }
 
-    get isConstructorTest() /* passed */ {
-        let plainTarget = NameAnalyzer.plainNameOf(this.of);
-        return plainTarget === TestDef.constructorName;
-    }
+        get isPolyCallTest() /* passed */ {
+            let is = this.andStringContains(TestDef.polyName);
+            return is;
+        }
 
-    get isMethodTest() /* passed */ {
-        return !this.isPropertyTest && !this.isConstructorTest;
-    }
+        get isConstructorTest() /* passed */ {
+            let plainTarget = NameAnalyzer.plainNameOf(this.of);
+            return plainTarget === TestDef.constructorName;
+        }
 
-    get isPropertyTest() /* passed */ {
-        let plainName = NameAnalyzer.plainNameOf(this.of);
-        
-        let isPropertyTest 
-            = NameAnalyzer.hasPropertySigil(this.of) 
-            || TypeAnalyzer.isPropertyMember(this.on, plainName);
-        
-        return isPropertyTest;
-    }
+        get isMethodTest() /* passed */ {
+            return !this.isPropertyTest && !this.isConstructorTest;
+        }
 
-    get callType() /* passed */ {
-        let type;
-
-        if (this.isMethodTest) {
-            type = this.isMonoCallTest ? CallTypes.methodMono : CallTypes.methodPoly;
-        } 
-        else if (this.isPropertyTest) {
-            type = this.isMonoCallTest ? CallTypes.propMono : CallTypes.propPoly;
-        } 
-        else if (this.isConstructorTest) {
-            type = this.isMonoCallTest ? CallTypes.conMono : CallTypes.conPoly;
+        get isPropertyTest() /* passed */ {
+            let plainName = NameAnalyzer.plainNameOf(this.of);
+            
+            let isPropertyTest 
+                = NameAnalyzer.hasPropertySigil(this.of) 
+                || TypeAnalyzer.isPropertyMember(this.on, plainName);
+            
+            return isPropertyTest;
         }
 
-        return type;
-    }
+        get callType() /* passed */ {
+            let type;
+
+            if (this.isMethodTest) {
+                type = this.isMonoCallTest ? CallTypes.methodMono : CallTypes.methodPoly;
+            } 
+            else if (this.isPropertyTest) {
+                type = this.isMonoCallTest ? CallTypes.propMono : CallTypes.propPoly;
+            } 
+            else if (this.isConstructorTest) {
+                type = this.isMonoCallTest ? CallTypes.conMono : CallTypes.conPoly;
+            }
 
-    get isRetrievalTest() /* passed */ {
-        // Falsy code elements never are a retrieval.
-        if (!this.from) {
-            return false;
-        }
-        
-        // If a (non-falsy) string, must be a retrieval.
-        if (typeof this.from === "string") {
-            return true;
+            return type;
         }
-        
-        // If a function, is a retrieval.
-        if (this.from instanceof Function) {
-            return true;
-        }
-        
-        // Anything else is not a retrieval.
-        return false;
-    }
 
-    get doesHaveDoEarly() /* passed */ {
-        if (this.do === undefined) {
+        get isRetrievalTest() /* passed */ {
+            // Falsy code elements never are a retrieval.
+            if (!this.from) {
+                return false;
+            }
+            
+            // If a (non-falsy) string, must be a retrieval.
+            if (typeof this.from === "string") {
+                return true;
+            }
+            
+            // If a function, is a retrieval.
+            if (this.from instanceof Function) {
+                return true;
+            }
+            
+            // Anything else is not a retrieval.
             return false;
         }
 
-        return TypeIdentifier.identify(this.do.early) === Types.isFunction;
-    }
+        get doesHaveDoEarly() /* passed */ {
+            if (this.do === undefined) {
+                return false;
+            }
+
+            return TypeIdentifier.identify(this.do.early) === Types.isFunction;
+        }
     
-    get doesHaveDoLate() /* passed */ {
-        if (this.do === undefined) {
-            return false;
+        get doesHaveDoLate() /* passed */ {
+            if (this.do === undefined) {
+                return false;
+            }
+            
+            return TypeIdentifier.identify(this.do.late) === Types.isFunction;
         }
         
-        return TypeIdentifier.identify(this.do.late) === Types.isFunction;
-    }
-    
-    get doesHaveUndo() /* passed */ {
-        return TypeIdentifier.identify(this.undo) === Types.isFunction;
-    }
+        get doesHaveUndo() /* passed */ {
+            return TypeIdentifier.identify(this.undo) === Types.isFunction;
+        }
 
-    /* Used for grouping in output by method or 
-       prop name, with type sigil only once. */
-    get runName() /* passed */ {
-        let plain = NameAnalyzer.plainNameOf(this.of);
+        /* Used for grouping in output by method or 
+           prop name, with type sigil only once. */
+        get runName() /* passed */ {
+            let plain = NameAnalyzer.plainNameOf(this.of);
 
-        if (!this.isPropertyTest) {
-            return `${ plain }()`;
-        }
-        else {
-            return `.${ plain }`;
+            if (!this.isPropertyTest) {
+                return `${ plain }()`;
+            }
+            else {
+                return `.${ plain }`;
+            }
         }
-    }
 
-    get anyUnsoughtThrow() /* passed */ {
-        // Prop is true when throw is sought.
-        if (this.isThrowTest) {
-            return;
-        }
+        get anyUnsoughtThrow() /* passed */ {
+            // Prop is true when throw is sought.
+            if (this.isThrowTest) {
+                return;
+            }
 
-        return this.thrown;
-    }
+            return this.thrown;
+        }
 
-    get doesHaveUnsoughtThrow() /* passed */ {
-        return this.anyUnsoughtThrow !== undefined;
-    }
+        get doesHaveUnsoughtThrow() /* passed */ {
+            return this.anyUnsoughtThrow !== undefined;
+        }
 
-    get doesHaveTrouble() /* passed */ {
-        return this.trouble !== undefined;
-    }
+        get doesHaveTrouble() /* passed */ {
+            return this.trouble !== undefined;
+        }
 
-    // endregion State properties
+        // endregion State properties
 
     // region State methods
 
-    /* Dependency of .isInstanceTest and .isStaticTest. */
-    #isNamedTypeTest(type, antiType, analyzer) /* verified */ {
-        // If stated to be the opposite type, not this type.
-        if (this.andStringContains(antiType)) {
-            return false;
-        }
-
-        // Analysis of what the type probably is.
-        let plainName = NameAnalyzer.plainNameOf(this.of);
-        let is = analyzer(this.on, plainName);
+        /* Dependency of .isInstanceTest and .isStaticTest. */
+        #isNamedTypeTest(type, antiType, analyzer) /* verified */ {
+            // If stated to be the opposite type, not this type.
+            if (this.andStringContains(antiType)) {
+                return false;
+            }
 
-        // If states to be this type, then this type.
-        let stated = this.andStringContains(type);
+            // Analysis of what the type probably is.
+            let plainName = NameAnalyzer.plainNameOf(this.of);
+            let is = analyzer(this.on, plainName);
 
-        // Whichever may apply.
-        return is || stated;
-    }
+            // If states to be this type, then this type.
+            let stated = this.andStringContains(type);
 
+            // Whichever may apply.
+            return is || stated;
+        }
 
-    /* Needed externally, and dependency 
-       of all .and-based properties. */
-    andStringContains(keyword) /* passed */ {
-        let doesContain 
-            = typeof this.and === "string"
-            && this.and.includes(keyword);
+        /* Needed externally, and dependency 
+           of all .and-based properties. */
+        andStringContains(keyword) /* passed */ {
+            let doesContain 
+                = typeof this.and === "string"
+                && this.and.includes(keyword);
 
-        return doesContain;
-    }
+            return doesContain;
+        }
 
-    // endregion State methods
+        // endregion State methods
 
     // region Initing, including constructor()
 
-    /* Long names used, since some short names, like `for`, are parsed as keywords. */
-    constructor(nature, type, spoofed, initors, method, inputs, output, source, factors, enact, counteract) /* ok */ {
-        this.nature = nature;           // .for 
-        this.type = type;               // .on 
-        this.spoofed = spoofed;         // .plus 
-        this.initors = initors;         // .with 
-        this.method = method;           // .of 
-        this.inputs = inputs;           // .in 
-        this.output = output;           // .out 
-        this.source = source;           // .from 
-        this.factors = factors;         // .and 
-        this.enact = enact;             // .do 
-        this.counteract = counteract;   // .undo 
-    }
-
-    static fromNonceTuples(nonces) /* passed */ {
-        // Throughput and output.
-        let full = new TestDef();
-        let defs = [];
-
-        // Looping over all.
-        for (let nonce of nonces) {
-            // No possible test definition to output.
-            if (!TestDef.isANonce(nonce)) {
-                continue;
-            }
-
-            // Get latest test definition.
-            let latest = TestDef.fromNonceTuple(nonce);
-
-            // Restarting test definitions when desired.
-            full = TestDef.maybeRestartFull(full, latest);
-
-            // Merge any previous 
-            // values into latest.
-            TestDef.combine(latest, full);
-
-            // Make latest the tuple for 
-            // combining with next time.
-            full = latest;
+        /* Long names used, since some short names, like `for`, are parsed as keywords. */
+        constructor(nature, type, spoofed, initors, method, inputs, output, source, factors, enact, counteract) /* ok */ {
+            this.nature = nature;           // .for 
+            this.type = type;               // .on 
+            this.spoofed = spoofed;         // .plus 
+            this.initors = initors;         // .with 
+            this.method = method;           // .of 
+            this.inputs = inputs;           // .in 
+            this.output = output;           // .out 
+            this.source = source;           // .from 
+            this.factors = factors;         // .and 
+            this.enact = enact;             // .do 
+            this.counteract = counteract;   // .undo 
+        }
 
-            // Changes to the current def, rather than 
-            // a new one, should not result in a new def.
-            if (TestDef.isChangeOnlyNonce(nonce)) {
-                continue;
+        static fromNonceTuples(nonces) /* passed */ {
+            // Throughput and output.
+            let full = new TestDef();
+            let defs = [];
+
+            // Looping over all.
+            for (let nonce of nonces) {
+                // No possible test definition to output.
+                if (!TestDef.isANonce(nonce)) {
+                    continue;
+                }
+
+                // Get latest test definition.
+                let latest = TestDef.fromNonceTuple(nonce);
+
+                // Restarting test definitions when desired.
+                full = TestDef.maybeRestartFull(full, latest);
+
+                // Merge any previous 
+                // values into latest.
+                TestDef.combine(latest, full);
+
+                // Make latest the tuple for 
+                // combining with next time.
+                full = latest;
+
+                // Changes to the current def, rather than 
+                // a new one, should not result in a new def.
+                if (TestDef.isChangeOnlyNonce(nonce)) {
+                    continue;
+                }
+
+                // Add latest, if it's ready to run as a test.
+                if (latest.isRunnable) {
+                    defs.push(latest);
+                }
             }
 
-            // Add latest, if it's ready to run as a test.
-            if (latest.isRunnable) {
-                defs.push(latest);
-            }
+            // Back to caller.
+            return defs;
         }
 
-        // Back to caller.
-        return defs;
-    }
+        /* Transfers properties in 'nonce' to a new TestDef 
+           if they match by either (first) short or long name.  
+           Unmatched props remain undefined on the TestDef. */
+        static fromNonceTuple(nonce) /* passed */ {
+            // Empty, since properties can be set 
+            // by either of two nonce naming styles.
+            let def = new TestDef();
+
+            let shortNames = TestDef.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 = TestDef.longsByShort.get(shortName);
+                def[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+            }
 
-    /* Transfers properties in 'nonce' to a new TestDef 
-       if they match by either (first) short or long name.  
-       Unmatched props remain undefined on the TestDef. */
-    static fromNonceTuple(nonce) /* passed */ {
-        // Empty, since properties can be set 
-        // by either of two nonce naming styles.
-        let def = new TestDef();
-
-        let shortNames = TestDef.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 = TestDef.longsByShort.get(shortName);
-            def[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+            // Back to caller.
+            return def;
         }
 
-        // Back to caller.
-        return def;
-    }
-
-    // region Dependencies of nonce-tuple initing methods
-
-    static isANonce(topic) /* passed */ {
-        let type = TypeIdentifier.identify(topic);
-        return type === Types.isObject;
-    }
+        // region Dependencies of nonce-tuple initing methods
 
-    /* Replaces some or all of the 'full' that gathers test 
-       props for reuse when targeting changes significantly 
-       in the middle of the collapsing-forward process. */
-    static maybeRestartFull(full, latest) /* passed */ {
-        // When a (new) model class is named, 
-        // wipe out all reused test values.
-        if (latest.type !== undefined) {
-            full = new TestDef();
-        }
-
-        // When a (new) model method is named, wipe out reused 
-        // test values except the general ones for its class 
-        // and .nature, needed for collapsing forward.
-        if (latest.method !== undefined) {
-            full = TestDef.classOnlyDefFrom(full);
-        }
+            static isANonce(topic) /* passed */ {
+                let type = TypeIdentifier.identify(topic);
+                return type === Types.isObject;
+            }
 
-        return full;
-    }
+            /* Replaces some or all of the 'full' that gathers test 
+               props for reuse when targeting changes significantly 
+               in the middle of the collapsing-forward process. */
+            static maybeRestartFull(full, latest) /* passed */ {
+                // When a (new) model class is named, 
+                // wipe out all reused test values.
+                if (latest.type !== undefined) {
+                    full = new TestDef();
+                }
+
+                // When a (new) model method is named, wipe out reused 
+                // test values except the general ones for its class 
+                // and .nature, needed for collapsing forward.
+                if (latest.method !== undefined) {
+                    full = TestDef.classOnlyDefFrom(full);
+                }
+
+                return full;
+            }
 
-    static classOnlyDefFrom(original) /* passed */ {
-        let output = new TestDef();
+            static classOnlyDefFrom(original) /* passed */ {
+                let output = new TestDef();
 
-        output.type = original.type;
-        output.initors = original.initors;
-        output.spoofed = original.spoofed;
+                output.type = original.type;
+                output.initors = original.initors;
+                output.spoofed = original.spoofed;
 
-        return output;
-    }
+                return output;
+            }
 
-    /* Replaces properties of the 'self' 
-       TestDef with any from 'other'. */
-    static combine(self, other) /* passed */ {
-        let shortNames = TestDef.longsByShort.keys();
+            /* Replaces properties of the 'self' 
+               TestDef with any from 'other'. */
+            static combine(self, other) /* passed */ {
+                let shortNames = TestDef.longsByShort.keys();
 
-        // Collapse properties forward.
-        for (let shortName of shortNames) {
-            TestDef.combineValues(self, other, shortName);
-        }
-    }
+                // Collapse properties forward.
+                for (let shortName of shortNames) {
+                    TestDef.combineValues(self, other, shortName);
+                }
+            }
 
-    static isChangeOnlyNonce(nonce) /* passed */ {
-        return nonce.just !== undefined || nonce.only !== undefined;
-    }
+            static isChangeOnlyNonce(nonce) /* passed */ {
+                return nonce.just !== undefined || nonce.only !== undefined;
+            }
 
-    /* Replaces the named property of 'self', if 
-       missing, with any new property of 'other'. */
-    static combineValues(self, other, name) /* passed */ {
-        // Property may still end up undefined.
-        if (self[name] === undefined) {
-            self[name] = other[name];
-        }
-    }
+            /* Replaces the named property of 'self', if 
+               missing, with any new property of 'other'. */
+            static combineValues(self, other, name) /* passed */ {
+                // Property may still end up undefined.
+                if (self[name] === undefined) {
+                    self[name] = other[name];
+                }
+            }
 
-    // endregion Dependencies of nonce-tuple initing methods
+            // endregion Dependencies of nonce-tuple initing methods
 
-    // endregion Initing, including constructor()
+        // endregion Initing, including constructor()
 
     toString() /* verified */ {
         let displayer = new TotalDisplayer();
@@ -506,5 +461,4 @@ export default class TestDef {
 
         return text;
     }
-
 }