risei 2.0.1 → 3.0.0

package/README.md

@@ -46,7 +46,7 @@ And they have a summary bar at the bottom:
 
 ## Status
 
-Risei is under active development and new enhancements appear often.   The latest release, **2.0.1**, brings many major improvements, including broader capabilities and simpler syntax, and a few minor breaking changes.
+Risei is under active development and new enhancements appear often.   The latest release, **3.0.0**, brings major improvements, starting with the ability to test `async` code, and builds on many major improvements in **2.0.0**, including broader capabilities and simpler syntax, and a few minor breaking changes.
 
 Check out the [full list of changes](#version-history).
 
@@ -58,11 +58,13 @@ Check out the [full list of changes](#version-history).
 - #### Easy-to-read test definitions and test outputs.    ►  [Test and output examples](https://deusware.com/risei/index.html#examples)   (also above)
 - #### Even less to write by stating reused test properties only once.      ►   [Collapsing forward](https://deusware.com/risei/index.html#collapsing-forward)   (basics below)
 - #### Built-in declarative syntax to fake test-time values from dependencies.      ►   [Spoofing using `.plus`](https://deusware.com/risei/index.html#spoofing)   (basics below)
-- #### Testing properties, methods, static and instance members all the same way.      ►   [Properties and statics](https://deusware.com/risei/index.html#testing-properties-and-static-methods)
+- #### Full support for `async` code with no special syntax needed.      ►   [Writing tests](https://deusware.com/risei/index.html#writing-tests)   (basics below)
+- #### Testing properties and methods, static and instance members all the same way.      ►   [Properties and statics](https://deusware.com/risei/index.html#testing-properties-and-static-methods)
 - #### Testing `throw` paths effortlessly.      ►   [Using `.and: "throws"`](https://deusware.com/risei/index.html#using-and-throws)
 - #### Deriving actual values to test from raw outputs or property retrieval.      ►   [Using `.from`](https://deusware.com/risei/index.html#using-from)
 - #### Setting up and tearing down arbitrary test state.      ►   [Using `.do` and `.undo`](https://deusware.com/risei/index.html#using-do-and-undo)
 - #### Testing for `undefined` as output.      ►   [Using `this.undef`](https://deusware.com/risei/index.html#using-undef)
+- #### Running a method repeatedly in one test.      ►   [Using `.and: "poly"`](https://deusware.com/risei/index.html#using-and-poly)
 
 - And more!   Check out the full [Risei home page](https://deusware.com/risei).
 
@@ -140,11 +142,11 @@ tests = [ ...
 ... ];
 ```
 
+- Asynchronous code with `async` and `await` keywords can tested with no changes at all to this syntax.
 - Use empty arrays for `.in` or `.with` when there are no args to pass.
 - You can use [long names](https://deusware.com/risei/index.html#long-names) for properties if you want.
 
 
-
 ## Basic collapsing forward example
 
 You can state test properties once and let them _collapse forward_ across subsequent tests to save time and make tests easier to read.
@@ -187,6 +189,7 @@ The most basic spoofing looks like this:
 }
 ```
 
+- It's just like _fakes_, _mocks_, or _test doubles_ in other test systems, but easier to write and read.
 - Numerous additional capabilities, as well as compressed syntax, can be mixed freely in many ways.
 - Learn more [here](https://deusware.com/risei/index.html#spoofing).
 
@@ -209,9 +212,22 @@ If problems cause test files not to load, a gold bar appears and tests in those
 - Those and other problems can be solved with the help of this [troubleshooting guide](https://deusware.com/risei/index.html#troubleshooting).
 
 
+
 ## Version history
 
-- Release **2.0.1** (August, 2024) contains all of these changes:
+- Release **3.0.0** (August, 2024) contains all of these changes:
+  - Asynchronous code with `async` syntax is now fully supported, with no special test syntax required.
+  - **(Breaking change)**   `.from` functions now take `test` and `actual` as parameters, rather than `target` and `test`.
+    - If you need to work with the target of the test (usually an instance of the class being tested), it's available as `test.target`.
+  - You can now call target code more than once in one test using an `.and` of `"poly"` (AKA _poly-calling_).
+
+
+<details>
+<summary>
+Older releases
+</summary>
+
+- Release **2.0.1** (August, 2024) contained all of these changes:
   - Risei now can determine automatically if tested methods are static.
   - You can now directly test properties just like methods.
     - Risei can also determine automatically if these are static.
@@ -221,20 +237,13 @@ If problems cause test files not to load, a gold bar appears and tests in those
   - You can now change test properties without accidentally creating a new test using `.just`.
   - You can now directly test for `undefined` in `.out` using `this.undef` / `ATestSource.undefSymbol`.
   - `Error` objects are now compared accurately.
-  - You can now identify member types with `.`, `:`, and `()` in `.of`, `.plus`, and `.from`, though they aren't necessary.
+  - You can now identify member types with `.`, `:`, and `()` in any of `.of`, `.plus`, and `.from`, though it isn't necessary.
   - **(Breaking change)**&nbsp;  The actual for throw tests is now the entire thrown object (usually an `Error`), rather than the `Error`'s message text.
   - **(Breaking change)**&nbsp;  `ATestSource` is now a default export, changing its imports from `import { ATestSource } from` to `import ATestSource from`.
+  - Major internal re-engineering.
 
-> Risei has been massively re-engineered internally along with these improvements.
+- Release **2.0.0** (August, 2024) was identical to 2.0.1 except for some unneeded extra files.
 
-
-
-<details>
-<summary>
-Older releases
-</summary>
-
-- Release **2.0.0** (August, 2024) is identical to 2.0.1 except for some unneeded extra files.
 - Release **1.3.4** (March, 2024) fixed a bug that caused class display problems in some cases.
 - Release **1.3.3** (March, 2024) fixed a major bug that prevented tests from running in Windows.
 - Release **1.3.2** (February, 2024) only improved this read-me's contents.
@@ -248,6 +257,7 @@ Older releases
 </details>
 
 
+
 ## Known issues and workarounds
 
 The only issue at present is reuse of method args mutated by tested code when collapsing forward. 
@@ -255,9 +265,10 @@ The only issue at present is reuse of method args mutated by tested code when co
 - The workaround is just to restate those args for each test.
 
 
+
 ## Exclusions from Risei
 
-At present, there are a few things Risei doesn't support, such as `async` syntax.&nbsp;  Some of these may be supported in the future.
+At present, there are a few things Risei doesn't support.&nbsp;  Some of these may be supported in the future.
 
 - You can see the whole list [here](https://deusware.com/risei/index.html#exclusions-from-risei).
 - You can save a lot of time by using Risei for most of your code, and another framework for whatever it doesn't support.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "risei",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Risei allows you to write unit tests as simple JavaScript objects, so it's easy and fast, with no drag on redesign.",
   "keywords": [
     "unit test",
@@ -50,6 +50,6 @@
     "fs": "^0.0.1-security",
     "mocha": "^10.0.0",
     "morgan": "~1.9.1",
-    "risei": "^1.3.4"
+    "risei": "^3.0.0"
   }
 }

package/system/ATestReporter.js

@@ -1,26 +1,26 @@
-/**/
-
-/* Defines operations that a test reporter must implement.  A = abstract. */
-
-/* &cruft, ? replace with my own code eventually */
-import chalk from "chalk";
-
-export default class ATestReporter {
-    // Reports whatever was just provided by the TestRunner.
-    // Can delegate to the other report-x methods.
-    reportNext(result) {
-    }
-
-    reportGroup() {
-    }
-
-    reportPassed(result) {
-    }
-
-    reportFailed(result) {
-    }
-
-    reportSummary(summary) {
-    }
-
-}
+/**/
+
+/* Defines operations that a test reporter must implement.  A = abstract. */
+
+/* &cruft, ? replace with my own code eventually */
+import chalk from "chalk";
+
+export default class ATestReporter {
+    // Reports whatever was just provided by the TestRunner.
+    // Can delegate to the other report-x methods.
+    reportNext(result) {
+    }
+
+    reportGroup() {
+    }
+
+    reportPassed(result) {
+    }
+
+    reportFailed(result) {
+    }
+
+    reportSummary(summary) {
+    }
+
+}

package/system/ClassTestGroup.js

@@ -1,8 +1,8 @@
-/**/
-
-import TestGroup from "./TestGroup.js";
-
-/* Identifies a grouping of tests by class.  No specialized workings. */
-
-export default class ClassTestGroup extends TestGroup {
-}
+/**/
+
+import TestGroup from "./TestGroup.js";
+
+/* Identifies a grouping of tests by class.  No specialized workings. */
+
+export default class ClassTestGroup extends TestGroup {
+}

package/system/LocalCaller.js

@@ -11,11 +11,11 @@ import TestRunner from "./TestRunner.js";
 export default class LocalCaller extends ATestCaller {
     async runAllTests() {
         let tests = await this.finder.findAllTests();
-        this.runner.useTests(tests); 
+        this.runner.useTests(tests);
 
         // Getting each run test / summary result 
         // and having it reported in the terminal.
-        for (let result of this.runner) {
+        for await (let result of this.runner.runTests()) {
             this.reporter.reportNext(result);
         }
     }

package/system/MethodSpoofer.js

@@ -39,7 +39,7 @@ export default class MethodSpoofer extends ASpoofingFixture {
     // endregion Properties
 
     constructor() {
-        super("MethodSpoofer", "Construction");
+        super();
     }
     
     // Spoofs methods of classes as defined in nonce 
@@ -53,7 +53,7 @@ export default class MethodSpoofer extends ASpoofingFixture {
         if (!Array.isArray(spoofNonces)) {
             return;
         }
-
+        
         // Converting to scope object type.
         let spoofDefs = SpoofDef.fromNonceTuples(spoofNonces, type);
 

package/system/MethodTestGroup.js

@@ -1,8 +1,8 @@
-/**/
-
-import TestGroup from "./TestGroup.js";
-
-/* Identifies a grouping of tests by method.  No specialized workings. */
-
-export default class MethodTestGroup extends TestGroup {
-}
+/**/
+
+import TestGroup from "./TestGroup.js";
+
+/* Identifies a grouping of tests by method.  No specialized workings. */
+
+export default class MethodTestGroup extends TestGroup {
+}

package/system/Moment.js

@@ -1,29 +1,29 @@
-/**/
-
-export default class Moment {
-    #now;
-
-    constructor(now) {
-        this.#now = now;
-    }
-
-    asReadable() /* passed */ {
-        let now = this.#now;
-        let asTwo = this.#asTwo;
-    
-        let day = `${ now.getMonth() + 1 }/${ asTwo(now.getDate()) }/${ now.getFullYear() }`;
-
-        let time = `${ now.getHours() % 12 || 12 }:${ asTwo(now.getMinutes()) }:${ asTwo(now.getSeconds()) } `
-            + `${ now.getHours() < 12 ? "AM" : "PM" }`;
-
-        return `${ day } at ${ time }`;
-    }
-
-    #asTwo(number) /* verified */ {
-        let text = `${ number }`;
-        text = text.padStart(2, "0");
-
-        return text;
-    }
-
-}
+/**/
+
+export default class Moment {
+    #now;
+
+    constructor(now) {
+        this.#now = now;
+    }
+
+    asReadable() /* passed */ {
+        let now = this.#now;
+        let asTwo = this.#asTwo;
+    
+        let day = `${ now.getMonth() + 1 }/${ asTwo(now.getDate()) }/${ now.getFullYear() }`;
+
+        let time = `${ now.getHours() % 12 || 12 }:${ asTwo(now.getMinutes()) }:${ asTwo(now.getSeconds()) } `
+            + `${ now.getHours() < 12 ? "AM" : "PM" }`;
+
+        return `${ day } at ${ time }`;
+    }
+
+    #asTwo(number) /* verified */ {
+        let text = `${ number }`;
+        text = text.padStart(2, "0");
+
+        return text;
+    }
+
+}

package/system/NameAnalyzer.js

@@ -1,26 +1,26 @@
-/**/
-
-export default class NameAnalyzer {
-    // region Definitions
-
-    static dotOperator = ".";
-    static colonOperator = ":";
-    static parensOperator = "()";
-    static operatorsRegExp = /\.|:|\(\)/g;
-
-    // endregion Definitions
-
-    static hasPropertySigil(name) /* passed */ {
-        return name.startsWith(NameAnalyzer.dotOperator) || name.endsWith(NameAnalyzer.colonOperator);
-    }
-
-    static hasMethodSigil(name) /* passed */ {
-        return name.endsWith(NameAnalyzer.parensOperator);
-    }
-
-    static plainNameOf(name) /* passed */ {
-        let plain = name.replaceAll(NameAnalyzer.operatorsRegExp, "");
-        return plain;
-    }
-}
-
+/**/
+
+export default class NameAnalyzer {
+    // region Definitions
+
+    static dotOperator = ".";
+    static colonOperator = ":";
+    static parensOperator = "()";
+    static operatorsRegExp = /\.|:|\(\)/g;
+
+    // endregion Definitions
+
+    static hasPropertySigil(name) /* passed */ {
+        return name.startsWith(NameAnalyzer.dotOperator) || name.endsWith(NameAnalyzer.colonOperator);
+    }
+
+    static hasMethodSigil(name) /* passed */ {
+        return name.endsWith(NameAnalyzer.parensOperator);
+    }
+
+    static plainNameOf(name) /* passed */ {
+        let plain = name.replaceAll(NameAnalyzer.operatorsRegExp, "");
+        return plain;
+    }
+}
+

package/system/PropertySpoofer.js

@@ -52,7 +52,7 @@ export default class PropertySpoofer extends ASpoofingFixture {
     // endregion Properties
 
     constructor() {
-        super("PropertySpoofer", "Construction");
+        super();
     }
     
     /* Spoofs properties of test.target as defined in any test.plus. */

package/system/SpoofDef.js

@@ -20,11 +20,6 @@ export default class SpoofDef {
         SpoofDef.#asNames
     ]);
     
-    /* &cruft, remove these after spoofing in .with and .in is removed */
-    /* Objects with either of these property names aren't 
-       converted to spoofDefs by from-nonce methods. */
-    static skipNames = [ "not", "skip" ];
-
     // endregion Static fields
 
     // region Public fields (long names)

package/system/TestDef.js

@@ -13,6 +13,7 @@ export default class TestDef {
 
     static staticName = "static";
     static throwName = "throw";
+    static polyName = "poly";
     static constructorName = "constructor";
     static nonceLocalCallableName = "nonce";
 
@@ -60,9 +61,7 @@ export default class TestDef {
     
     // endregion Fields
 
-    // region Properties
-
-    // region Test definition, short names
+    // region Definition properties 
 
     /* These short names make JSON-like definitions easier. */
 
@@ -154,9 +153,9 @@ export default class TestDef {
         this.counteract = value;
     }
 
-    // endregion Test definition, short names
+    // endregion Definition properties
 
-    // region Def state
+    // region State properties
 
     get isRunnable() /* passed */ {
         let isRunnable
@@ -182,12 +181,17 @@ export default class TestDef {
 
         return is || stated;
     }
-    
+
     get isThrowTest() /* passed */ {
         let is = this.andStringContains(TestDef.throwName);
         return is;
     }
 
+    get isPolyCallTest() /* passed */ {
+        let is = this.andStringContains(TestDef.polyName);
+        return is;
+    }
+
     get isConstructorTest() /* passed */ {
         let plainTarget = NameAnalyzer.plainNameOf(this.of);
         return plainTarget === TestDef.constructorName;
@@ -255,17 +259,14 @@ export default class TestDef {
         if (this.isMethodTest) {
             return `${ plain }()`;
         }
-
-        if (this.isPropertyTest) {
+        else {
             return `.${ plain }`;
         }
     }
 
-    // endregion Def state
-
-    // endregion Properties
+    // endregion State properties
 
-    // region Def state methods
+    // region State methods
 
     /* Needed externally, and dependency 
        of all .and-based properties. */
@@ -277,7 +278,7 @@ export default class TestDef {
         return doesContain;
     }
 
-    // endregion Def state methods
+    // endregion State methods
 
     // region Initing, including constructor()
 

package/system/TestFrame.js

@@ -9,12 +9,12 @@ export default class TestFrame {
         // A TestStages is inited for each test.
         this.#stages = new TestStages();
     }
-    
-    run(test) /* passed */ {
+
+    async run(test) /* passed */ {
         // Outer try for fails of groundwork requested.
         try {
             // Spoofing and so on.
-            this.#stages.anyPreTargetingGroundwork(test);
+            await this.#stages.anyPreTargetingGroundwork(test);
             
             // Target may be instance, prototype for constructors, the class 
             // itself for statics, or nonce for properties.  Sets test.target.
@@ -25,14 +25,14 @@ export default class TestFrame {
             // Method under test may be on instance, class, 
             // or nonce for properties.  Sets test.callable.
             let callable = this.#stages.supplyCallableName(test);
-            
+
             // Setting (spoofing) properties and so on.
-            this.#stages.anyPostTargetingGroundwork(test);
-            
+            await this.#stages.anyPostTargetingGroundwork(test);
+
             // Inner try for fails of targeted code only.
             try {
                 // Tests usually look for this.
-                test.actual = target[callable](...test.in);
+                test.actual = await target[callable](...test.in);
             }
             catch (thrown) {
                 // Sometimes tests look for this.
@@ -50,9 +50,7 @@ export default class TestFrame {
         }
         finally {
             // Undoing any groundwork changes made. 
-            this.#stages.anyGroundworkReversal(test);
+            await this.#stages.anyGroundworkReversal(test);
         }
-        
-        // console.log(`cruft : q, outer try-catch : after`);
     }
 }

package/system/TestGroup.js

@@ -1,25 +1,25 @@
-/**/
-
-export default class TestGroup {
-    // region Private fields
-
-    #group;
-
-    // endregion Private fields
-
-    // region Properties
-
-    get group() {
-        return this.#group;
-    }
-
-    set group(value) {
-        this.#group = value;
-    }
-
-    // endregion Properties
-
-    constructor(group) {
-        this.#group = group;
-    }
-}
+/**/
+
+export default class TestGroup {
+    // region Private fields
+
+    #group;
+
+    // endregion Private fields
+
+    // region Properties
+
+    get group() {
+        return this.#group;
+    }
+
+    set group(value) {
+        this.#group = value;
+    }
+
+    // endregion Properties
+
+    constructor(group) {
+        this.#group = group;
+    }
+}

package/system/TestRunner.js

@@ -101,7 +101,7 @@ export default class TestRunner {
 
     // Generator for all test results, 
     // including groups and summary.
-    * [Symbol.iterator]() {
+    async * runTests() {
         if (!this.#tests) {
             throw new Error("No tests available to run.  TestRunner's .tests must be set before an attempt to run is made.");
         }
@@ -126,13 +126,15 @@ export default class TestRunner {
 
             // Each new method / prop name should be a group, 
             // and so should the first method for a class.
-            if (test.runName !== methodGroup.group || atFirstClassMethod) {
-                methodGroup.group = test.runName;
+            let runName = test.runName;
+
+            if (runName !== methodGroup.group || atFirstClassMethod) {
+                methodGroup.group = runName;
                 atFirstClassMethod = false;
                 yield methodGroup;
             }
 
-            let result = this.runOneTest(test);
+            let result = await this.runOneTest(test);
             yield result;
         }
 
@@ -140,7 +142,7 @@ export default class TestRunner {
         yield this.summarize();
     }
 
-    runOneTest(test) {
+    async runOneTest(test) {
         // Default outputs.  Never left undefined.
         test.didPass = false;
         test.anyThrow = null;
@@ -151,7 +153,7 @@ export default class TestRunner {
         result.setNature();
 
         // Actually running the test.
-        this.#frame.run(test);
+        await this.#frame.run(test);
 
         // Gathering facts based on the test run.
         result.setResults();

package/system/TestStages.js

@@ -14,18 +14,22 @@ export default class TestStages {
        or before / after all test frames, in the test runner.  
        Not necessarily all test steps are found here. */
 
+    // region Components
+
     static #methodSpoofer = new MethodSpoofer();
     static #propertySpoofer = new PropertySpoofer();
     static #comparer = new TotalComparer();
 
-    anyPreTargetingGroundwork(test) /* passed */ {
+    // endregion Components
+
+    async anyPreTargetingGroundwork(test) /* passed */ {
         // Spoofing methods; properties spoofed later.
         TestStages.#methodSpoofer.spoof(test);
 
         // Arbitrary user-defined actions. 
         // Only spoofed methods available.
         if (test.doesHaveDoEarly) {
-            test.do.early(test);
+            await test.do.early(test);
         }
     }
     
@@ -48,36 +52,58 @@ export default class TestStages {
     
     supplyLocalTarget(test) /* passed */ {
         /* Methods are called on instance / type / prototype directly.  
-           Properties are called on instance / type in a nonce. */
+           Properties are called on instance / type in a nonce.
+           Methods or properties are poly-called in a nonce. */
 
         let callable = NameAnalyzer.plainNameOf(test.method);
 
+        // Two most common cases: mono-call 
+        // tests of methods and properties.
         let localTarget = test.isMethodTest
             ? test.target
             : { nonce: () => { return test.target[callable]; } };
 
+        // Rare cases: poly-call tests 
+        // of methods and properties.
+        if (test.isPolyCallTest) {
+            let nonce = test.isMethodTest
+                ? this.supplyPolyMethodNonce(test, callable)
+                : this.supplyPolyPropNonce(test, callable);
+
+            localTarget = { nonce };
+        }
+
         return localTarget;
     }
 
     supplyCallableName(test) /* passed */ {
-        /* Method under test is a method named in test, 
-           or a nonce method for a property test. */
+        /* Name is of the method named in test, 
+           or a nonce method for a property or 
+           any poly-call test (method or prop). */
         
+        // Two most common cases: mono-call 
+        // test of a method or property.
         let name = test.isMethodTest 
             ? NameAnalyzer.plainNameOf(test.method) 
             : TestDef.nonceLocalCallableName;
 
+        // Rare cases: poly-call tests 
+        // of a method or property.
+        if (test.isPolyCallTest) {
+            name = TestDef.nonceLocalCallableName;
+        }
+
         return name;
     }
     
-    anyPostTargetingGroundwork(test) /* passed */ {
+    async anyPostTargetingGroundwork(test) /* passed */ {
         // Spoofing properties; methods spoofed earlier.
         TestStages.#propertySpoofer.spoof(test);
 
         // Arbitrary user-defined actions. 
         // All spoofs normally available.
         if (test.doesHaveDoLate) {
-            test.do.late(test);
+            await test.do.late(test);
         }
     }
     
@@ -99,7 +125,7 @@ export default class TestStages {
         return TestStages.#comparer.compare(expected, actual);
     }
     
-    anyGroundworkReversal(test) /* passed */ {
+    async anyGroundworkReversal(test) /* passed */ {
         // Unspoofing methods and properties.
         TestStages.#methodSpoofer.unspoof(test);
         TestStages.#propertySpoofer.unspoof(test);
@@ -107,12 +133,42 @@ export default class TestStages {
         // Arbitrary user-defined operations.
         // No spoofs are available here.
         if (test.doesHaveUndo) {
-            test.undo(test);
+            await test.undo(test);
         }
     }
 
     // region Dependencies of test stages
 
+    supplyPolyMethodNonce(test, callable) /* verified */ {
+        let nonce = (...inputs) => {
+            let actuals = [];
+
+            for (let args of inputs) {
+                let local = test.target[callable](...args);
+                actuals.push(local);
+            }
+
+            return actuals;
+        };
+
+        return nonce;
+    }
+
+    supplyPolyPropNonce(test, callable) /* verified */ {
+        let nonce = (...inputs) => {
+            let actuals = [];
+        
+            for (let args of inputs) {
+                let local = test.target[callable];
+                actuals.push(local);
+            }
+        
+            return actuals;
+        };
+
+        return nonce;
+    }
+
     supplyNonReturnActual(test) /* passed */ {
         // When .from is a string, the actual 
         // is the named target or type member.
@@ -136,7 +192,7 @@ export default class TestStages {
         // given everything that might be needed.
         if (test.from instanceof Function) {
             // Actually supplying value.
-            return test.from(test.target, test);
+            return test.from(test, test.actual);
         }
 
         // Only property names and functions make sense to support.

package/system/TestSummary.js

@@ -1,37 +1,37 @@
-/**/
-
-export default class TestSummary {
-    #summary;
-    #allDidPass;
-    #anyWereRun;
-    
-    get summary() {
-        return this.#summary;
-    }
-    
-    set summary(value) {
-        this.#summary = value;
-    }
-    
-    get allDidPass() {
-        return this.#allDidPass;
-    }
-    
-    set allDidPass(value) {
-        this.#allDidPass = value;
-    }
-    
-    get anyWereRun() {
-        return this.#anyWereRun;
-    }
-    
-    set anyWereRun(value) {
-        this.#anyWereRun = value;
-    }
-    
-    constructor(summary, allDidPass, anyWereRun) {
-        this.summary = summary;
-        this.allDidPass = allDidPass;
-        this.anyWereRun = anyWereRun;
-    }
-}
+/**/
+
+export default class TestSummary {
+    #summary;
+    #allDidPass;
+    #anyWereRun;
+    
+    get summary() {
+        return this.#summary;
+    }
+    
+    set summary(value) {
+        this.#summary = value;
+    }
+    
+    get allDidPass() {
+        return this.#allDidPass;
+    }
+    
+    set allDidPass(value) {
+        this.#allDidPass = value;
+    }
+    
+    get anyWereRun() {
+        return this.#anyWereRun;
+    }
+    
+    set anyWereRun(value) {
+        this.#anyWereRun = value;
+    }
+    
+    constructor(summary, allDidPass, anyWereRun) {
+        this.summary = summary;
+        this.allDidPass = allDidPass;
+        this.anyWereRun = anyWereRun;
+    }
+}

package/system/TypeAnalyzer.js

@@ -45,40 +45,93 @@ export default class TypeAnalyzer {
     /* Returns true if instance or static member is a method.
        Returns false if member is any kind of property. */
     static isMethodMember(type, name) /* passed */ {
-        /* A method is always defined either on a type or 
-           its prototype, even if declared on a superclass. */
+        return !TypeAnalyzer.isPropertyMember(type, name);
+    }
 
-        try {
-            let anyInstanceType = TypeIdentifier.identify(type.prototype[name]);
-            let anyStaticType = TypeIdentifier.identify(type[name]);
+    /* Returns true if instance or static member is a property 
+       (value or accessor).  Returns false if member is a method. */
+    static isPropertyMember(type, name) /* passed */ {
+        /* Type and supertypes are tested directly for static props, 
+           and their definition texts are read for instance props. */
 
-            /* Excludes class "functions", which are not methods. */
-            let isInstanceMethod = anyInstanceType === Types.isFunction;
-            let isStaticMethod = anyStaticType === Types.isFunction;
+        let isProperty = this.#typeChainIncludesAsProperty(type, name);
 
-            /* Returns net method-ness; if not found at all, a property 
-               is assumed (true as long as the member exists at all.) */
-            return isInstanceMethod || isStaticMethod;
-        }
-        catch (thrown) {
-            /* If private fields are used behind public accessor properties, 
-               there's a characteristic message which shows it's not a method.  
-               It may be a property returning a function, but not a method. */
-            if (thrown.message.startsWith(TypeAnalyzer.accessorOfPrivate)) {
-                return false;
+        return isProperty;
+    }
+
+    static #typeChainIncludesAsProperty(type, name) /* verified */ {
+        let prototype = type.prototype;
+
+        while (prototype !== null) {
+            // Type is needed, rather than prototype.
+            type = prototype.constructor;
+
+            // First line finds any static props; second, any instance props.
+            let isProperty 
+                = TypeAnalyzer.#typeDefinitionIncludesAsProperty(type, name) 
+                || TypeAnalyzer.#typeTextContainsNameAsProperty(type, name);
+
+            // Found as static or instance.
+            if (isProperty) {
+                return true;
             }
 
-            /* Other throws are unpredictable and mean there's a problem. */
-            throw thrown;
+            // Parent class.
+            prototype = Object.getPrototypeOf(prototype);
+
+            if (prototype === null) {
+                break;
+            }
         }
 
-        /* Probably never reached.  No previous throw, but some unknown problem. */
-        throw new Error("Unable to determine method vs. property state.");
+        // Never found.
+        return false;
     }
 
-    /* Returns true if instance or static member is a property 
-       (value or accessor).  Returns false if member is a method. */
-    static isPropertyMember(type, name) /* passed */ {
-        return !TypeAnalyzer.isMethodMember(type, name);
+    static #typeDefinitionIncludesAsProperty(type, name) /* verified */ {
+        let named = Object.getOwnPropertyDescriptor(type, name);
+
+        // If not found, try parent.
+        if (named === undefined) {
+            return false;
+        }
+
+        // Members with getters are properties.
+        if (named.get !== undefined) {
+            return true;
+        }
+
+        // Members with function values are methods.
+        if (named.value instanceof Function) {
+            return false;
+        }
+
+        // Members with any other values are properties.
+        if (named.value !== undefined) {
+            return true;
+        }
+    }
+
+    static #typeTextContainsNameAsProperty(type, name) /* verified */ {
+        let text = type.toString();
+
+        // Instance properties are always defined as 'name =', 
+        // 'name;', or 'get name()' at the start of a line.
+        let valueRegex = new RegExp(`^\\s*${ name }\\s*[=;]`, "m");
+        let accessorRegex = new RegExp(`^\\s*get ${ name }\\(\\)`, "m");
+
+        let anyIndexOf = text.search(valueRegex);
+
+        if (anyIndexOf >= 0) {
+            return true;
+        }
+
+        anyIndexOf = text.search(accessorRegex);
+
+        if (anyIndexOf >= 0) {
+            return true;
+        }
+
+        return false;
     }
 }

package/system/ChosenTestFinder.js

@@ -1,31 +0,0 @@
-/**/
-
-/* ChosenTestFinder is an ATestFinder that finds tests in the places coded in its constructor. */
-
-import ATestFinder from "./ATestFinder.js";
-import TopicTests from "../trial-tests/TopicTests.outward-rt.js";
-import SelfTests from "../trial-tests/SelfTests.outward-rt.js";
-
-export default class ChosenTestFinder extends ATestFinder {
-    constructor() {
-        super();
-        
-        let testSource = new TopicTests();
-        let selfTestSource = new SelfTests();
-        
-        this.testSources = [ testSource, selfTestSource ];
-    }
-
-    async findAllTests() {
-        let tests = [];
-        
-        for (let source of this.testSources) {
-            let local = source.tests;
-            tests.push(...local);
-        }
-        
-        // Returning an awaitable value 
-        // to match async signature.
-        return Promise.resolve(tests);
-    }
-}

package/system/Risei.js

@@ -1,118 +0,0 @@
-/**/
-
-/* Copyright (c) 2023-2024 Ed Fallin.  Published under the terms of the MIT license. */
-
-/* This index.js is the entry point for running Risei tests from 
-   other code.  It imports other modules to perform its work.
-   It also exports modules that should / can be subclassed. */
-
-// region Imports
-
-// region Test-running dependencies
-
-import TestRunner from "./TestRunner.js";
-import LocalCaller from "./LocalCaller.js";
-import TerminalReporter from "./TerminalReporter.js";
-import TestFinder from "./TestFinder.js";
-
-// endregion Test-running dependencies
-
-// region Display dependencies
-
-import chalk from "chalk";
-import Moment from "./Moment.js";
-
-// endregion Display dependencies
-
-// endregion Imports
-
-// region Named styles
-
-/* Display styles for the start title and other general needs. */
-const title = chalk.hex("FFFFFF").bgHex("191970").bold;
-const fails = chalk.hex("000000").bgHex("FFD700").bold;
-
-// endregion Named styles
-
-// region Styling for color stripes
-
-let wide = (text) => { 
-    let width = process.stdout.columns;
-    text = text || "";
-
-    return text.padEnd(width, "\u00A0");
-};
-
-// endregion Styling for color stripes
-
-// region Key callable and its scripted call
-
-async function runRiseiMetaTests(testFinderPath) {
-    // region Converting test-finder from path to class
-    
-    testFinderPath = testFinderPath || "./TestFinder.js";
-    let finderModule = await import(testFinderPath);
-    
-    let moduleKeys = Object.keys(finderModule);
-    let classKey = moduleKeys[0];
-    let finderClass = finderModule[classKey];
-    
-    // endregion Converting test-finder from path to class
-
-    // region Intro / title
-    
-    console.clear();
-    console.log();
-    console.log(title(wide()));
-    
-    let now = new Date();
-    now = new Moment(now);
-    
-    console.log(title(wide(` Risei tests run on ${ now.asReadable() } local time.`)));
-    console.log(title(wide()));
-    
-    console.log();
-    
-    // endregion Intro / title
-    
-    // region Running tests
-    
-    // Test-system objects and their relationships.
-    const finder = new finderClass.prototype.constructor();
-    finder.sourceBySearch = () => { return { tests: "**.outward-rt.js" }; };
-
-    const runner = new TestRunner();
-    const reporter = new TerminalReporter();
-    
-    const caller = new LocalCaller(finder, runner, reporter);
-
-    // Actually running the tests using this system.
-    await caller.runAllTests();
-    
-    // endregion Running tests
-    
-    // region Trailing display of test-loading issues
-
-    if (finder.thrown.length !== 0) {
-        let loadFails = finder.thrown;
-
-        for (let fail of loadFails) {
-            console.log(fails(wide(` ${ fail }`)));
-        }
-    }
-
-    // endregion Trailing display of test-loading issues
-
-    // region Trailing formatting
-    
-    console.log();
-    console.log();
-    
-    // endregion Trailing formatting
-}
-
-/* Runs tests now. */
-await runRiseiMetaTests();
-
-// endregion Key callable and its scripted call
-