risei 3.0.0 → 3.1.1

package/system/TestFrame.js

@@ -36,6 +36,7 @@ export default class TestFrame {
             }
             catch (thrown) {
                 // Sometimes tests look for this.
+                // Otherwise, listed in gold bar.
                 test.thrown = thrown;
             }
 
@@ -46,11 +47,21 @@ export default class TestFrame {
             test.didPass = this.#stages.compareResults(test.output, test.actual);
         }
         catch (thrown) {
-            /* Block needed, but no operations. */
+            // Fail of the test system, or of code in .do or .from.
+            test.trouble = thrown;
         }
         finally {
-            // Undoing any groundwork changes made. 
-            await this.#stages.anyGroundworkReversal(test);
+            // Always undoing any groundwork changes made.
+            try {
+                await this.#stages.anyGroundworkReversal(test);
+            }
+            catch (thrown) {
+                // Fail of the test system, or of code in .undo; 
+                // only needed when no preceding throw.
+                if (test.trouble === undefined) {
+                    test.trouble = thrown;
+                }
+            }
         }
     }
 }

package/system/TestResult.js

@@ -19,9 +19,19 @@ export default class TestResult {
     #expectedText;
     #actualText;
 
+    #thrown;
+    #trouble;
+
+    #thrownText;
+    #troubleText;
+
+    #wasThrowTest;
+
+    #doesHaveThrow;
+    #doesHaveTrouble;
+
     #didPass;
     #actual;
-    #thrown;
 
     // endregion Fields
 
@@ -91,19 +101,39 @@ export default class TestResult {
         this.#didPass = value;
     }
 
+    get wasThrowTest() {
+        return this.#wasThrowTest;
+    }
+
+    get doesHaveThrow() {
+        return this.#doesHaveThrow;
+    }
+
+    get doesHaveTrouble() {
+        return this.#doesHaveTrouble;
+    }
+
     get anyThrow() {
         return this.#thrown;
     }
 
-    set anyThrow(value) {
-        this.#thrown = value;
+    get anyTrouble() {
+        return this.#trouble;
+    }
+
+    get anyThrowText() {
+        return this.#thrownText;
+    }
+
+    get anyTroubleText() {
+        return this.#troubleText;
     }
 
     // endregion Outcome properties
 
     // region Construction
 
-    constructor(test) {
+    constructor(test) /* ok */ {
         this.#test = test;
         this.#displayer = new TotalDisplayer();
     }
@@ -112,56 +142,76 @@ export default class TestResult {
 
     // region Before run: setNature() and dependencies
 
-    setNature() {
+    setNature() /* passed */ {
         this.#identityText = this.#calculateIdentityText();
         this.#initorsText = this.#calculateInitorsText();
         this.#inputsText = this.#calculateInputsText();
         this.#expectedText = this.#calculateExpectedText();
+        this.#wasThrowTest = this.#test.isThrowTest;
     }
     
-    #calculateIdentityText() {
+    #calculateIdentityText() /* verified */ {
         let text = `${ this.test.for } `;
         return text;
     }
     
-    #calculateInitorsText() {
+    #calculateInitorsText() /* verified */ {
         let text = this.#displayItemRow(this.test.with);
         text = `Initors: ${ text }. `;
         return text;
     }
     
-    #calculateInputsText() {
+    #calculateInputsText() /* verified */ {
         let text = this.#displayItemRow(this.test.in);
         text = `Inputs: ${ text }. `;
         return text;
     }
     
-    #calculateExpectedText() {
+    #calculateExpectedText() /* verified */ {
         let text = this.#displaySingleItem(this.test.out);
         text = `Expected: ${ text }. `;
         return text;
     }
-    
+ 
     // endregion Before run: setNature() and dependencies
     
     // region After run: setResults() and dependencies
 
-    setResults() {
+    setResults() /* passed */ {
         // Direct results.
         this.#didPass = this.test.didPass;
         this.#actual = this.test.actual;
-        this.#thrown = this.test.anyThrow;
         
+        this.#thrown = this.test.thrown;
+        this.#trouble = this.test.trouble;
+
+        this.#doesHaveThrow = this.test.doesHaveUnsoughtThrow;
+        this.#doesHaveTrouble = this.test.doesHaveTrouble;
+
         // Derived displayable results.
         this.#actualText = this.#calculateActualText();
+        this.#thrownText = this.#calculateThrownText("Unsought throw in tested code", this.#thrown);
+        this.#troubleText = this.#calculateThrownText("Throw in framing code", this.#trouble);
     }
 
-    #calculateActualText() {
+    #calculateActualText() /* verified */ {
         let text = this.#displaySingleItem(this.test.actual);
         text = `Actual: ${ text }. `;
         return text;
     }
     
+    #calculateThrownText(scope, thrown) /* verified */ {
+        // No throw to display.
+        if (thrown === undefined) {
+            return;  // Undefined.
+        }
+
+        let text = `${ scope }: ${ this.#test.on.name }: ${ this.#test.runName }: `
+                 + `\"${ this.#test.for }\":  ${ thrown.message }`;
+
+        return text;
+    }
+   
     // endregion After run: setResults() and dependencies
 
     // region Displaying test args

package/system/TestRunner.js

@@ -1,6 +1,6 @@
 /**/
 
-/* Runs tests one by one as an ATestCaller requests them. */
+/* Runs tests one by one as TestCaller or equivalent requests them. */
 
 import TestDef from "./TestDef.js";
 import TestGroup from "./TestGroup.js";
@@ -25,6 +25,12 @@ export default class TestRunner {
     #numberRun;
     #numberPassed;
     #numberFailed;
+
+    // Problems in different scopes.
+    #thrown;  // In tested code.
+    #trouble;  // In framing code.
+    #caught;  // In outer system.
+
     #allDidPass;
 
     // endregion Private fields
@@ -67,6 +73,14 @@ export default class TestRunner {
         this.#numberFailed = value;
     }
 
+    get thrown() {
+        return this.#thrown;
+    }
+
+    get trouble() {
+        return this.#trouble;
+    }
+
     get allDidPass() {
         return this.#allDidPass;
     }
@@ -86,6 +100,10 @@ export default class TestRunner {
         this.#numberPassed = 0;
         this.#numberFailed = 0;
 
+        this.#thrown = [];
+        this.#trouble = [];
+        this.#caught = [];
+
         this.#allDidPass = true;
     }
 
@@ -103,46 +121,56 @@ export default class TestRunner {
     // including groups and summary.
     async * runTests() {
         if (!this.#tests) {
-            throw new Error("No tests available to run.  TestRunner's .tests must be set before an attempt to run is made.");
+            throw new Error(
+                "No tests available to run.  TestRunner's .tests "
+                + "must be set before an attempt to run is made."
+            );
         }
     
-        // Converting so that property names can be relied on.
-        this.#tests = TestDef.fromNonceTuples(this.tests);
-
-        // Needed for displaying classes and methods as groups.
-        let classGroup = new ClassTestGroup();
-        let methodGroup = new MethodTestGroup();
-        let atFirstClassMethod = false;
-
-        // Iterative running of all tests in current order.
-        for (let test of this.#tests) {
-            // Each new class should be a group, and its start 
-            // should be retained for grouping of methods.
-            if (test.on.name !== classGroup.group) {
-                classGroup.group = test.on.name;
-                atFirstClassMethod = true;
-                yield classGroup;
+        try {
+            // Converting so that property names can be relied on.
+            this.#tests = TestDef.fromNonceTuples(this.tests);
+
+            // Needed for displaying classes and methods as groups.
+            let classGroup = new ClassTestGroup();
+            let methodGroup = new MethodTestGroup();
+            let atFirstClassMethod = false;
+
+            // Iterative running of all tests in current order.
+            for (let test of this.#tests) {
+                // Each new class should be a group, and its start 
+                // should be retained for grouping of methods.
+                if (test.on.name !== classGroup.group) {
+                    classGroup.group = test.on.name;
+                    atFirstClassMethod = true;
+                    yield classGroup;
+                }
+
+                // Each new method / prop name should be a group, 
+                // and so should the first method for a class.
+                let runName = test.runName;
+
+                if (runName !== methodGroup.group || atFirstClassMethod) {
+                    methodGroup.group = runName;
+                    atFirstClassMethod = false;
+                    yield methodGroup;
+                }
+
+                let result = await this.#runOneTest(test);
+
+                yield result;
             }
-
-            // Each new method / prop name should be a group, 
-            // and so should the first method for a class.
-            let runName = test.runName;
-
-            if (runName !== methodGroup.group || atFirstClassMethod) {
-                methodGroup.group = runName;
-                atFirstClassMethod = false;
-                yield methodGroup;
-            }
-
-            let result = await this.runOneTest(test);
-            yield result;
+        }
+        catch (caught) {
+            // Top of .stack is .message.
+            this.#caught.push(caught.stack);
         }
 
         // Iterative returning of final results summary.
-        yield this.summarize();
+        yield this.#summarize();
     }
 
-    async runOneTest(test) {
+    async #runOneTest(test) {
         // Default outputs.  Never left undefined.
         test.didPass = false;
         test.anyThrow = null;
@@ -159,7 +187,7 @@ export default class TestRunner {
         result.setResults();
 
         // For later summarizing.
-        this.#retainTestResults(test);
+        this.#retainTestResults(result);
 
         // Results and test back to the caller.
         return result;
@@ -167,22 +195,30 @@ export default class TestRunner {
     
     // region Dependencies of runOneTest()
     
-    #retainTestResults(test) {
+    #retainTestResults(result) {
         this.#numberRun++;
 
-        if (test.didPass) {
+        if (result.doesHaveThrow) {
+            this.#thrown.push(result.anyThrowText);
+        }
+
+        if (result.doesHaveTrouble) {
+            this.#trouble.push(result.anyTroubleText);
+        }
+
+        if (result.didPass) {
             this.#numberPassed++;
         }
         else {
             this.#numberFailed++;
         }
 
-        this.#allDidPass &&= test.didPass;
+        this.#allDidPass &&= result.didPass;
     }
 
     // endregion Dependencies of runOneTest()
 
-    summarize() {
+    #summarize() {
         let summary = `Ran ${ this.#numberRun } test${ this.#numberRun !== 1 ? "s" : "" }.  `
             + `${ this.#allDidPass ? "All tests passed.  " : "" }`
             + `${ this.#numberPassed } passed.  `
@@ -190,9 +226,8 @@ export default class TestRunner {
 
         let anyWereRun = this.#numberRun > 0;
 
-        return new TestSummary(summary, this.#allDidPass, anyWereRun);
+        return new TestSummary(summary, this.#allDidPass, anyWereRun, this.#thrown, this.#trouble, this.#caught);
     }
 
     // endregion Running tests
-
 }

package/system/TestStages.js

@@ -6,12 +6,11 @@ import PropertySpoofer from "./PropertySpoofer.js";
 import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
 import TotalComparer from "./TotalComparer.js";
+import CallTypes from "./CallTypes.js";
 
 export default class TestStages {
-    /* &cruft, ? factor these to more classes */
-
-    /* These methods hold operations carried out in the test frame, 
-       or before / after all test frames, in the test runner.  
+    /* These methods hold reentrant operations carried 
+       out in the test frame in the test runner.  
        Not necessarily all test steps are found here. */
 
     // region Components
@@ -39,7 +38,7 @@ export default class TestStages {
            static or instance properties. */
 
         if (test.isConstructorTest) {
-            test.target = new test.on.prototype.constructor(...test.in);
+            test.target = test.on.prototype;
             return;
         }
 
@@ -57,20 +56,19 @@ export default class TestStages {
 
         let callable = NameAnalyzer.plainNameOf(test.method);
 
-        // Two most common cases: mono-call 
-        // tests of methods and properties.
-        let localTarget = test.isMethodTest
-            ? test.target
-            : { nonce: () => { return test.target[callable]; } };
-
-        // Rare cases: poly-call tests 
-        // of methods and properties.
-        if (test.isPolyCallTest) {
-            let nonce = test.isMethodTest
-                ? this.supplyPolyMethodNonce(test, callable)
-                : this.supplyPolyPropNonce(test, callable);
-
-            localTarget = { nonce };
+        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;
@@ -78,21 +76,13 @@ export default class TestStages {
 
     supplyCallableName(test) /* passed */ {
         /* Name is of the method named in test, 
-           or a nonce method for a property or 
-           any poly-call test (method or prop). */
+           or of a nonce method for prop, con, 
+           or poly-call test (of any target). */
         
-        // Two most common cases: mono-call 
-        // test of a method or property.
-        let name = test.isMethodTest 
+        let name = test.isMethodTest && test.isMonoCallTest
             ? NameAnalyzer.plainNameOf(test.method) 
             : TestDef.nonceLocalCallableName;
 
-        // Rare cases: poly-call tests 
-        // of a method or property.
-        if (test.isPolyCallTest) {
-            name = TestDef.nonceLocalCallableName;
-        }
-
         return name;
     }
     
@@ -169,6 +159,21 @@ export default class TestStages {
         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;
+    }
+
     supplyNonReturnActual(test) /* passed */ {
         // When .from is a string, the actual 
         // is the named target or type member.
@@ -181,12 +186,15 @@ export default class TestStages {
                 ? test.target
                 : test.type;
 
+            // Constructors are different.
+            host = test.isConstructorTest
+                ? test.actual
+                : host;
+
             // Actually supplying value.
             return host[name];
         }
 
-        /* &cruft, possibly change all .from syntax 
-                   to ? (actual, test), or ? (test) */
         // When there is a .from that's a function, 
         // the actual is the result of calling it, 
         // given everything that might be needed.
@@ -199,10 +207,5 @@ export default class TestStages {
         throw new Error("The test.from value was not a usable type.  It must be either a property name or a function to work.");
     }
     
-    #compare(expected, actual) /* verified */ {
-        return this.#comparer.compare(expected, actual);
-    }
-
     // endregion Dependencies of test stages
-
 }

package/system/TestSummary.js

@@ -4,34 +4,41 @@ export default class TestSummary {
     #summary;
     #allDidPass;
     #anyWereRun;
+
+    #anyThrows;
+    #anyTroubles;
+    #anyCaught;
     
     get summary() {
         return this.#summary;
     }
     
-    set summary(value) {
-        this.#summary = value;
-    }
-    
     get allDidPass() {
         return this.#allDidPass;
     }
     
-    set allDidPass(value) {
-        this.#allDidPass = value;
-    }
-    
     get anyWereRun() {
         return this.#anyWereRun;
     }
     
-    set anyWereRun(value) {
-        this.#anyWereRun = value;
+    get anyThrows() {
+        return this.#anyThrows;
     }
-    
-    constructor(summary, allDidPass, anyWereRun) {
-        this.summary = summary;
-        this.allDidPass = allDidPass;
-        this.anyWereRun = anyWereRun;
+
+    get anyTroubles() {
+        return this.#anyTroubles;
+    }
+
+    get anyCaught() {
+        return this.#anyCaught;
+    }
+
+    constructor(summary, allDidPass, anyWereRun, anyThrows, anyTroubles, anyCaught) {
+        this.#summary = summary;
+        this.#allDidPass = allDidPass;
+        this.#anyWereRun = anyWereRun;
+        this.#anyThrows = anyThrows;
+        this.#anyTroubles = anyTroubles;
+        this.#anyCaught = anyCaught;
     }
 }

package/system/TotalComparer.js

@@ -1,6 +1,7 @@
 /**/
 
 import ATestSource from "./ATestSource.js";
+import ObjectAnalyzer from "./ObjectAnalyzer.js";
 
 export default class TotalComparer {
     constructor() {
@@ -65,26 +66,31 @@ export default class TotalComparer {
         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;
-            }
+
+        let expectedNames = ObjectAnalyzer.allProperties(expected);
+        let actualNames = ObjectAnalyzer.allProperties(actual);
+
+        // Objects with different numbers of properties can't be the same.
+        if (expectedNames.length !== actualNames.length) {
+            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)) {
+        // O(n) algorithm covers all other cases, including recursion.
+        for (let at = 0; at < expectedNames.length; at++) {
+            // Objects with differing property names can't be the same.
+            if (expectedNames[at] !== actualNames[at]) {
                 return false;
             }
-            
+
+            // Same property name in both objects.
+            let name = expectedNames[at];
+
+            // Individual props, or their throws if getters that fail.
+            let paired = this.#retrieveExpectedAndActualProps(name, expected, actual);
+
             // Cross-recursion.
-            let areEqual = this.#recurse(expected[propertyName], actual[propertyName]);
-            
+            let areEqual = this.#recurse(paired.expected, paired.actual);
+
             // Exit only at first false.
             switch (areEqual) {
                 case true: continue;
@@ -95,7 +101,32 @@ export default class TotalComparer {
         // No mismatched or missing found.
         return true;
     }
-    
+
+    /* Dependency of #recurseOverObjects(). */
+    #retrieveExpectedAndActualProps(name, expected, actual) {
+        /* Expected and actual prop values are retrieved in individual 
+           try-catches because getters may fail, and this way, 
+           any fails can be compared as indicators of overall state. */
+
+        let paired = { };
+
+        try {
+            paired.expected = expected[name];
+        }
+        catch (thrown) {
+            paired.expected = thrown;
+        }
+
+        try {
+            paired.actual = actual[name];
+        }
+        catch (thrown) {
+            paired.actual = thrown;
+        }
+
+        return paired;
+    }
+
     #recurseOverMaps(expected, actual) /* verified */ {
         // Both must be Maps.
         if (!(actual instanceof Map)) {
@@ -229,7 +260,7 @@ export default class TotalComparer {
     }
 
     #compareFunctions(expected, actual) /* verified */ {
-        // `expected` is already known to be a function / method.
+        // 'expected' is already known to be a function / method.
         if (!(actual instanceof Function)) {
             return false;
         }
@@ -253,6 +284,7 @@ export default class TotalComparer {
     }
 
     #compareDates(expected, actual) /* verified */ {
+        // 'expected' is already known to be a Date.
         if (!(actual instanceof Date)) {
             return false;
         }
@@ -261,6 +293,11 @@ export default class TotalComparer {
     }
 
     #compareErrors(expected, actual) /* verified */ {
+        // 'expected' is already known to be an Error.
+        if (!(actual instanceof Error)) {
+            return false;
+        }
+
         /* Compares Errors and subclasses accurately apart from .stack, 
            which is ignored because it rarely makes sense to compare it. */