risei 1.1.0 → 1.1.2

package/system/TestStages.js

@@ -0,0 +1,278 @@
+/**/
+
+import { TestTuple } from "./TestTuple.js";
+import { TotalComparer } from "./TotalComparer.js";
+import { TotalCopier } from "./TotalCopier.js";
+
+export class TestStages {
+    /* &cruft, implement all of these under test, and eventually factor them */
+
+    /* These methods hold operations carried out in the test frame, 
+       or before / after all test frames, in the test runner.  
+       Not necessarily all test steps are found here. */
+
+    static #comparer = new TotalComparer();
+    static #copier = new TotalCopier();
+
+    setLocalInitorsAndInputs(test) /* passed */ {
+        /* Sets local__ of each to a copy of the original, 
+           so any mutated args aren't collapsed forward. */
+
+        test.localInitors = TestStages.#copier.copy(test.with);
+        test.localInputs = TestStages.#copier.copy(test.in);
+    }
+    
+    anyPreTargetingGroundwork(test) {
+        // Spoofing of class members here.
+        // Setting any static properties here.
+    }
+    
+    setLocalTarget(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.localTarget = test.on.prototype;
+            return;
+        }
+
+        let callable = TestTuple.plainNameOf(test.of);
+        
+        let target = test.isInstanceTest 
+            ? this.#supplyInstanceLocalTarget(test, callable) 
+            : this.#supplyStaticLocalTarget(test, callable);
+
+        test.localTarget = target;
+    }
+    
+    // region Dependencies of setLocalTarget()
+    
+    #supplyStaticLocalTarget(test, callable) /* verified */ {
+        let type = test.on;
+        
+        // Methods are called on class directly.  
+        // Properties are called on class in nonce.
+        let target = test.isMethodTest 
+            ? type 
+            : { localCallable: () => { return type[callable]; } };
+
+        return target;
+    }
+
+    #supplyInstanceLocalTarget(test, callable) /* verified */ {
+        let instance = new test.on.prototype.constructor(...test.localInitors);
+        
+        // Methods are called on instance directly.  
+        // Properties are called on instance in nonce.
+        let target = test.isMethodTest  
+            ? instance 
+            : { localCallable: () => { return instance[callable]; } };
+            
+        return target; 
+    }
+    
+    // endregion Dependencies of setLocalTarget()
+
+    setLocalCallable(test) /* passed */ {
+        /* Method under test is a method named in test, 
+           or a nonce method for a property test. */
+        
+        test.localCallable = test.isMethodTest 
+            ? TestTuple.plainNameOf(test.method) 
+            : TestTuple.nonceLocalCallableName;
+    }
+    
+    anyPostTargetingGroundwork(test) {
+        // Setting instance properties.
+    }
+    
+    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;
+        }
+
+        if (test.isRetrievalTest) {
+            test.actual = this.supplyNonReturnActual(test);
+        }
+    }
+    
+    compareResults(expected, actual) /* passed */ {
+        return TestStages.#comparer.compare(expected, actual);
+    }
+    
+    anyGroundworkReversion(test) {
+        // Unspoofing.
+        // Unsetting static properties.
+        // Undoing any other groundwork changes made.
+    }
+
+
+    // region Dependencies of test stages
+
+    #anyOriginalPropertyGetting(target, settables) {
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        let unsettables = [ ];
+        
+        for (let settable of settables) {
+            // Not a setter tuple.
+            if (!settable.of) {
+                continue;
+            }
+            
+            // Retaining original.
+            let original = target[settable.of];
+            let unsettable = { of: settable.of, as: original };
+            unsettables.push(unsettable);
+        }
+        
+        return unsettables;
+    }
+
+    #anyPropertySetting(target, settables) {
+        // No properties to set.
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        for (let settable of settables) {
+            // Not a setter tuple.
+            if (!settable.of) {
+                continue;
+            }
+
+            // Actually setting property.
+            target[settable.of] = settable.as;
+        }
+    }
+    
+    #anyPropertyUnsetting(target, unsettables) {
+        // Unsetting is the same as setting, 
+        // but with tuples of original values.
+        return this.#anyPropertySetting(target, unsettables);
+    }
+
+    #compare(expected, actual) {
+        return this.#comparer.compare(expected, actual);
+    }
+
+    supplyNonReturnActual(test) {
+        // When there is a .from that's a string, 
+        // the actual is the named target member.
+        if (typeof test.from === "string") {
+            /* &cruft, maybe explain how this differs from setting .localTarget, 
+                       which can be a nonce, or else maybe make them the same */
+
+            // Common member host; 
+            // undefined if static.
+            let host = test.target;
+            
+            // When .and defines static.
+            if (test.isStaticTest) {
+                host = test.on;
+            }
+        
+            return host[test.from];
+        }
+        
+        /* &cruft, possibly change all .from syntax to (actual, test), 
+                   or maybe to (test), or else switch back args here */
+        // 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(test.actual, test.localTarget);
+        }
+
+        /* &cruft, probably drop this, change maybe to a throw */
+        // When there is any other .from, the actual is the
+        // value of the code element provided as .from.
+        return test.from;
+    }
+    
+    // endregion Dependencies of test stages
+
+
+    /* &cruft, remove or use this code... */
+
+    // anyOriginalPropertyGetting(target, settables) {
+    //     if (!Array.isArray(settables)) {
+    //         return;
+    //     }
+    //
+    //     let unsettables = [ ];
+    //    
+    //     for (let settable of settables) {
+    //         // Not a setter tuple.
+    //         if (!settable.of) {
+    //             continue;
+    //         }
+    //        
+    //         // Retaining original.
+    //         let original = target[settable.of];
+    //         let unsettable = { of: settable.of, as: original };
+    //         unsettables.push(unsettable);
+    //     }
+    //    
+    //     return unsettables;
+    // }
+    //
+    // anyPropertySetting(target, settables) {
+    //     // No properties to set.
+    //     if (!Array.isArray(settables)) {
+    //         return;
+    //     }
+    //
+    //     for (let settable of settables) {
+    //         // Not a setter tuple.
+    //         if (!settable.of) {
+    //             continue;
+    //         }
+    //
+    //         // Actually setting property.
+    //         target[settable.of] = settable.as;
+    //     }
+    // }
+    //
+    // anyPropertyUnsetting(target, unsettables) {
+    //     // Unsetting is the same as setting, 
+    //     // but with tuples of original values.
+    //     return this.anyPropertySetting(target, unsettables);
+    // }
+    //
+    // 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 (test.isStaticTest) {
+    //             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;
+    // }
+    
+}

package/{public/javascript → system}/TestTuple.js

@@ -1,8 +1,23 @@
 /**/
 
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
+
 /* 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 Definitions
+
+    static staticName = "static";
+    static throwName = "throw";
+    static constructorName = "constructor";
+    static nonceLocalCallableName = "localCallable";
+    static dotOperator = ".";
+    static colonOperator = ":";
+    static parensOperator = "()";
+    static operatorsRegExp = /\.|:|\(\)/g;
+
+    // endregion Definitions
+
     // region Static fields
 
     static longsByShort = new Map([
@@ -11,6 +26,7 @@ export class TestTuple {
         [ "with", "initors" ],
         [ "of", "method" ],
         [ "plus", "spoofed" ],
+        [ "amid", "settables" ],
         [ "in", "inputs" ],
         [ "out", "output" ],
         [ "from", "source" ],
@@ -19,6 +35,12 @@ export class TestTuple {
 
     // endregion Static fields
 
+    // region Private fields
+
+    #typeAnalyzer;
+
+    // endregion Private fields
+
     // region Fields
 
     /* These longer names match the constructor-arg names. 
@@ -29,13 +51,23 @@ export class TestTuple {
     initors;
     method;
     spoofed;
+    settables;
     inputs;
     output;
     source;
     factors;
 
-    // Outcome field is not part of general system.
-    #actual = null;
+    /* &cruft, possibly drop defaults when properties settable in tests */
+    // These fields are not part of collapse-forward system:
+    // Local copies of args; local test targets; outcome fields.
+    localInitors = [ ];
+    localInputs = [ ];
+    
+    localTarget;
+    localMethod;
+    
+    actual;
+    thrown;
     
     // endregion Fields
 
@@ -84,6 +116,15 @@ export class TestTuple {
     set plus(value) {
         this.spoofed = value;
     }
+    
+    /* &cruft, rename this .amid property pair */
+    get amid() { 
+        return this.settables; 
+    }
+    
+    set amid(value) { 
+        this.settables = value; 
+    }
 
     get in() {
         return this.inputs;
@@ -119,7 +160,7 @@ export class TestTuple {
 
     // endregion Test definition, short names
 
-    // region Tuple state
+    // region Tuple state and dependencies
 
     get isRunnable() {
         let isRunnable
@@ -133,15 +174,71 @@ export class TestTuple {
         return isRunnable;
     }
 
-    get actual() {
-        return this.#actual;
+    get isInstanceTest() /* passed */ {
+        return !this.isStaticTest || this.isConstructorTest;
+    }
+
+    get isStaticTest() /* passed */ {
+        let does = this.andStringContains(TestTuple.staticName);
+        return does;
     }
     
-    set actual(value) {
-        this.#actual = value;
+    get isThrowTest() /* passed */ {
+        let is = this.andStringContains(TestTuple.throwName);
+        return is;
+    }
+
+    /* Needed externally, and dependency 
+       of all .and-based properties. */
+    andStringContains(keyword) /* passed */ {
+        let doesContain 
+            = typeof this.and === "string"
+            && this.and.includes(keyword);
+
+        return doesContain;
+    }
+
+    get isConstructorTest() /* passed */ {
+        let plainTarget = TestTuple.plainNameOf(this.of);
+        return plainTarget === TestTuple.constructorName;
+    }
+
+    get isMethodTest() /* passed */ {
+        return !this.isPropertyTest;
+    }
+
+    get isPropertyTest() /* passed */ {
+        let plainName = TestTuple.plainNameOf(this.of);
+        
+        let isPropertyTest 
+            = this.of.startsWith(TestTuple.dotOperator) 
+            || this.of.endsWith(TestTuple.colonOperator) 
+            || this.#typeAnalyzer.memberIsProperty(plainName);
+        
+        return isPropertyTest;
     }
 
-    // endregion Tuple state
+    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;
+    }
+
+    // endregion Tuple state and dependencies
 
     // endregion Properties
 
@@ -149,16 +246,19 @@ export class TestTuple {
 
     /* 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;
+    constructor(nature, type, spoofed, initors, settables, method, inputs, output, source, factors) {
+        this.nature = nature;        // .for 
+        this.type = type;            // .on 
+        this.spoofed = spoofed;      // .plus 
+        this.initors = initors;      // .with 
+        this.settables = settables;  // .amid 
+        this.method = method;        // .of 
+        this.inputs = inputs;        // .in 
+        this.output = output;        // .out 
+        this.source = source;        // .from 
+        this.factors = factors;      // .and 
+
+        this.#typeAnalyzer = new TypeAnalyzer(this.type);
     }
 
     static fromNonceTuples(nonces) {
@@ -252,4 +352,12 @@ export class TestTuple {
 
     // endregion Initing, including constructor()
 
+    // region Other statics
+
+    static plainNameOf(name) /* passed */ {
+        let plain = name.replaceAll(TestTuple.operatorsRegExp, "");
+        return plain;
+    }
+
+    // endregion Other statics
 }

package/{public/javascript → system}/TotalComparer.js

@@ -36,6 +36,10 @@ export class TotalComparer extends AComparer {
             return this.#compareFunctions(expected, actual);
         }
         
+        if (expected instanceof Date) {
+            return this.#compareDates(expected, actual);
+        }
+        
         if (expected instanceof Object) {
             /* Traverse / recurse to leaves. */
             return this.#recurseOverObjects(expected, actual);
@@ -223,6 +227,14 @@ export class TotalComparer extends AComparer {
         return expectedCode === actualCode;
     }
 
+    #compareDates(expected, actual) /* verified */ {
+        if (!(actual instanceof Date)) {
+            return false;
+        }
+        
+        return expected.valueOf() === actual.valueOf();
+    }
+
     // endregion Dependencies of compare()
 
 }

package/system/TotalCopier.js

@@ -0,0 +1,79 @@
+/**/
+
+export class TotalCopier {
+    copy(original) /* passed */ {
+        return this.recursiveCopy(original);
+    }
+
+    recursiveCopy(original) /* verified */ {
+        /* &cruft, factor, possibly abstracting similar code, 
+                   and/or return copy only once, or similar */
+
+        /* Algorithm: First copied at current level by value if a value, by reference if 
+                      not a value; then recursively replaced at next level, and so on. */
+
+        let copy;
+
+        if (Array.isArray(original)) {
+            copy = [ ];
+            
+            // Traversal construction with recursion.
+            for (let item of original) {
+                let next = this.recursiveCopy(item);
+                copy.push(next);
+            }
+            
+            return copy;
+        }
+        
+        if (original instanceof Map) {
+            copy = new Map();
+
+            // Traversal construction with recursion.
+            for (let entry of original.entries()) {
+                let next = this.recursiveCopy(entry);
+                copy.set(next[0], next[1]);
+            }
+            
+            return copy;
+        }
+        
+        if (original instanceof Set) {
+            copy = new Set();
+
+            // Traversal construction with recursion.
+            for (let value of original.values()) {
+                let next = this.recursiveCopy(value);
+                copy.add(next);
+            }
+
+            return copy;
+        }
+
+        if (original instanceof Date) {
+            copy = new Date(original);
+            return copy;
+        }
+
+        if (original instanceof Object) {
+            copy = { };
+            
+            let keys = Object.keys(original);
+            
+            // Traversal construction with recursion.
+            for (let key of Object.keys(original)) {
+                let next = this.recursiveCopy(original[key]);
+                copy[key] = next;
+            }
+            
+            return copy;
+        }
+        
+        /* &cruft, other object types here */
+
+        // All object types exhausted, so this is a value, 
+        // which can be used directly for a copy.
+        copy = original;
+        return copy;
+    }
+}