risei 1.0.3 → 1.1.0

package/public/javascript/TestFrames.js

@@ -0,0 +1,180 @@
+/**/
+
+import { AComparer } from "./AComparer.js";
+import { TotalComparer } from "./TotalComparer.js";
+
+export class TestFrames {
+    /* &cruft : refactor to merge with same on TestFrameChooser */
+    // Used for special test cases.
+    constructorName = "constructor";
+    staticName = "static";
+
+    /* &cruft : probably refactor comparing usage */
+    /* Each test frame is bound to the calling instance of TestRunner, 
+       for now at least.  TestRunner includes #compare() for now. */
+
+    #comparer;
+
+    constructor() {
+        // Comparer is inited once for all tests, since compare() is reentrant.
+        this.#comparer = new TotalComparer();
+    }
+
+    // The most basic test: whether a call of 
+    // a method returns the expected value.
+    testReturnValueOfCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+
+        /* Exercising the code. */
+        test.actual = target[test.of](...test.in);  // Must use `...`.
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    testReturnValueOfStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        /* Exercising the code. */
+        test.actual = test.on[test.of](...test.in);  // Must use `...`.
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // The second-most basic test: whether a property 
+    // has the expected value after a method call.
+    testCodeElementAfterCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+
+        /* Exercising the code. */
+        target[test.of](...test.in);  // Must use `...`.
+
+        /* Retrieving. */
+        // The `actual` is a property or other code element somewhere.
+        test.actual = this.#supplyNonReturnActual(test, target);
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testCodeElementAfterStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        /* Exercising the code. */
+        test.on[test.of](...test.in);  // Must use `...`.
+        
+        /* Retrieving. */
+        test.actual = this.#supplyNonReturnActual(test);  // No `target` here.
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // The third-most basic test: whether a property has 
+    // the expected value after an object is constructed.
+    testCodeElementAfterConstruction(test) {
+        /* Groundwork. */
+        // For definition consistency, initing with test.in, not test.with.
+        let prototype = test.on.prototype;
+        
+        /* Exercising the code. */
+        let target = new prototype.constructor(...test.in);  // Must use `...`.
+
+        /* Retrieving. */
+        // The `actual` is a property or other code element somewhere.
+        test.actual = this.#supplyNonReturnActual(test, target);
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testThrowResultAfterCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+        
+        /* Exercising the code. */
+        try {
+            target[test.of](...test.in);  // Must use `...`.
+        }
+        /* Retrieving. */
+        catch (thrown) {
+            test.actual = thrown.message;
+        }
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testThrowResultAfterStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        /* Exercising the code. */
+        try {
+            test.on[test.of](...test.in)  // Must use `...`.
+        }
+        catch (thrown) {
+            test.actual = thrown.message;
+        }
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // region Dependencies of test frames
+
+    #compare(expected, actual) {
+        return this.#comparer.compare(expected, actual);
+    }
+
+    #supplyNonReturnActual(test, target) {
+        // When there is a .from that's a string, 
+        // the actual is the named target member.
+        if (typeof test.from === "string") {
+            // Common member host; 
+            // undefined if static.
+            let host = target;
+            
+            // When .and defines static.
+            if (this.#doesAddressStatics(test)) {
+                host = test.on;
+            }
+        
+            return host[test.from];
+        }
+        
+        // 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) {
+            return test.from(target, test);
+        }
+
+        // When there is any other .from, the actual is the
+        // value of the code element provided as .from.
+        return test.from;
+    }
+    
+    /* &cruft : refactor to merge with same on TestFrameChooser */
+    #doesAddressStatics(test) {
+        if (typeof test.and === "string") {
+            if (test.and.includes(this.staticName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // endregion Dependencies of test frames
+
+
+}

package/public/javascript/TestRunner.js

@@ -9,13 +9,13 @@ import { MethodTestGroup } from "./MethodTestGroup.js";
 import { TestResult } from "./TestResult.js";
 import { TestSummary } from "./TestSummary.js";
 
+import { TestFrameChooser } from "./TestFrameChooser.js";
+import { TestFrames } from "./TestFrames.js";
+
 import { SpoofClassMethodsFixture } from "./SpoofClassMethodsFixture.js";
 import { SpoofObjectMethodsFixture } from "./SpoofObjectMethodsFixture.js";
 import { SpoofTuple } from "./SpoofTuple.js";
 
-import { AComparer } from "./AComparer.js";
-import { TotalComparer } from "./TotalComparer.js";
-
 export class TestRunner {
     // region Static definition fields
 
@@ -33,6 +33,9 @@ export class TestRunner {
     #classSpoofer;
     #instanceSpoofer;
     
+    #frameSource;
+    #frameChooser;
+    
     #comparer;
 
     // Results summary.
@@ -73,14 +76,6 @@ export class TestRunner {
 
     // endregion Spoofing
 
-    get comparer() {
-        return this.#comparer;
-    }
-    
-    set comparer(value) {
-        this.#comparer = value;
-    }
-
     get numberRun() {
         return this.#numberRun;
     }
@@ -119,15 +114,15 @@ export class TestRunner {
         this.#tests = [];
         this.#classSpoofer = new SpoofClassMethodsFixture();
         this.#instanceSpoofer = new SpoofObjectMethodsFixture();
+        
+        this.#frameSource = new TestFrames();
+        this.#frameChooser = new TestFrameChooser(this.#frameSource);
 
         this.#numberRun = 0;
         this.#numberPassed = 0;
         this.#numberFailed = 0;
 
         this.#allDidPass = true;
-
-        // Comparer is inited once for all tests, since compare() is reentrant.
-        this.#comparer = new TotalComparer();
     }
 
     // region Tests to run
@@ -188,16 +183,20 @@ export class TestRunner {
 
         // Spoofing based on any spoof 
         // definitions in .with and .of.
-        this.#spoofObjects(test);
+        this.#anyObjectSpoofing(test);
 
         // Gathering facts defining the nature of the test, 
         // some of which might change after the test is run.
         let result = new TestResult(test);
         result.setNature();
 
-        // Choosing the right test frame for the definition.
-        let testFrame = this.#supplyTestFrame(test);
-        testFrame = testFrame.bind(this);
+        // Aspects of the test determine the right test frame,
+        // bound back to its class to use private class members.
+        let testFrame = this.#frameChooser.supplyTestFrame(test);
+        testFrame = testFrame.bind(this.#frameSource);
+
+        // Done in every test.
+        this.#anyMethodSpoofing(test);
 
         // Actually running the test.
         try {
@@ -205,8 +204,12 @@ export class TestRunner {
         }
         catch (thrown) {
             test.anyThrow = thrown;
+            test.didPass = false;
         }
         
+        // Done in every test, whether passed, failed, or thrown.
+        this.#anyMethodRestoring(test);
+        
         // Gathering facts based on the test run.
         result.setResults();
 
@@ -221,64 +224,31 @@ export class TestRunner {
     
     // Spoofs objects as defined in TestTuple's 
     // .with and .in, which can contain spoofs.
-    #spoofObjects(test) {
-        this.#instanceSpoofer.spoof(test);
-    }
-    
-    #supplyTestFrame(test) {
-        // If `.and` includes "static", a call of a static member 
-        // is made, and the actual is its return value.
+    #anyObjectSpoofing(test) {
+        // Spoofing objects may be skipped for self-testing.
         if (typeof test.and === "string") {
-            if (this.#doesAddressStatics(test)) {
-                // If .from, a static call is made, then the actual is 
-                // retrieved from a named code element or custom code.
-                if (test.from !== undefined) {
-                    return this.testCodeElementAfterStaticCall;
-                }
-            
-                // Otherwise, the return value 
-                // of the static call is used.
-                return this.testReturnValueOfStaticCall;
+            if (test.and.includes("nospoof")) {
+                return;
             }
         }
     
-        // Constructors are a special case; no second call should 
-        // be made, and actual must be retrieved from property.
-        if (test.of === TestRunner.#constructorName) {
-            return this.testCodeElementAfterConstruction;
-        }
+        // Actually spoofing, if any is defined.
+        this.#instanceSpoofer.spoof(test);
+    }
 
-        // If .from, a call of the target is made, then the actual 
-        // is retrieved from a named code element or custom code.
-        if (this.#isRetrievalTest(test.from)) {
-            return this.testCodeElementAfterCall;
+    #anyMethodSpoofing(test) {
+        if (test.plus === undefined) {
+            return;
         }
 
-        // The most common case: the target is called, 
-        // and the actual is its return value.
-        return this.testReturnValueOfCall;
+        this.#classSpoofer.spoof(test);
     }
-    
-    #isRetrievalTest(testFrom) {
-        // Falsy code elements never are a retrieval.
-        if (!testFrom) {
-            return false;
-        }
-        
-        // If a (non-falsy) string, must be a retrieval.
-        if (typeof testFrom === "string") {
-            return true;
-        }
-        
-        // If a function, is a retrieval.
-        if (testFrom instanceof Function) {
-            return true;
-        }
-        
-        // Anything else is not a retrieval.
-        return false;
+
+    #anyMethodRestoring(test) {
+        this.#classSpoofer.unspoof();
+        this.#classSpoofer.removeDefinitions();
     }
-    
+
     #retainTestResults(test) {
         this.#numberRun++;
 
@@ -307,170 +277,4 @@ export class TestRunner {
 
     // endregion Running tests
 
-    // region Test frames
-
-    // The most basic test: whether a call of 
-    // a method returns the expected value.
-    testReturnValueOfCall(test) {
-        /* Groundwork. */
-        this.#anyMethodSpoofing(test);
-
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.with);  // Must use `...`.
-
-        /* Exercising the code. */
-        test.actual = target[test.of](...test.in);  // Must use `...`.
-
-        /* Restoring. */
-        this.#anyMethodRestoring(test);
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    testReturnValueOfStaticCall(test) {
-        /* Groundwork. */
-        this.#anyMethodSpoofing(test);
-        
-        /* No instance is constructed. */
-        
-        /* Exercising the code. */
-        test.actual = test.on[test.of](...test.in);  // Must use `...`.
-        
-        /* Restoring. */
-        this.#anyMethodRestoring(test);
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // The second-most basic test: whether a property 
-    // has the expected value after a method call.
-    testCodeElementAfterCall(test) {
-        /* Groundwork. */
-        this.#anyMethodSpoofing(test);
-
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.with);  // Must use `...`.
-
-        /* Exercising the code. */
-        target[test.of](...test.in);  // Must use `...`.
-
-        /* Retrieving. */
-        // The `actual` is a property or other code element somewhere.
-        test.actual = this.#supplyNonReturnActual(test, target);
-
-        /* Restoring. */
-        this.#anyMethodRestoring(test);
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-    
-    testCodeElementAfterStaticCall(test) {
-        /* Groundwork. */
-        this.#anyMethodSpoofing(test);
-        
-        /* No instance is constructed. */
-        
-        /* Exercising the code. */
-        test.on[test.of](...test.in);  // Must use `...`.
-        
-        /* Retrieving. */
-        test.actual = this.#supplyNonReturnActual(test);  // No `target` here.
-        
-        /* Restoring. */
-        this.#anyMethodRestoring(test);
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // The third-most basic test: whether a property has 
-    // the expected value after an object is constructed.
-    testCodeElementAfterConstruction(test) {
-        /* Groundwork. */
-        this.#anyMethodSpoofing(test);
-
-        /* Exercising the code. */
-        // For definition consistency, initing with test.in, not test.with.
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.in);  // Must use `...`.
-
-        /* Retrieving. */
-        // The `actual` is a property or other code element somewhere.
-        test.actual = this.#supplyNonReturnActual(test, target);
-
-        /* Restoring. */
-        this.#anyMethodRestoring(test);
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // endregion Test frames
-
-    // region Dependencies of test frames
-
-    #anyMethodSpoofing(test) {
-        if (test.plus === undefined) {
-            return;
-        }
-
-        this.#classSpoofer.spoof(test);
-    }
-
-    #compare(expected, actual) {
-        return this.#comparer.compare(expected, actual);
-    }
-
-    #supplyNonReturnActual(test, target) {
-        // When there is a .from that's a string, 
-        // the actual is the named target member.
-        if (typeof test.from === "string") {
-            // Common member host; 
-            // undefined if static.
-            let host = target;
-            
-            // When .and defines static.
-            if (this.#doesAddressStatics(test)) {
-                host = test.on;
-            }
-        
-            return host[test.from];
-        }
-        
-        // 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) {
-            return test.from(target, test);
-        }
-
-        // When there is any other .from, the actual is the
-        // value of the code element provided as .from.
-        return test.from;
-    }
-
-    #anyMethodRestoring(test) {
-        this.#classSpoofer.unspoof();
-        this.#classSpoofer.removeDefinitions();
-    }
-
-    // endregion Dependencies of test frames
-
-    // region Cross-region dependencies
-
-    #doesAddressStatics(test) {
-        if (typeof test.and === "string") {
-            if (test.and.includes("static")) {  /* &cruft, abstract */
-                return true;
-            }
-        }
-    
-        return false;
-    }
-
-    // endregion Cross-region dependencies
-
 }

package/public/javascript/TestTuple.js

@@ -19,7 +19,7 @@ export class TestTuple {
 
     // endregion Static fields
 
-    // region Private fields
+    // region Fields
 
     /* These longer names match the constructor-arg names. 
        The short-name properties use the same fields. */
@@ -33,8 +33,11 @@ export class TestTuple {
     output;
     source;
     factors;
+
+    // Outcome field is not part of general system.
+    #actual = null;
     
-    // endregion Private fields
+    // endregion Fields
 
     // region Properties
 
@@ -130,6 +133,14 @@ export class TestTuple {
         return isRunnable;
     }
 
+    get actual() {
+        return this.#actual;
+    }
+    
+    set actual(value) {
+        this.#actual = value;
+    }
+
     // endregion Tuple state
 
     // endregion Properties