risei 1.2.0 → 1.3.0

package/system/{SpoofTuple.js → SpoofDefinition.js}

@@ -4,7 +4,7 @@ import { TypeAnalyzer } from "./TypeAnalyzer.js";
 
 /* Defines what is found in a spoof-definition tuple (SDT).  Actual SDTs don't need to be instances of this class. */
 
-export class SpoofTuple {
+export class SpoofDefinition {
     // region Static fields
 
     /* Properties can have short or long names. */
@@ -15,7 +15,7 @@ export class SpoofTuple {
     ]);
     
     /* Objects with either of these property names aren't 
-       converted to SpoofTuples by from-nonce methods. */
+       converted to SpoofDefinitions by from-nonce methods. */
     static skipNames = [ "not", "skip" ];
 
     // endregion Static fields
@@ -107,23 +107,23 @@ export class SpoofTuple {
 
     static fromNonceTuples(nonces) {
         // Throughput and output.
-        let full = new SpoofTuple();
+        let full = new SpoofDefinition();
         let output = [];
 
         // Looping over all.
         for (let nonce of nonces) {
             // Don't convert non-tuples, but output 
             // them unchanged for the caller.
-            if (SpoofTuple.isNotASpoof(nonce)) {
+            if (SpoofDefinition.isNotASpoof(nonce)) {
                 output.push(nonce);
                 continue;
             }
         
             // Get latest spoof definition.
-            let latest = SpoofTuple.fromNonceTuple(nonce);
+            let latest = SpoofDefinition.fromNonceTuple(nonce);
 
             // Restarting spoof definitions when desired.
-            full = SpoofTuple.maybeRestartFull(full, latest);
+            full = SpoofDefinition.maybeRestartFull(full, latest);
 
             // Merge any previous 
             // values into latest.
@@ -147,21 +147,21 @@ export class SpoofTuple {
     /* Returns true if arg should not be used for spoofing.
        See isSpoofable() for a contrasting condition. */
     static isNotASpoof(nonce) /* passed */ {
-        /* Any nonce that is null or undefined is not a SpoofTuple. */
+        /* Any nonce that is null or undefined is not a SpoofDefinition. */
         if (nonce === undefined || nonce === null) {
             return true;
         }
     
-        /* Any nonce with .not or .skip isn't a SpoofTuple, even if it has SpoofTuple properties. */
-        for (let non of SpoofTuple.skipNames) {
+        /* Any nonce with .not or .skip isn't a SpoofDefinition, even if it has SpoofDefinition properties. */
+        for (let non of SpoofDefinition.skipNames) {
             if (nonce[non] !== undefined) {
                 return true;
             }
         }
         
-        /* Any other nonce with any SpoofTuple properties is a full or partial SpoofTuple. */
-        for (let key of SpoofTuple.#longsByShort.keys()) {
-            let value = SpoofTuple.#longsByShort.get(key);
+        /* Any other nonce with any SpoofDefinition properties is a full or partial SpoofDefinition. */
+        for (let key of SpoofDefinition.#longsByShort.keys()) {
+            let value = SpoofDefinition.#longsByShort.get(key);
         
             if (nonce[key] !== undefined) {
                 return false;
@@ -172,7 +172,7 @@ export class SpoofTuple {
             }
         }
     
-        /* Any nonce without SpoofTuple properties is not a spoof. */
+        /* Any nonce without SpoofDefinition properties is not a spoof. */
         return true;
     }
     
@@ -183,15 +183,15 @@ export class SpoofTuple {
     static fromNonceTuple(nonce) /* passed */ {
         // Empty, since properties can be set 
         // by either of two nonce naming styles.
-        let tuple = new SpoofTuple();
+        let tuple = new SpoofDefinition();
 
-        let shortNames = SpoofTuple.#longsByShort.keys();
+        let shortNames = SpoofDefinition.#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 = SpoofTuple.#longsByShort.get(shortName);
+            let longName = SpoofDefinition.#longsByShort.get(shortName);
             tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
         }
 
@@ -203,7 +203,7 @@ export class SpoofTuple {
 
     static maybeRestartFull(full, latest) /* passed */ {
         // When a (new) spoof target is named, return the new 
-        // SpoofTuple to wipe out all reused spoof values.
+        // SpoofDefinition to wipe out all reused spoof values.
         if (latest.target !== undefined) {
             full = latest;
         }
@@ -212,10 +212,10 @@ export class SpoofTuple {
     }
 
     combineWith(other) {
-        let shortNames = SpoofTuple.#longsByShort.keys();
+        let shortNames = SpoofDefinition.#longsByShort.keys();
 
         for (let shortName of shortNames) {
-            SpoofTuple.combineValues(this, other, shortName);
+            SpoofDefinition.combineValues(this, other, shortName);
         }
     }
 
@@ -233,7 +233,7 @@ export class SpoofTuple {
     // region Overrides and dependencies
 
     toString() /* passed */ {
-        let text = `SpoofTuple:{ target:${ this.#asRawOrString(this.target) }, `
+        let text = `SpoofDefinition:{ target:${ this.#asRawOrString(this.target) }, `
             + `method:${ this.#asRawOrString(this.method) }, `
             + `output:${ this.#asRawOrString(this.output) } }`;
         return text;

package/system/SpoofObjectMethodsFixture.js

@@ -1,7 +1,7 @@
 /* */
 
 import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofTuple } from "./SpoofTuple.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
 
 export class SpoofObjectMethodsFixture extends ASpoofingFixture {
     /* Algorithm:  Forward method spoof() looks at a test's .with and .in, and replaces entire objects 
@@ -31,12 +31,12 @@ export class SpoofObjectMethodsFixture extends ASpoofingFixture {
 
     spoofTarget(target) {
         // Non-spoof targets are returned unchanged.
-        if (SpoofTuple.isNotASpoof(target)) {
+        if (SpoofDefinition.isNotASpoof(target)) {
             return target;
         }
 
         // Spoof definition targets are converted.
-        let tuple = SpoofTuple.fromNonceTuple(target);
+        let tuple = SpoofDefinition.fromNonceTuple(target);
         let ofAsPairs = this.#supplySpoofPairs(tuple);
         
         // Returning object with one or more spoofed members.

package/system/{TestTuple.js → TestDefinition.js}

@@ -1,10 +1,13 @@
 /**/
 
 import { TypeAnalyzer } from "./TypeAnalyzer.js";
+import { TypeIdentifier } from "./TypeIdentifier.js";
+import { Types } from "./Types.js";
+import { TotalCopier } from "./TotalCopier.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 {
+export class TestDefinition {
     // region Definitions
 
     static staticName = "static";
@@ -33,6 +36,10 @@ export class TestTuple {
         [ "and", "factors" ]
     ]);
 
+    static #copier = new TotalCopier();
+
+    static #identifier = new TypeIdentifier();
+
     // endregion Static fields
 
     // region Private fields
@@ -57,12 +64,6 @@ export class TestTuple {
     source;
     factors;
 
-    /* &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;
     
@@ -179,12 +180,12 @@ export class TestTuple {
     }
 
     get isStaticTest() /* passed */ {
-        let does = this.andStringContains(TestTuple.staticName);
+        let does = this.andStringContains(TestDefinition.staticName);
         return does;
     }
     
     get isThrowTest() /* passed */ {
-        let is = this.andStringContains(TestTuple.throwName);
+        let is = this.andStringContains(TestDefinition.throwName);
         return is;
     }
 
@@ -199,8 +200,8 @@ export class TestTuple {
     }
 
     get isConstructorTest() /* passed */ {
-        let plainTarget = TestTuple.plainNameOf(this.of);
-        return plainTarget === TestTuple.constructorName;
+        let plainTarget = TestDefinition.plainNameOf(this.of);
+        return plainTarget === TestDefinition.constructorName;
     }
 
     get isMethodTest() /* passed */ {
@@ -208,11 +209,11 @@ export class TestTuple {
     }
 
     get isPropertyTest() /* passed */ {
-        let plainName = TestTuple.plainNameOf(this.of);
+        let plainName = TestDefinition.plainNameOf(this.of);
         
         let isPropertyTest 
-            = this.of.startsWith(TestTuple.dotOperator) 
-            || this.of.endsWith(TestTuple.colonOperator) 
+            = this.of.startsWith(TestDefinition.dotOperator) 
+            || this.of.endsWith(TestDefinition.colonOperator) 
             || this.#typeAnalyzer.memberIsProperty(plainName);
         
         return isPropertyTest;
@@ -261,18 +262,31 @@ export class TestTuple {
         this.#typeAnalyzer = new TypeAnalyzer(this.type);
     }
 
+    copy() {
+        // Empty initial copy.
+        let copy = new TestDefinition();
+
+        let names = TestDefinition.longsByShort.values();
+
+        for (let name of names) {
+            copy[name] = TestDefinition.#copier.copy(this[name]);
+        }
+        
+        return copy;
+    }
+
     static fromNonceTuples(nonces) {
         // Throughput and output.
-        let full = new TestTuple();
+        let full = new TestDefinition();
         let tuples = [];
 
         // Looping over all.
         for (let nonce of nonces) {
             // Get latest test definition.
-            let latest = TestTuple.fromNonceTuple(nonce);
+            let latest = TestDefinition.fromNonceTuple(nonce);
 
             // Restarting test definitions when desired.
-            full = TestTuple.maybeRestartFull(full, latest);
+            full = TestDefinition.maybeRestartFull(full, latest);
 
             // Merge any previous 
             // values into latest.
@@ -282,10 +296,11 @@ export class TestTuple {
             // combining with next time.
             full = latest;
 
-            // Add latest only if it's 
-            // ready to run as a test.
+            // Add (copy of) latest (for isolation), 
+            // only if it's ready to run as a test.
             if (latest.isRunnable) {
-                tuples.push(latest);
+                let copy = latest.copy();
+                tuples.push(copy);
             }
         }
 
@@ -296,15 +311,15 @@ export class TestTuple {
     static fromNonceTuple(nonce) {
         // Empty, since properties can be set 
         // by either of two nonce naming styles.
-        let tuple = new TestTuple();
+        let tuple = new TestDefinition();
 
-        let shortNames = TestTuple.longsByShort.keys();
+        let shortNames = TestDefinition.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 = TestTuple.longsByShort.get(shortName);
+            let longName = TestDefinition.longsByShort.get(shortName);
             tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
         }
 
@@ -318,13 +333,13 @@ export class TestTuple {
         // When a (new) model class is named, 
         // wipe out all reused test values.
         if (latest.type !== undefined) {
-            full = new TestTuple();
+            full = new TestDefinition();
         }
 
         // When a (new) model method is named, wipe out reused 
         // test values except the general ones for its class.
         if (latest.method !== undefined) {
-            full = new TestTuple(
+            full = new TestDefinition(
                 full.nature, full.type,
                 full.spoofed, full.initors
             );
@@ -334,10 +349,10 @@ export class TestTuple {
     }
 
     combineWith(other) {
-        let shortNames = TestTuple.longsByShort.keys();
+        let shortNames = TestDefinition.longsByShort.keys();
 
         for (let shortName of shortNames) {
-            TestTuple.combineValues(this, other, shortName);
+            TestDefinition.combineValues(this, other, shortName);
         }
     }
 
@@ -355,7 +370,7 @@ export class TestTuple {
     // region Other statics
 
     static plainNameOf(name) /* passed */ {
-        let plain = name.replaceAll(TestTuple.operatorsRegExp, "");
+        let plain = name.replaceAll(TestDefinition.operatorsRegExp, "");
         return plain;
     }
 

package/system/TestFinder.js

@@ -43,7 +43,7 @@ export class TestFinder extends ATestFinder {
         for (let testPath of testPaths) {
             // Contents of test sources have to be loaded.
             let sources = await this.convertPathToClassInstances(testPath.path);
-            
+
             // Any test classes in each source have to be loaded.
             for (let source of sources) {
                 let local = source.tests;
@@ -77,8 +77,8 @@ export class TestFinder extends ATestFinder {
 
     pathsFromTargetingSource() {
         let paths = [];
-        let root = process.cwd();        
-        
+        let root = process.cwd();
+
         // Recursively add all test 
         // files in tree to `paths`.
         this.searchTree(root, paths);
@@ -88,7 +88,7 @@ export class TestFinder extends ATestFinder {
     
     searchTree(root, paths) {
         let entries = fs.readdirSync(root, { withFileTypes: true });
-        
+
         for (let entry of entries) {
             // Working around a recent bug in fs of .path always undefined or wrong.
             entry.path = path.join(root, entry.name);
@@ -115,6 +115,11 @@ export class TestFinder extends ATestFinder {
     }
 
     sortTestPaths(testPaths) /* passed */ {
+        // An empty array can't be reduced, but can be returned as-is.
+        if (Array.isArray(testPaths) && testPaths.length === 0) {
+            return testPaths;
+        }
+
         // Latest is found for placing at end.
         let latest = testPaths.reduce((prior, now) => { return now.changed > prior.changed ? now : prior; });
 
@@ -148,8 +153,9 @@ export class TestFinder extends ATestFinder {
             return testSources;
         }
         catch (e) {
+            // Throw messages are retained for listing after tests are run.
             let fileName = path.basename(classPath);
-            console.log(`Test loading failed for ${ fileName }.    ${ e }`);
+            this.thrown.push(`Test loading failed for ${ fileName }.  ${ e }`);
             return [];
         }
     }

package/system/TestFrame.js

@@ -17,67 +17,60 @@ export class TestFrame {
         // Outer try for fails of groundwork requested.
         try {
             console.log(`cruft : b`);
-            /* &cruft, maybe simplify explanations here */
-
-            // Certain args must be isolated for collapsing forward, in case tested 
-            // code mutates them.  Sets test.localInitors and test.localInputs.
-            this.#stages.setLocalInitorsAndInputs(test);
-
-            console.log(`cruft : c`);
 
             // Spoofing, setting static properties, and so on.
             this.#stages.anyPreTargetingGroundwork(test);
             
-            console.log(`cruft : d`);
+            console.log(`cruft : c`);
 
             // Target may be instance, prototype for constructors, the class 
             // itself for statics, or nonce for properties.  Sets test.target.
             this.#stages.setLocalTarget(test);
             
-            console.log(`cruft : e`);
+            console.log(`cruft : d`);
             
             // Method under test may be on instance, class, 
             // or nonce for properties.  Sets test.callable.
             this.#stages.setLocalCallable(test);
             
-            console.log(`cruft : f`);
+            console.log(`cruft : e`);
             
             // Setting instance properties and so on.
             this.#stages.anyPostTargetingGroundwork(test);
             
             
-            console.log(`cruft : g`);
+            console.log(`cruft : f`);
             
             // Inner try for fails of targeted code only.
             try {
-                console.log(`cruft : h`);
+                console.log(`cruft : g`);
                 
                 console.log(`cruft : test.actual:`, test.actual);
                 console.log(`cruft : test.localTarget:`, test.localTarget);
                 console.log(`cruft : test.localCallable:`, test.localCallable);
-                console.log(`cruft : test.localInputs:`, test.localInputs);
+                console.log(`cruft : test.in:`, test.in);
             
                 // Tests usually look for this.
-                test.actual = test.localTarget[test.localCallable](...test.localInputs);
+                test.actual = test.localTarget[test.localCallable](...test.in);
                 
                 console.log(`cruft : test.actual:`, test.actual);
-                console.log(`cruft : i`);
+                console.log(`cruft : h`);
             }
             catch (thrown) {
-                console.log(`cruft : j`);
+                console.log(`cruft : i`);
                 
                 // Sometimes tests look for this.
                 test.thrown = thrown;
                 
-                console.log(`cruft : k`);
+                console.log(`cruft : j`);
             }
 
-            console.log(`cruft : l`);
+            console.log(`cruft : k`);
 
             // Sometimes tests look for results elsewhere. 
             this.#stages.anyModifyActual(test);
 
-            console.log(`cruft : m`);
+            console.log(`cruft : l`);
 
             /* &cruft, remove test-checking line when all tests pass */
             // test.didPass = "fails";
@@ -85,103 +78,18 @@ export class TestFrame {
             // Actually testing the result.
             test.didPass = this.#stages.compareResults(test.output, test.actual);
             
-            console.log(`cruft : n`);
+            console.log(`cruft : m`);
             
         }
         finally {
-            console.log(`cruft : o`);
+            console.log(`cruft : n`);
         
             // Undoing any groundwork changes made. 
             this.#stages.anyGroundworkReversion(test);
             
-            console.log(`cruft : p`);
+            console.log(`cruft : o`);
         }
         
-        console.log(`cruft : q`);
+        console.log(`cruft : p`);
     }
-
-    // // region Dependencies of test frames
-    //
-    // /* &cruft, remove if / once superseded by code in TestStages */
-    //
-    // #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, 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;
-    // }
-    //
-    // // endregion Dependencies of test frames
-    //
-
 }

package/system/TestRunner.js

@@ -2,7 +2,7 @@
 
 /* Runs tests one by one as an ATestCaller requests them. */
 
-import { TestTuple } from "./TestTuple.js";
+import { TestDefinition } from "./TestDefinition.js";
 import { TestGroup } from "./TestGroup.js";
 import { ClassTestGroup } from "./ClassTestGroup.js";
 import { MethodTestGroup } from "./MethodTestGroup.js";
@@ -14,7 +14,7 @@ import { TestFrames } from "./TestFrames.js";
 
 import { SpoofClassMethodsFixture } from "./SpoofClassMethodsFixture.js";
 import { SpoofObjectMethodsFixture } from "./SpoofObjectMethodsFixture.js";
-import { SpoofTuple } from "./SpoofTuple.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
 
 export class TestRunner {
     // region Static definition fields
@@ -143,7 +143,7 @@ export class TestRunner {
         }
     
         // Converting so that property names can be relied on.
-        this.#tests = TestTuple.fromNonceTuples(this.tests);
+        this.#tests = TestDefinition.fromNonceTuples(this.tests);
 
         // Needed for displaying classes and methods as groups.
         let classGroup = new ClassTestGroup();
@@ -222,7 +222,7 @@ export class TestRunner {
     
     // region Dependencies of runOneTest()
     
-    // Spoofs objects as defined in TestTuple's 
+    // Spoofs objects as defined in TestDefinition's 
     // .with and .in, which can contain spoofs.
     #anyObjectSpoofing(test) {
         // Spoofing objects may be skipped for self-testing.

package/system/TestStages.js

@@ -1,6 +1,6 @@
 /**/
 
-import { TestTuple } from "./TestTuple.js";
+import { TestDefinition } from "./TestDefinition.js";
 import { TotalComparer } from "./TotalComparer.js";
 import { TotalCopier } from "./TotalCopier.js";
 
@@ -14,14 +14,6 @@ export class TestStages {
     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.
@@ -37,7 +29,7 @@ export class TestStages {
             return;
         }
 
-        let callable = TestTuple.plainNameOf(test.of);
+        let callable = TestDefinition.plainNameOf(test.of);
         
         let target = test.isInstanceTest 
             ? this.#supplyInstanceLocalTarget(test, callable) 
@@ -61,7 +53,7 @@ export class TestStages {
     }
 
     #supplyInstanceLocalTarget(test, callable) /* verified */ {
-        let instance = new test.on.prototype.constructor(...test.localInitors);
+        let instance = new test.on.prototype.constructor(...test.with);
         
         // Methods are called on instance directly.  
         // Properties are called on instance in nonce.
@@ -79,8 +71,8 @@ export class TestStages {
            or a nonce method for a property test. */
         
         test.localCallable = test.isMethodTest 
-            ? TestTuple.plainNameOf(test.method) 
-            : TestTuple.nonceLocalCallableName;
+            ? TestDefinition.plainNameOf(test.method) 
+            : TestDefinition.nonceLocalCallableName;
     }
     
     anyPostTargetingGroundwork(test) {