risei 3.3.0 → 3.3.2

package/system/TestFinder.js

@@ -137,7 +137,7 @@ export default class TestFinder  {
         // Each test source may have multiple test classes.
         let testSources = [];
         
-        // Loading modules should load their dependencies.
+        // Loading modules also loads their dependencies.
         try {
             // Pseudo-protocol needed for non-POSIX OSes.
             let asFileUrl = `file:///${ classPath }`;

package/system/TestFrame.js

@@ -1,13 +1,23 @@
 /**/
 
+import TestTargets from "./TestTargets.js";
 import TestStages from "./TestStages.js";
+import TotalComparer from "./TotalComparer.js";
 
 export default class TestFrame {
-    #stages;
+    // region Components
+
+        #targets;
+        #stages;
+        #comparer;
+
+        // endregion Components
 
     constructor() /* ok */ {
-        // A TestStages is inited for each test.
+        // These are inited for each test.
+        this.#targets = new TestTargets();
         this.#stages = new TestStages();
+        this.#comparer = new TotalComparer();
     }
 
     async run(test) /* passed */ {
@@ -16,15 +26,16 @@ export default class TestFrame {
             // Spoofing and so on.
             await this.#stages.anyPreTargetingGroundwork(test);
             
-            // Target may be instance, prototype for constructors, the class 
-            // itself for statics, or nonce for properties.  Sets test.target.
-            this.#stages.setTarget(test);
+            // Sets test.target to instance, class, or prototype.
+            this.#targets.setTarget(test);
             
-            let target = this.#stages.supplyLocalTarget(test);
+            // Local-only target is test.target for methods, 
+            // and a nonce using test.target for all else.
+            let target = this.#targets.supplyLocalTarget(test);
 
             // Method under test may be on instance, class, 
             // or nonce for properties.  Sets test.callable.
-            let callable = this.#stages.supplyCallableName(test);
+            let callable = this.#targets.supplyCallableName(test);
 
             // Setting (spoofing) properties and so on.
             await this.#stages.anyPostTargetingGroundwork(test);
@@ -41,10 +52,10 @@ export default class TestFrame {
             }
 
             // Sometimes tests look for results elsewhere. 
-            this.#stages.anyModifyActual(test);
+            await this.#stages.anyModifyActual(test);
 
             // Actually testing the result.
-            test.didPass = this.#stages.compareResults(test.output, test.actual);
+            test.didPass = this.#comparer.compare(test.output, test.actual);
         }
         catch (thrown) {
             // Fail of the test system, or of code in .do or .from.

package/system/TestRunner.js

@@ -39,55 +39,31 @@ export default class TestRunner {
 
     /* inputs */
 
-    get tests() {
-        return this.#tests;
-    }
+    get tests() { return this.#tests; }
 
-    set tests(value) {
-        this.#tests = value;
-    }
+    set tests(value) { this.#tests = value; }
 
     /* outputs */
 
-    get numberRun() {
-        return this.#numberRun;
-    }
+    get numberRun() { return this.#numberRun; }
 
-    set numberRun(value) {
-        this.#numberRun = value;
-    }
+    set numberRun(value) { this.#numberRun = value; }
 
-    get numberPassed() {
-        return this.#numberPassed;
-    }
+    get numberPassed() { return this.#numberPassed; }
 
-    set numberPassed(value) {
-        this.#numberPassed = value;
-    }
+    set numberPassed(value) { this.#numberPassed = value; }
 
-    get numberFailed() {
-        return this.#numberFailed;
-    }
+    get numberFailed() { return this.#numberFailed; }
 
-    set numberFailed(value) {
-        this.#numberFailed = value;
-    }
+    set numberFailed(value) { this.#numberFailed = value; }
 
-    get thrown() {
-        return this.#thrown;
-    }
+    get thrown() { return this.#thrown; }
 
-    get trouble() {
-        return this.#trouble;
-    }
+    get trouble() { return this.#trouble; }
 
-    get allDidPass() {
-        return this.#allDidPass;
-    }
+    get allDidPass() { return this.#allDidPass; }
 
-    set allDidPass(value) {
-        this.#allDidPass = value;
-    }
+    set allDidPass(value) { this.#allDidPass = value; }
 
     // endregion Properties
 

package/system/TestStages.js

@@ -15,197 +15,94 @@ export default class TestStages {
 
     // region Components
 
-    static #methodSpoofer = new MethodSpoofer();
-    static #propertySpoofer = new PropertySpoofer();
-    static #comparer = new TotalComparer();
+        static #methodSpoofer = new MethodSpoofer();
+        static #propertySpoofer = new PropertySpoofer();
+        static #comparer = new TotalComparer();
 
-    // endregion Components
+        // endregion Components
 
-    async anyPreTargetingGroundwork(test) /* passed */ {
-        // Spoofing methods; properties spoofed later.
-        TestStages.#methodSpoofer.spoof(test);
+    // region Stages
 
-        // Arbitrary user-defined actions. 
-        // Only spoofed methods available.
-        if (test.doesHaveDoEarly) {
-            await test.do.early(test);
-        }
-    }
-    
-    setTarget(test) /* passed */ {
-        /* Target may be instance, prototype for constructors, 
-           the class itself for statics, or a nonce for either 
-           static or instance properties. */
-
-        if (test.isConstructorTest) {
-            test.target = test.on.prototype;
-            return;
-        }
+        async anyPreTargetingGroundwork(test) /* passed */ {
+            // Spoofing methods; properties spoofed later.
+            TestStages.#methodSpoofer.spoof(test);
 
-        let target = test.isInstanceTest // || test.of === "toString"
-            ? new test.on.prototype.constructor(...test.with) 
-            : test.on;
-
-        test.target = target;
-    }
-    
-    supplyLocalTarget(test) /* passed */ {
-        /* Methods are called on instance / type / prototype directly.  
-           Properties are called on instance / type in a nonce.
-           Methods or properties are poly-called in a nonce. */
-
-        let callable = NameAnalyzer.plainNameOf(test.method);
-
-        switch (test.callType) {
-            case CallTypes.methodMono:
-                return test.target;
-            case CallTypes.propMono:
-                return { nonce: () => { return test.target[callable]; } };
-            case CallTypes.conMono:
-                return { nonce: (...args) => { return new test.target[callable](...args); } };
-            case CallTypes.methodPoly:
-                return { nonce: this.supplyPolyMethodNonce(test, callable) };
-            case CallTypes.propPoly:
-                return { nonce: this.supplyPolyPropNonce(test, callable) };
-            case CallTypes.conPoly:
-                return { nonce: this.supplyPolyConstructorNonce(test, callable) };
+            // Arbitrary user-defined actions. 
+            // Only spoofed methods available.
+            if (test.doesHaveDoEarly) {
+                await test.do.early(test);
+            }
         }
 
-        return localTarget;
-    }
-
-    supplyCallableName(test) /* passed */ {
-        /* Name is of the method named in test, 
-           or of a nonce method for prop, con, 
-           or poly-call test (of any target). */
-        
-        let name = test.isMethodTest && test.isMonoCallTest
-            ? NameAnalyzer.plainNameOf(test.method) 
-            : TestDef.nonceLocalCallableName;
-
-        return name;
-    }
-    
-    async anyPostTargetingGroundwork(test) /* passed */ {
-        // Spoofing properties; methods spoofed earlier.
-        TestStages.#propertySpoofer.spoof(test);
-
-        // Arbitrary user-defined actions. 
-        // All spoofs normally available.
-        if (test.doesHaveDoLate) {
-            await test.do.late(test);
-        }
-    }
-    
-    anyModifyActual(test) /* passed */ {
-        /* Original test.actual is used if a normal test, but replaced with .thrown 
-           if a throw test, or result of supplier method if a retrieval test. */
-
-        if (test.isThrowTest) {
-            // May be undefined, if no throw.
-            test.actual = test.thrown;
-        }
+        async anyPostTargetingGroundwork(test) /* passed */ {
+            // Spoofing properties; methods spoofed earlier.
+            TestStages.#propertySpoofer.spoof(test);
 
-        if (test.isRetrievalTest) {
-            test.actual = this.supplyNonReturnActual(test);
-        }
-    }
-    
-    compareResults(expected, actual) /* passed */ {
-        return TestStages.#comparer.compare(expected, actual);
-    }
-    
-    async anyGroundworkReversal(test) /* passed */ {
-        // Unspoofing methods and properties.
-        TestStages.#methodSpoofer.unspoof(test);
-        TestStages.#propertySpoofer.unspoof(test);
-
-        // Arbitrary user-defined operations.
-        // No spoofs are available here.
-        if (test.doesHaveUndo) {
-            await test.undo(test);
+            // Arbitrary user-defined actions. 
+            // All spoofs normally available.
+            if (test.doesHaveDoLate) {
+                await test.do.late(test);
+            }
         }
-    }
-
-    // region Dependencies of test stages
 
-    supplyPolyMethodNonce(test, callable) /* verified */ {
-        let nonce = (...inputs) => {
-            let actuals = [];
+        async anyModifyActual(test) /* passed */ {
+            /* Original test.actual is used if a normal test, but replaced with .thrown 
+               if a throw test, or result of supplier method if a retrieval test. */
 
-            for (let args of inputs) {
-                let local = test.target[callable](...args);
-                actuals.push(local);
+            if (test.isThrowTest) {
+                // May be undefined, if no throw.
+                test.actual = test.thrown;
             }
 
-            return actuals;
-        };
-
-        return nonce;
-    }
-
-    supplyPolyPropNonce(test, callable) /* verified */ {
-        let nonce = (...inputs) => {
-            let actuals = [];
-        
-            for (let args of inputs) {
-                let local = test.target[callable];
-                actuals.push(local);
+            if (test.isRetrievalTest) {
+                test.actual = await this.supplyNonReturnActual(test);
             }
-        
-            return actuals;
-        };
-
-        return nonce;
-    }
-
-    supplyPolyConstructorNonce(test, callable) /* verified */ {
-        let nonce = (...inputs) => {
-            let actuals = [];
+        }
 
-            for (let args of inputs) {
-                let local = new test.target[callable](...args);
-                actuals.push(local);
+        async supplyNonReturnActual(test) /* passed */ {
+            // When .from is a string, the actual 
+            // is the named target or type member.
+            if (typeof test.from === "string") {
+                // Removing any sigil.
+                let name = NameAnalyzer.plainNameOf(test.from);
+
+                // Determining which exposes the property.
+                let host = TypeAnalyzer.isInstanceMember(test.type, name)
+                    ? test.target
+                    : test.type;
+
+                // Constructors are different.
+                host = test.isConstructorTest
+                    ? test.actual
+                    : host;
+
+                // Actually supplying value.
+                return host[name];
             }
 
-            return actuals;
-        };
-
-        return nonce;
-    }
-
-    supplyNonReturnActual(test) /* passed */ {
-        // When .from is a string, the actual 
-        // is the named target or type member.
-        if (typeof test.from === "string") {
-            // Removing any sigil.
-            let name = NameAnalyzer.plainNameOf(test.from);
-
-            // Determining which exposes the property.
-            let host = TypeAnalyzer.isInstanceMember(test.type, name)
-                ? test.target
-                : test.type;
-
-            // Constructors are different.
-            host = test.isConstructorTest
-                ? test.actual
-                : host;
+            // When there is a .from that's a function, 
+            // the actual is the result of calling it, 
+            // given everything that might be needed.
+            if (test.from instanceof Function) {
+                // Actually supplying value.
+                return await test.from(test, test.actual);
+            }
 
-            // Actually supplying value.
-            return host[name];
+            // Only property names and functions make sense to support.
+            throw new Error("The test.from value was not a usable type.  It must be either a property name or a function to work.");
         }
 
-        // When there is a .from that's a function, 
-        // the actual is the result of calling it, 
-        // given everything that might be needed.
-        if (test.from instanceof Function) {
-            // Actually supplying value.
-            return test.from(test, test.actual);
+        async anyGroundworkReversal(test) /* passed */ {
+            // Unspoofing methods and properties.
+            TestStages.#methodSpoofer.unspoof(test);
+            TestStages.#propertySpoofer.unspoof(test);
+
+            // Arbitrary user-defined operations.
+            // No spoofs are available here.
+            if (test.doesHaveUndo) {
+                await test.undo(test);
+            }
         }
 
-        // Only property names and functions make sense to support.
-        throw new Error("The test.from value was not a usable type.  It must be either a property name or a function to work.");
-    }
-    
-    // endregion Dependencies of test stages
+        // endregion Stages
 }

package/system/TestSummary.js

@@ -9,29 +9,17 @@ export default class TestSummary {
     #anyTroubles;
     #anyCaught;
     
-    get summary() {
-        return this.#summary;
-    }
+    get summary() { return this.#summary; }
     
-    get allDidPass() {
-        return this.#allDidPass;
-    }
+    get allDidPass() { return this.#allDidPass; }
     
-    get anyWereRun() {
-        return this.#anyWereRun;
-    }
+    get anyWereRun() { return this.#anyWereRun; }
     
-    get anyThrows() {
-        return this.#anyThrows;
-    }
+    get anyThrows() { return this.#anyThrows; }
 
-    get anyTroubles() {
-        return this.#anyTroubles;
-    }
+    get anyTroubles() { return this.#anyTroubles; }
 
-    get anyCaught() {
-        return this.#anyCaught;
-    }
+    get anyCaught() { return this.#anyCaught; }
 
     constructor(summary, allDidPass, anyWereRun, anyThrows, anyTroubles, anyCaught) {
         this.#summary = summary;

package/system/TestTargets.js

@@ -0,0 +1,114 @@
+/**/
+
+import TestDef from "./TestDef.js";
+import TypeAnalyzer from "./TypeAnalyzer.js";
+import NameAnalyzer from "./NameAnalyzer.js";
+import CallTypes from "./CallTypes.js";
+
+export default class TestTargets {
+    /* Stages in a TestFrame run() that identify 
+       or set targets, or names for them. */
+
+    setTarget(test) /* passed */ {
+        /* Target may be instance, prototype for constructors, 
+           the class itself for statics, or a nonce for either 
+           static or instance properties. */
+
+        if (test.isConstructorTest) {
+            test.target = test.on.prototype;
+            return;
+        }
+
+        let target = test.isInstanceTest
+            ? new test.on.prototype.constructor(...test.with) 
+            : test.on;
+
+        test.target = target;
+    }
+    
+    supplyLocalTarget(test) /* passed */ {
+        /* Methods are called on instance / type / prototype directly.  
+           Properties are called on instance / type in a nonce.
+           Methods or properties are poly-called in a nonce. */
+
+        let callable = NameAnalyzer.plainNameOf(test.method);
+
+        switch (test.callType) {
+            case CallTypes.methodMono:
+                return test.target;
+            case CallTypes.propMono:
+                return { nonce: () => { return test.target[callable]; } };
+            case CallTypes.conMono:
+                return { nonce: (...args) => { return new test.target[callable](...args); } };
+            case CallTypes.methodPoly:
+                return { nonce: this.supplyPolyMethodNonce(test, callable) };
+            case CallTypes.propPoly:
+                return { nonce: this.supplyPolyPropNonce(test, callable) };
+            case CallTypes.conPoly:
+                return { nonce: this.supplyPolyConstructorNonce(test, callable) };
+        }
+
+        return localTarget;
+    }
+
+    supplyCallableName(test) /* passed */ {
+        /* Name is of the method named in test, 
+           or of a nonce method for prop, con, 
+           or poly-call test (of any target). */
+        
+        let name = test.isMethodTest && test.isMonoCallTest
+            ? NameAnalyzer.plainNameOf(test.method) 
+            : TestDef.nonceLocalCallableName;
+
+        return name;
+    }
+
+    // region Dependencies of targeting / naming methods
+
+        supplyPolyMethodNonce(test, callable) /* verified */ {
+            let nonce = (...inputs) => {
+                let actuals = [];
+
+                for (let args of inputs) {
+                    let local = test.target[callable](...args);
+                    actuals.push(local);
+                }
+
+                return actuals;
+            };
+
+            return nonce;
+        }
+
+        supplyPolyPropNonce(test, callable) /* verified */ {
+            let nonce = (...inputs) => {
+                let actuals = [];
+            
+                for (let args of inputs) {
+                    let local = test.target[callable];
+                    actuals.push(local);
+                }
+            
+                return actuals;
+            };
+
+            return nonce;
+        }
+
+        supplyPolyConstructorNonce(test, callable) /* verified */ {
+            let nonce = (...inputs) => {
+                let actuals = [];
+
+                for (let args of inputs) {
+                    let local = new test.target[callable](...args);
+                    actuals.push(local);
+                }
+
+                return actuals;
+            };
+
+            return nonce;
+        }
+
+        // endregion Dependencies of targeting / naming methods
+}

package/system/TotalComparer.js

@@ -322,6 +322,4 @@ export default class TotalComparer {
     }
 
     // endregion Dependencies of compare()
-
 }
-

package/system/TypeAnalyzer.js

@@ -105,10 +105,8 @@ export default class TypeAnalyzer {
             return false;
         }
 
-        // Members with any other values are properties.
-        if (named.value !== undefined) {
-            return true;
-        }
+        // Any other members are properties.
+        return true;
     }
 
     static #typeTextContainsNameAsProperty(type, name) /* verified */ {
@@ -171,5 +169,4 @@ export default class TypeAnalyzer {
     }
     
     // endregion Dependencies of allGetters()
-    
 }