risei 1.3.1 → 1.3.3

package/README.md

@@ -123,9 +123,9 @@ You can save a lot of time by putting repeated test properties into an object on
     { of: "countOf", for: "Returns the number present.", in: [ "b" ], out: 2 }
 ```
 
-- This _collapsing forward_ works for just about every test property, but is reset when you change the class in `.on`, when you give the property a new value, or you erase it with an empty array `[ ]`.
+- This _collapsing forward_ is reset when you change the class in `.on`, when you give the property a new value, or you erase it with an empty array `[]`.
 
-- When the tested code mutates the contents of `.with` or `.in`, provide these args as the output of a function or method, because at present, the mutated values are collapsed forward.
+- Tests are isolated in general, but if the code you're testing mutates its arguments, you have to state them in each test so the mutations aren't carried forward.
 
 
 
@@ -134,7 +134,7 @@ You can save a lot of time by putting repeated test properties into an object on
 When your tests need certain results from code dependencies, just _spoof_ what you want using a `.plus` test property:
 
 ```javascript
-        { on: CombinerClass, with: [ ], 
+        { on: CombinerClass, with: [], 
           of: "combineResults",
           plus: [ 
             { on: ClassA, of: "someMethod", as: 10 },    // Spoof this ClassA method to return 10.
@@ -153,9 +153,9 @@ When your tests need certain results from code dependencies, just _spoof_ what y
           in: [ "green" ], out: [ 7, 8, 9, 10, 10, 11, 12, { color: "green" } ] }
 ```
 
-- Spoofing collapses forward across tests, but not across the elements within `.plus`.
+- It's just like _fakes_, _mocks_, or _test doubles_ in other test systems, but much easier to write and read.
 
-- Spoofing is also fully isolated within tests.
+- Spoofed code is fully isolated within tests, even though spoof definitions collapse forward across tests (and within `.plus`).
 
 
 
@@ -232,10 +232,10 @@ There's plenty more to learn about Risei and how it makes testing easy...
 | Name   | Contents                                                                                                  |
 |--------|-----------------------------------------------------------------------------------------------------------|
 | `on`   | The class under test, as a symbol / name (already imported into the test file)                            |
-| `with` | An array of any arguments to pass to the constructor of the tested class, or an empty array `[ ]` if none |
+| `with` | An array of any arguments to pass to the constructor of the tested class, or an empty array `[]` if none |
 | `of`   | The name of the method under test, as a string, no `()` needed                                            |
 | `for`  | A description of what the test proves, for test output                                                    |
-| `in`   | An array of the input arguments to pass to the tested method, or an empty array `[ ]` if none             |
+| `in`   | An array of the input arguments to pass to the tested method, or an empty array `[]` if none             |
 | `out`  | The expected return value, not in an array                                                                |
 
 - There are additional properties for extended functionality, covered later.
@@ -245,7 +245,7 @@ There's plenty more to learn about Risei and how it makes testing easy...
 
 ### Test-property reuse _AKA_ Collapsing forward
 
-- To save time and effort, any property you write is collapsed forward to subsequent tests unless you replace it or erase it with an empty array `[ ]`.
+- To save time and effort, any property you write is collapsed forward to subsequent tests unless you replace it or erase it with an empty array `[]`.
   - Property values are gathered across partial test objects until they add up to a runnable test, which is then run.
   - Changes to properties are combined with previous ones to produce intended new tests.
     - For a rare and avoidable side-effect of this system, see [known issues and workarounds](#known-issues-and-workarounds).
@@ -254,9 +254,9 @@ There's plenty more to learn about Risei and how it makes testing easy...
   - Changing the tested class in `.on` wipes out all prior test properties, so the new class has a fresh start.
   - Changing the tested method in `.of` wipes out only test properties related to methods, to preserve class values you usually want.
 
-- Individual tests remain isolated, except for when args are mutable.
-  - To use the original, un-mutated args for successive tests, just return them from a function or method to set `.with` or `.in`.
-
+- Individual tests remain isolated, except for when args are mutated by the code under test.
+  - Restate args for each test when the code mutates them.
+  - This limitation is the result of limits on what can be copied reliably in JavaScript.
 
 
 ### Choosing test-only dependency inputs _AKA_ Spoofing
@@ -337,7 +337,7 @@ To test a throw, use an `.and` of `"throw"` or `"throws"`:
 { of: "getTextProfile",
   for: "Throws with a helpful message when there is no arg text.",
   and: "throws",
-  in: [ ],
+  in: [],
   out: "Could not build a profile.  Did you forget to provide a text?"
 }
 ```
@@ -355,7 +355,7 @@ To test a value that isn't the exercised code's return value, you use `.out` nor
 
 
 - Getting properties, mutated args, and other non-return values is known as _retrieving_.
-- Retrieving definitions collapse forward across tests unless replaced with new definitions, or erased by setting `.from` to an empty array `[ ]`.
+- Retrieving definitions collapse forward across tests unless replaced with new definitions, or erased by setting `.from` to an empty array `[]`.
 
 
 <details>
@@ -457,7 +457,7 @@ All test properties have long names that you can use instead of the short ones i
 Constructors can be tested with no special test properties or keywords.
 - The method name in `.of` is simply `"constructor"`.
 - Any `.with` args are completely ignored for a constructor test.&nbsp;  Only those in the test's `.in` property are used.
-  - However, a `.with` must still be provided.&nbsp;  It can simply be an empty array `[ ]`.
+  - However, a `.with` must still be provided.&nbsp;  It can simply be an empty array `[]`.
 
 </details>
 
@@ -514,7 +514,7 @@ You set up the transpiler to output files to a directory with these settings:
 
 ### In test files:
 
-All `import` statements have to point to the `outDir` path or subfolders there, using relative-path syntax:
+All `import` statements have to point to the Javascript (`.js`) files in the `outDir` path or subfolders there, using relative-path syntax:
 
 ```javascript
 import { TestedClass } from "../../dist/out-tsc/SubPath/TestedClass.js";
@@ -524,6 +524,7 @@ import { TestedClass } from "../../dist/out-tsc/SubPath/TestedClass.js";
 
 
 
+
 ## Limitations in Risei
 
 The following are not supported at present:
@@ -544,15 +545,15 @@ Some of these are on the tentative future-development list.&nbsp;  In the meanti
 
 Most problems with using Risei are minor mistakes in syntax, or omissions in test definitions:
 
-| Error condition or text                                             | Probable cause / fix                                                                                                                                                                                                                                                                                                                       |
+| Error condition or text                                             | Probable cause                                                                                                                                                                                                                                                                                                                       |
 |---------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | Gold bar appears below the summary, and the number of tests run drops        | A syntax error caused a test file not to load; error output in the gold bar explains why                                                                                                                                                                                                                                        |
 | `"Test loading failed for...  SyntaxError: Unexpected token ':'"`   | Missing comma in your tests in the named file                                                                                                                                                                                                                                                                                              |
 | `"Test loading failed for...  SyntaxError: Unexpected token '.'"`   | Using `this.tests = []` instead of `tests = []` in the file named                                                                                                                                                                                                                                                                          |
 | Other `... Unexpected token ...` errors                             | Some other syntax error in the file named, most likely a missing or extra delimiter                                                                                                                                                                                                                                                        |
-| Unexpected actual values, or unexpected passes / fails in test runs | Spoofs, retrievals, or special conditions from previous tests not replaced or reset with `[ ]` |
-| Unexpected actual values, or unexpected passes / fails in test runs | Pre-listed test properties have produced extra tests; changing properties as part of new tests prevents this |
-| Unexpected actual values, or unexpected passes / fails in test runs | `.with` or `.in` values were mutated by a test and passed to subsequent tests; providing contents of these properties with a function prevents this |
+| Unexpected extra, failing test/s   | Partial test properties in a mid-list object have produced extra tests |
+| Unexpected actual values, or unexpected passes / fails in test runs | Test properties from previous tests not replaced or reset with `[]` <br>&mdash; or &mdash;<br> Args mutated by tested code were not restated in following tests to isolate them |
+
 
 
 
@@ -560,22 +561,24 @@ Most problems with using Risei are minor mistakes in syntax, or omissions in tes
 
 Two issues are known to exist:
 
-- If the contents of `.with` or `.in` are mutated by the code being tested, the mutated values are carried from test to test.
-  - To use the original, un-mutated args for successive tests, just return them from a function or method, and call it to set `.with` or `.in`.
-  - Ways to prevent this are being looked at.
+- When code mutates its args in test definitions, the mutated forms are used in subsequent tests unless those args are restated.
+  - To avoid this problem, just restate the args in each test of this code.
+  - The workaround for this &mdash; copying and initing objects to bypass mutation &mdash; requires too many assumptions to be reliable.
 
 
-- Changing one or more properties in objects by themselves in the middle of tests (perhaps to emphasize them) can create extra tests.
-  - The extra tests usually fail, because they have an unintended mix of old and new properties.
-  - In this case, Rs is actually working properly, running prior tests with the new properties swapped in.
-  - To avoid this problem, include changed properties in full tests to run, or restate `.of` along with the changed properties.
-  - This situation is rarely an issue, but ways to optionally prevent it are being considered.
+- When a few properties are changed in separate objects, they are treated as whole new tests, which usually fail because of their unintended mix of old and new properties.
+  - To avoid this problem, just change properties as part of whole new tests, or else restate `.of` along with the changed properties.
+  - Rs is actually working as intended when this happens, but ways to optionally prevent it are being considered.
 
 
 
 ## What's new in Risei
 
-- Release **1.3.1** (February, 2024) reverses some changes in 1.3.0 that were intended to fully isolate tests against mutable args, but which caused incomplete or inaccurate object contents in some cases.&nbsp;  Later work may restore full isolation in a different way at some point.
+- Release **1.3.3** (March, 2024) fixes a major bug related to file paths that prevented any tests from loading or running in Windows environments.
+
+- Release **1.3.2** (February, 2024) does not change the code at all, but improves this read-me, notably explaining the easiest way to deal with mutable args (which is just restating the args), and correcting a few mistakes.
+
+- Release **1.3.1** (February, 2024) reverses some changes in 1.3.0 that were intended to fully isolate tests against mutable args, but which caused incomplete or inaccurate object contents in some cases.&nbsp;  This sort of built-in total isolation is not feasible, and in fact is rarely needed.
 
 - Release **1.3.0** (February, 2024) moves the display of test-loading error messages to a new gold bar that appears at the bottom of the summary when there are any loading errors.&nbsp;  A sorting error that occurs when no test files exist yet has also been fixed. 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Risei is the framework that allows you to write unit tests as collections of values in JavaScript objects, so it's easy and fast, and tests don't serve as a drag on redesigns.",
   "keywords": [
     "unit test",
@@ -48,6 +48,6 @@
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "1.3.1"
+    "risei": "1.3.3"
   }
 }

package/system/{SpoofClassMethodsFixture.js → ClassMethodSpoofer.js}

@@ -2,12 +2,13 @@
 
 import { ASpoofingFixture } from "./ASpoofingFixture.js";
 import { SpoofDefinition } from "./SpoofDefinition.js";
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
 
-export class SpoofClassMethodsFixture extends ASpoofingFixture {
+export class ClassMethodSpoofer extends ASpoofingFixture {
     /* Algorithm:  Forward method spoof() looks at spoof definitions in .plus and applies them 
                    to each class' prototypes after first saving the original member definitions.
                    Reverse method unspoof() restores each original member definition.
-                   Fundamentally different from what SpoofObjectMethodsFixture does. */
+                   Fundamentally different from what ObjectMethodSpoofer does. */
 
     // region Private fields
 
@@ -37,7 +38,7 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
     // endregion Properties
 
     constructor() {
-        super("SpoofClassMethodsFixture", "Construction");
+        super("ClassMethodSpoofer", "Construction");
     }
     
     /* Spoofs methods of classes as defined in nonce 
@@ -140,7 +141,7 @@ export class SpoofClassMethodsFixture extends ASpoofingFixture {
         for (let type of types) {
             let spoofsByTarget = this.#spoofsByClass.get(type);
             let names = spoofsByTarget.keys();
-            
+
             // Actually spoofing, one by one.
             for (let name of names) {
                 let spoofSource = spoofsByTarget.get(name);

package/system/ClassPropertySpoofer.js

@@ -0,0 +1,182 @@
+/**/
+
+import { ASpoofingFixture } from "./ASpoofingFixture.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
+
+export class ClassPropertySpoofer extends ASpoofingFixture {
+    /* Algorithm:  Forward method spoof() looks at spoof definitions in .plus and applies them 
+                   to each class' prototypes after first saving the original member definitions.
+                   Reverse method unspoof() restores each original member definition.
+                   Fundamentally different from what ObjectMethodSpoofer does. */
+
+    // region Private fields
+
+    #spoofsByClass = new Map();
+    #originalsByClass = new Map();
+
+    // endregion Private fields
+
+    // region Properties
+
+    get spoofsByClass() {
+        return this.#spoofsByClass;
+    }
+
+    set spoofsByClass(value) {
+        this.#spoofsByClass = value;
+    }
+
+    get originalsByClass() {
+        return this.#originalsByClass;
+    }
+
+    set originalsByClass(value) {
+        this.#originalsByClass = value;
+    }
+
+    // endregion Properties
+
+    constructor() {
+        super("ClassPropertySpoofer", "Construction");
+    }
+    
+    /* Spoofs methods of classes as defined in nonce 
+       spoof-tuple definitions in any test.plus. */
+    spoof(test) {
+        // Localizing.
+        let type = test.on;
+        let spoofNonces = test.plus;
+        
+        // Spoofing definitions are always in an array.
+        if (!Array.isArray(spoofNonces)) {
+            return;
+        }
+    
+        // Converting to scope object type.
+        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
+        
+        // Storing spoofing definitions.
+        this.#retainSpoofsByClass(type, spoofDefinitions);
+        
+        // Storing originals for restoring later.
+        this.#reserveOriginalsByClass();
+        
+        // Actually spoofing.
+        this.#spoofMembersByClass();
+    }
+
+    // region Dependencies of spoof()
+
+    #retainSpoofsByClass(type, spoofDefinitions) {
+        // Map of Maps: by type, then by method.
+        for (let tuple of spoofDefinitions) {
+            // If no .target, use `type`. 
+            if (!tuple.target) {
+                tuple.target = type;
+            }
+            
+            let spoofsByTarget = this.#supplyMemberMap(this.#spoofsByClass, tuple.target);
+            
+            // A single-method spoof is set for later use.
+            if (tuple.method) {
+                spoofsByTarget.set(tuple.method, tuple.output);
+                continue;
+            }
+            
+            // Two or more method spoofs are set for later use.
+            if (tuple.output) {
+                let ofAsPairs = tuple.output;
+                
+                for (let pair of ofAsPairs) {
+                    spoofsByTarget.set(pair.of, pair.as);
+                }
+                
+                continue;
+            }
+        }
+    }
+    
+    #reserveOriginalsByClass() {
+        /* Any spoofing of multiple methods on each class has already been 
+           split up into Map elements, so this code can use those naively. */
+    
+        let types = this.#spoofsByClass.keys();
+        
+        // For each class.
+        for (let type of types) {
+            let originalsByTarget = this.#supplyMemberMap(this.#originalsByClass, type);
+            
+            let spoofsByTarget = this.#spoofsByClass.get(type);
+            let names = spoofsByTarget.keys();
+            
+            // Saving originals in the Map for later.
+            for (let name of names) {
+                let original = type.prototype[name];
+                originalsByTarget.set(name, original);
+            }
+        }
+    }
+
+    /* Dependency of #retainSpoofsByClass() 
+       and #reserveOriginalsByClass(). */
+    #supplyMemberMap(source, target) {
+        let mapForType = source.get(target);
+        
+        if (!mapForType) {
+            mapForType = new Map();
+            source.set(target, mapForType);
+        }
+        
+        return mapForType;
+    }
+
+    #spoofMembersByClass() {
+        /* Any spoofing of multiple methods on each class has already been 
+           split up into Map elements, so this code can use those naively. */
+
+        let types = this.#spoofsByClass.keys();
+    
+        // For each class.
+        for (let type of types) {
+            let spoofsByTarget = this.#spoofsByClass.get(type);
+            let names = spoofsByTarget.keys();
+
+            // Actually spoofing, one by one.
+            for (let name of names) {
+                let spoofSource = spoofsByTarget.get(name);
+                let spoof = super.spoofMethod(spoofSource);
+                type.prototype[name] = spoof;
+            }
+        }
+    }
+
+    // endregion Dependencies of spoof()
+
+    // Spoofed methods on any targeted classes 
+    // are restored to their original forms.
+    unspoof() {
+        let types = this.#originalsByClass.keys();
+        
+        // For each class.
+        for (let target of types) {
+            let prototype = target.prototype;
+            
+            let originalsByTarget = this.#originalsByClass.get(target);
+            let names = originalsByTarget.keys();
+            
+            // Actually restoring, one by one.
+            for (let name of names) {
+                let original = originalsByTarget.get(name);
+                target.prototype[name] = original;
+            }
+        }
+    }
+
+    // Removes definitions, useful if this instance is reused, 
+    // or else they might be applied when they shouldn't be.
+    removeDefinitions() {
+        this.#spoofsByClass.clear();
+        this.#originalsByClass.clear();
+    }
+}

package/system/{SpoofObjectMethodsFixture.js → ObjectMethodSpoofer.js}

@@ -3,14 +3,14 @@
 import { ASpoofingFixture } from "./ASpoofingFixture.js";
 import { SpoofDefinition } from "./SpoofDefinition.js";
 
-export class SpoofObjectMethodsFixture extends ASpoofingFixture {
+export class ObjectMethodSpoofer extends ASpoofingFixture {
     /* Algorithm:  Forward method spoof() looks at a test's .with and .in, and replaces entire objects 
                    in each with spoofed object trees, if the originals are spoof definitions.
                    No reverse unspoofing method is needed, since objects are nonces tossed after tests.
-                   Fundamentally different from much of what SpoofClassMethodsFixture does. */
+                   Fundamentally different from much of what ClassMethodSpoofer does. */
 
     constructor() {
-        super("SpoofObjectMethodsFixture", "Construction");
+        super("ObjectMethodSpoofer", "Construction");
     }
     
     /* Spoofs methods of any objects in test.with and test.in 

package/system/ObjectPropertySpoofer.js

@@ -0,0 +1,136 @@
+/**/
+
+import { ASpoofingFixture } from "./ASpoofingFixture.js";
+import { SpoofDefinition } from "./SpoofDefinition.js";
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
+
+export class ObjectPropertySpoofer extends ASpoofingFixture {
+    /* Algorithm:  Forward method spoof() looks at property spoof definitions in .plus 
+                   and first saves the original values, then applies the spoofed ones.
+                   Reverse method unspoof() restores each original property value.
+                   Fundamentally different from what ObjectMethodSpoofer does. */
+
+    // region Private fields
+
+    // Spoofed and original property values.
+    #settables = [ ];
+    #unsettables = [ ];
+
+    // endregion Private fields
+
+    // region Properties
+
+    get settables() {
+        return this.#settables;
+    }
+
+    set settables(value) {
+        this.#settables = value;
+    }
+
+    get unsettables() {
+        return this.#unsettables;
+    }
+
+    set unsettables(value) {
+        this.#unsettables = value;
+    }
+
+    // endregion Properties
+
+    constructor() {
+        super("ObjectPropertySpoofer", "Construction");
+    }
+    
+    /* Spoofs properties of test.target as defined in any test.plus. */
+    spoof(test) {
+        // Localizing.
+        let target = test.target;
+        let spoofNonces = test.plus;
+
+        // Spoofing definitions are always in an array.
+        if (!Array.isArray(spoofNonces)) {
+            return;
+        }
+    
+        // Converting to scope object type.
+        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
+
+        // Working only with property spoofs.
+        let propertySpoofs = Array.from(spoofDefinitions)
+            .filter(x => TypeAnalyzer.memberIsProperty(test.on, x.on));
+
+        // Storing new values for setting.
+        this.#settables = propertySpoofs;
+
+        // Storing original values for restoring later.
+        this.#unsettables = this.#anyOriginalPropertyGetting(target, this.#settables);
+
+        // Actually spoofing with new values.
+        this.#anyPropertySetting(target, this.#settables);
+    }
+
+    // Spoofed methods on any targeted classes 
+    // are restored to their original forms.
+    unspoof() {
+        this.#anyPropertyUnsetting(this.target, this.#unsettables);
+    }
+
+    // region Dependencies of spoof()
+
+    #anyOriginalPropertyGetting(target, settables) {
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        let unsettables = [ ];
+        
+        for (let settable of settables) {
+            // Not a setter tuple if no settable value.
+            if (settable.of === undefined) {
+                continue;
+            }
+            
+            // Retaining original.
+            let original = target[settable.of];
+            let unsettable = { of: settable.of, as: original };
+
+            unsettables.push(unsettable);
+        }
+        
+        return unsettables;
+    }
+
+    // endregion Dependencies of spoof()
+    
+    // region Dependencies of unspoof()
+
+    #anyPropertyUnsetting(target, unsettables) {
+        // Unsetting is the same as setting, 
+        // but with tuples of original values.
+        return this.#anyPropertySetting(target, unsettables);
+    }
+
+    // endregion Dependencies of unspoof()
+
+    // region Dependencies of both spoof() and unspoof()
+
+    #anyPropertySetting(target, settables) {
+        // No properties to set.
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        for (let settable of settables) {
+            // Not a setter tuple if no settable value.
+            if (settable.of === undefined) {
+                continue;
+            }
+
+            // Actually setting property.
+            target[settable.of] = settable.as;
+        }
+    }
+
+    // endregion Dependencies of both spoof() and unspoof()
+}

package/system/SpoofDefinition.js

@@ -20,12 +20,6 @@ export class SpoofDefinition {
 
     // endregion Static fields
 
-    // region Private fields
-    
-    #typeAnalyzer;
-    
-    // endregion Private fields
-
     // region Public fields (long names)
 
     /* These long names are clearer and match the constructor's parameter names. */
@@ -86,7 +80,7 @@ export class SpoofDefinition {
     }
     
     isPropertySpoof() /* passed */ {
-        return this.#typeAnalyzer.memberIsProperty(this.method);
+        return TypeAnalyzer.memberIsProperty(this.target, this.method);
     }
 
     // endregion Tuple state
@@ -101,8 +95,6 @@ export class SpoofDefinition {
         this.target = target;
         this.method = method;
         this.output = output;
-        
-        this.#typeAnalyzer = new TypeAnalyzer(target);
     }
 
     static fromNonceTuples(nonces) {

package/system/TestDefinition.js

@@ -42,12 +42,6 @@ export class TestDefinition {
 
     // endregion Static fields
 
-    // region Private fields
-
-    #typeAnalyzer;
-
-    // endregion Private fields
-
     // region Fields
 
     /* These longer names match the constructor-arg names. 
@@ -64,8 +58,8 @@ export class TestDefinition {
     source;
     factors;
 
-    localTarget;
-    localMethod;
+    target;
+    localCallable;
     
     actual;
     thrown;
@@ -118,7 +112,7 @@ export class TestDefinition {
         this.spoofed = value;
     }
     
-    /* &cruft, rename this .amid property pair */
+    /* &cruft, drop or rename this .amid property pair */
     get amid() { 
         return this.settables; 
     }
@@ -180,8 +174,12 @@ export class TestDefinition {
     }
 
     get isStaticTest() /* passed */ {
-        let does = this.andStringContains(TestDefinition.staticName);
-        return does;
+        let plainName = TestDefinition.plainNameOf(this.of);
+
+        let is = TypeAnalyzer.memberIsStatic(this.on, plainName);
+        let stated = this.andStringContains(TestDefinition.staticName);
+
+        return is || stated;
     }
     
     get isThrowTest() /* passed */ {
@@ -214,7 +212,7 @@ export class TestDefinition {
         let isPropertyTest 
             = this.of.startsWith(TestDefinition.dotOperator) 
             || this.of.endsWith(TestDefinition.colonOperator) 
-            || this.#typeAnalyzer.memberIsProperty(plainName);
+            || TypeAnalyzer.memberIsProperty(this.on, plainName);
         
         return isPropertyTest;
     }
@@ -258,8 +256,6 @@ export class TestDefinition {
         this.output = output;        // .out 
         this.source = source;        // .from 
         this.factors = factors;      // .and 
-
-        this.#typeAnalyzer = new TypeAnalyzer(this.type);
     }
 
     copy() {
@@ -296,8 +292,7 @@ export class TestDefinition {
             // combining with next time.
             full = latest;
 
-            // Add (copy of) latest (for isolation), 
-            // only if it's ready to run as a test.
+            // Add latest, if it's ready to run as a test.
             if (latest.isRunnable) {
                 tuples.push(latest);
             }
@@ -350,6 +345,7 @@ export class TestDefinition {
     combineWith(other) {
         let shortNames = TestDefinition.longsByShort.keys();
 
+        // Collapse properties forward.
         for (let shortName of shortNames) {
             TestDefinition.combineValues(this, other, shortName);
         }

package/system/TestFinder.js

@@ -137,7 +137,9 @@ export class TestFinder extends ATestFinder {
         
         // Loading modules should load their dependencies.
         try {
-            let module = await import(classPath);
+            // Pseudo-protocol needed for non-POSIX OSes.
+            let asFileUrl = `file:///${ classPath }`;
+            let module = await import(asFileUrl);
             
             // A module may have many contents.
             for (let moduleKey in module) {

package/system/TestFrame.js

@@ -3,7 +3,7 @@
 import { TestStages } from "./TestStages.js";
 
 export class TestFrame {
-    /* &cruft : when TestStages is ready, use it and its methods here */
+    /* &cruft, when TestStages is ready, use it and its methods here */
     
     #stages;
 
@@ -13,84 +13,83 @@ export class TestFrame {
     }
     
     testFrame(test) {
-        console.log(`cruft : a`);
+        /* &cruft, removing logging after it's no longer needed */
+        // console.log(`cruft : a`);
 
         // Outer try for fails of groundwork requested.
         try {
-            console.log(`cruft : b`);
+            // console.log(`cruft : b`);
 
             // Spoofing, setting static properties, and so on.
             this.#stages.anyPreTargetingGroundwork(test);
             
-            console.log(`cruft : c`);
+            // 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);
+            this.#stages.setTarget(test);
             
-            console.log(`cruft : d`);
+            // 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 : e`);
+            // console.log(`cruft : e`);
             
             // Setting instance properties and so on.
             this.#stages.anyPostTargetingGroundwork(test);
             
-            
-            console.log(`cruft : f`);
+            // console.log(`cruft : f`);
             
             // Inner try for fails of targeted code only.
             try {
-                console.log(`cruft : g`);
+                // 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.in:`, test.in);
+                // console.log(`cruft : test.actual:`, test.actual);
+                // console.log(`cruft : test.target:`, test.target);
+                // console.log(`cruft : test.localCallable:`, test.localCallable);
+                // console.log(`cruft : test.in:`, test.in);
             
                 // Tests usually look for this.
-                test.actual = test.localTarget[test.localCallable](...test.in);
+                test.actual = test.target[test.localCallable](...test.in);
                 
-                console.log(`cruft : test.actual:`, test.actual);
-                console.log(`cruft : h`);
+                // console.log(`cruft : test.actual:`, test.actual);
+                // console.log(`cruft : h`);
             }
             catch (thrown) {
-                console.log(`cruft : i`);
+                // console.log(`cruft : i`);
                 
                 // Sometimes tests look for this.
                 test.thrown = thrown;
                 
-                console.log(`cruft : j`);
+                // console.log(`cruft : j`);
             }
 
-            console.log(`cruft : k`);
+            // console.log(`cruft : k`);
 
             // Sometimes tests look for results elsewhere. 
             this.#stages.anyModifyActual(test);
 
-            console.log(`cruft : l`);
-
-            /* &cruft, remove test-checking line when all tests pass */
-            // test.didPass = "fails";
+            // console.log(`cruft : l`);
 
             // Actually testing the result.
             test.didPass = this.#stages.compareResults(test.output, test.actual);
             
-            console.log(`cruft : m`);
-            
+            /* &cruft, remove this test-checking line when all tests pass */
+            // test.didPass = !test.didPass;
+
+            // console.log(`cruft : m`);
         }
         finally {
-            console.log(`cruft : n`);
+            // console.log(`cruft : n`);
         
             // Undoing any groundwork changes made. 
             this.#stages.anyGroundworkReversion(test);
             
-            console.log(`cruft : o`);
+            // console.log(`cruft : o`);
         }
         
-        console.log(`cruft : p`);
+        // console.log(`cruft : p`);
     }
 }

package/system/TestFrames.js

@@ -4,12 +4,12 @@ import { AComparer } from "./AComparer.js";
 import { TotalComparer } from "./TotalComparer.js";
 
 export class TestFrames {
-    /* &cruft : refactor to merge with same on TestFrameChooser */
+    /* &cruft, refactor to merge with same on TestFrameChooser */
     // Used for special test cases.
     constructorName = "constructor";
     staticName = "static";
 
-    /* &cruft : probably refactor comparing usage */
+    /* &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. */
 
@@ -215,7 +215,7 @@ export class TestFrames {
         return test.from;
     }
     
-    /* &cruft : refactor to merge with same on TestFrameChooser */
+    /* &cruft, refactor to merge with same on TestFrameChooser */
     #doesAddressStatics(test) {
         if (typeof test.and === "string") {
             if (test.and.includes(this.staticName)) {

package/system/TestRunner.js

@@ -12,8 +12,8 @@ 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 { ClassMethodSpoofer } from "./ClassMethodSpoofer.js";
+import { ObjectMethodSpoofer } from "./ObjectMethodSpoofer.js";
 import { SpoofDefinition } from "./SpoofDefinition.js";
 
 export class TestRunner {
@@ -112,8 +112,8 @@ export class TestRunner {
 
     constructor() {
         this.#tests = [];
-        this.#classSpoofer = new SpoofClassMethodsFixture();
-        this.#instanceSpoofer = new SpoofObjectMethodsFixture();
+        this.#classSpoofer = new ClassMethodSpoofer();
+        this.#instanceSpoofer = new ObjectMethodSpoofer();
         
         this.#frameSource = new TestFrames();
         this.#frameChooser = new TestFrameChooser(this.#frameSource);

package/system/TestStages.js

@@ -19,28 +19,28 @@ export class TestStages {
         // Setting any static properties here.
     }
     
-    setLocalTarget(test) /* passed */ {
+    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.localTarget = test.on.prototype;
+            test.target = test.on.prototype;
             return;
         }
 
         let callable = TestDefinition.plainNameOf(test.of);
-        
+
         let target = test.isInstanceTest 
-            ? this.#supplyInstanceLocalTarget(test, callable) 
-            : this.#supplyStaticLocalTarget(test, callable);
+            ? this.#supplyInstanceTarget(test, callable) 
+            : this.#supplyStaticTarget(test, callable);
 
-        test.localTarget = target;
+        test.target = target;
     }
     
-    // region Dependencies of setLocalTarget()
+    // region Dependencies of setTarget()
     
-    #supplyStaticLocalTarget(test, callable) /* verified */ {
+    #supplyStaticTarget(test, callable) /* verified */ {
         let type = test.on;
         
         // Methods are called on class directly.  
@@ -52,7 +52,7 @@ export class TestStages {
         return target;
     }
 
-    #supplyInstanceLocalTarget(test, callable) /* verified */ {
+    #supplyInstanceTarget(test, callable) /* verified */ {
         let instance = new test.on.prototype.constructor(...test.with);
         
         // Methods are called on instance directly.  
@@ -64,7 +64,7 @@ export class TestStages {
         return target; 
     }
     
-    // endregion Dependencies of setLocalTarget()
+    // endregion Dependencies of setTarget()
 
     setLocalCallable(test) /* passed */ {
         /* Method under test is a method named in test, 
@@ -103,7 +103,6 @@ export class TestStages {
         // Undoing any other groundwork changes made.
     }
 
-
     // region Dependencies of test stages
 
     #anyOriginalPropertyGetting(target, settables) {
@@ -159,7 +158,7 @@ export class TestStages {
         // 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, 
+            /* &cruft, maybe explain how this differs from setting .target, 
                        which can be a nonce, or else maybe make them the same */
 
             // Common member host; 
@@ -180,7 +179,7 @@ export class TestStages {
         // 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);
+            return test.from(test.actual, test.target);
         }
 
         /* &cruft, probably drop this, change maybe to a throw */
@@ -191,80 +190,4 @@ export class TestStages {
     
     // 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/system/TypeAnalyzer.js

@@ -11,32 +11,51 @@ export class TypeAnalyzer {
 
     // endregion Definitions
 
-    // region Fields
+    /* Returns true if member is static (value or accessor 
+       property, or method).  Returns false otherwise. */
+    static memberIsStatic(type, name) /* passed */ {
+        // Constructor of class type, available with `in`, 
+        // is not the constructor normally being sought, 
+        // which instead is treated as instance-hosted.
+        if (name === TypeAnalyzer.constructorName) {
+            return false;
+        }
 
-    #type;
+        // All static methods and properties 
+        // (value or accessor, in this class 
+        // or a superclass) are `in` type.
+        if (name in type) {
+            return true;
+        }
 
-    // endregion Fields
+        // Anything else is an instance member, 
+        // present in this class or inherited.
+        return false;
+    }
 
-    constructor(type) {
-        this.#type = type;
+    /* Returns true if instance or static member is a method.
+       Returns false if member is any kind of property. */
+    static memberIsMethod(type, name) /* passed */ {
+        return !TypeAnalyzer.memberIsProperty(type, name);
     }
 
-    /* Returns true if instance or static member is a property (value or accessor).  Returns false if member is a method. */
-    memberIsProperty(name) /* passed */ {
+    /* Returns true if instance or static member is a property 
+       (value or accessor).  Returns false if member is a method. */
+    static memberIsProperty(type, name) /* passed */ {
         // Constructor is never a property and is irregular, 
         // so other type-analysis code can't handle it.
         if (name === TypeAnalyzer.constructorName) {
             return false;
         }
-    
+
         // Static methods and properties (value or accessor) are on type.
-        if (name in this.#type) {
-            return this.#staticMemberIsProperty(this.#type, name);
+        if (name in type) {
+            return TypeAnalyzer.#staticMemberIsProperty(type, name);
         }
         
         // Methods and accessor properties are on prototype.
-        if (name in this.#type.prototype) {
-            return this.#instanceMemberIsProperty(this.#type.prototype, name);
+        if (name in type.prototype) {
+            return TypeAnalyzer.#instanceMemberIsProperty(type.prototype, name);
         }
 
         // Instance value properties are not on type or prototype.
@@ -46,16 +65,16 @@ export class TypeAnalyzer {
     // region Dependencies of memberIsProperty()
     
     /* Algorithm specialized with function check for static members. */
-    #staticMemberIsProperty(type, name) {
+    static #staticMemberIsProperty(type, name) {
         let descriptor = Object.getOwnPropertyDescriptor(type, name);
         
         // If on type and has accessors, it's a static accessor property.
-        if (this.#doesHaveAccessorProps(descriptor)) {
+        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
             return true;
         }
         
         // If on type and has non-Function .value, it's a static value property.
-        if (this.#doesNotHaveFunctionValue(descriptor)) {
+        if (TypeAnalyzer.#doesNotHaveFunctionValue(descriptor)) {
             return true;
         }
 
@@ -64,11 +83,11 @@ export class TypeAnalyzer {
     }
 
     /* Algorithm specialized for instance members, no function check. */
-    #instanceMemberIsProperty(prototype, name) {
+    static #instanceMemberIsProperty(prototype, name) {
         let descriptor = Object.getOwnPropertyDescriptor(prototype, name);
         
         // If on prototype and has accessors, it's an accessor property.
-        if (this.#doesHaveAccessorProps(descriptor)) {
+        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
             return true;
         }
         
@@ -78,7 +97,7 @@ export class TypeAnalyzer {
     
     // region Internally reused dependencies of other memberIsProperty() dependencies
     
-    #doesHaveAccessorProps(descriptor) /* verified */ {
+    static #doesHaveAccessorProps(descriptor) /* verified */ {
         // Accessor properties have one or both of these in descriptor.
         if (TypeAnalyzer.getName in descriptor || TypeAnalyzer.setName in descriptor) {
             return true;
@@ -87,12 +106,12 @@ export class TypeAnalyzer {
         return false;
     }
     
-    #doesNotHaveFunctionValue(descriptor) /* verified */ {
+    static #doesNotHaveFunctionValue(descriptor) /* verified */ {
         // Simple inverter of other method for readability.
-        return !this.#doesHaveFunctionValue(descriptor);
+        return !TypeAnalyzer.#doesHaveFunctionValue(descriptor);
     }
     
-    #doesHaveFunctionValue(descriptor) /* verified */ {
+    static #doesHaveFunctionValue(descriptor) /* verified */ {
         // If no member, .value of undefined.
         return descriptor.value instanceof Function;
     }