risei 1.1.1 → 1.1.2

package/tests/self-tests/SelfTests.outward-rt.js

@@ -1,583 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { Moment } from "../../system/Moment.js";
-
-import { SpoofCaller } from "../target-objects/SpoofCaller.js";
-import { SpoofTuple } from "../../system/SpoofTuple.js";
-import { Spoofable } from "../target-objects/Spoofable.js";
-import { SpoofableArgsCaller } from "../target-objects/SpoofableArgsCaller.js";
-import { PolySpoofableOuter } from "../target-objects/PolySpoofableOuter.js";
-import { PolySpoofableInner } from "../target-objects/PolySpoofableInner.js";
-import { ConditionalThrowModel } from "../target-objects/ConditionalThrowModel.js";
-import { ObjectCompositionModel } from "../target-objects/ObjectCompositionModel.js";
-import { MixedContents } from "../target-objects/MixedContents.js";
-import { Returner } from "../target-objects/Returner.js";
-import { MutationModel } from "../target-objects/MutationModel.js";
-
-export class SelfTests extends ATestSource {
-    // region Fields
-
-    #sameObject = { a: "b" };    
-
-    // endregion Fields
-
-    // region Tests
-
-    tests = [
-        { on: Moment, of: "asReadable" },
-        /* The date-time input is in the constructor arguments, so .with, and no .in contents are needed. */
-        /* Without final `Z`, the long date-time formats used are local times. */
-
-        { for: "When given a date with a time before noon, returns less than twelve and AM.", /* good */
-          with: [ new Date("2024-10-08T08:45:37.143") ], 
-          in: [], out: "10/08/2024 at 8:45:37 AM" },
-        { for: "When given a date with a time after noon, returns greater than twelve and PM.", /* good */
-          with: [ new Date("2024-10-08T18:45:37.143") ],
-          in: [], out: "10/08/2024 at 6:45:37 PM" },
-        { for: "When given a date with noon, returns twelve and PM.", /* good */
-          with: [ new Date("2026-08-10T12:00:00.000") ],
-          in: [], out: "8/10/2026 at 12:00:00 PM" },
-        { for: "When given a date with midnight, returns twelve and AM.", /* good */
-          with: [ new Date("2026-08-10T24:00:00.000") ],
-          in: [], out: "8/11/2026 at 12:00:00 AM" },  /* Midnight of day D is treated as day D +1. */
-        { for: "When given a date with a time in the noon hour, returns twelve and PM.", /* good */
-          with: [ new Date("2024-10-08T12:21:07.143") ],
-          in: [], out: "10/08/2024 at 12:21:07 PM" },
-        { for: "When given a date with a time in the midnight hour, returns twelve and AM.", /* good */
-          with: [ new Date("2024-10-08T00:21:07.143") ],
-          in: [], out: "10/08/2024 at 12:21:07 AM" },
-
-        { for: "When given a date with a one-digit day, returns day with a leading zero.", /* good */
-          with: [ new Date("2026-10-07T13:03:02.000") ],
-          in: [], out: "10/07/2026 at 1:03:02 PM" },
-        { for: "When given a date with a two-digit day, returns day digits unchanged.", /* good */
-          with: [ new Date("2026-08-12T14:06:02.000") ],
-          in: [], out: "8/12/2026 at 2:06:02 PM" },
-        { for: "When given a date with a month less than ten, returns month without a leading zero.", /* good */
-          with: [ new Date("2024-06-16T10:24:12.000") ],
-          in: [], out: "6/16/2024 at 10:24:12 AM" },
-        { for: "When given a date with a month greater than ten, returns month unchanged.", /* good */
-          with: [ new Date("2024-11-16T10:32:14.000") ],
-          in: [], out: "11/16/2024 at 10:32:14 AM" },
-        { for: "When given a date in January, returns month of 1, not 0.", /* good */
-          with: [ new Date("2028-01-14T23:23:43.000") ],  /* JS internal month handling (only) is zero-based. */
-          in: [], out: "1/14/2028 at 11:23:43 PM" },
-
-        /* &cruft, remove these indirect tests of SCF when direct tests are finished and all passing */
-        { on: Spoofable, with: [] },
-        { for: "When SCF is used to spoof with no return value, a call to the spoofed method doesn't return anything.", /* good */
-          plus: [ { of: "spoofNumber" } ],  /* The actual spoofing. */
-          /* Calling indirectly so that .out doesn't have to be `undefined`. */
-          of: "callSpoofNumber", 
-          in: [ 8, 17 ], 
-          /* Can't set .out to `undefined`, since it's not a full test then. */
-          out: "spoofNumber() internal call: no return value"
-        },
-        { for: "When SCF is used to spoof with a return value, the spoofed method returns that value.", /* good */
-          plus: [ { of: "spoofNumber", as: 10 } ],  /* The actual spoofing. */
-          of: "spoofNumber", in: [ 8, 17 ], out: 10 },
-        { for: "When SCF is used to spoof with a return simple object, the spoofed method returns that object.", /* good */
-          plus: [ { of: "spoofNumber", as: { a: 3, b: "4", c: 5, d: "six" } } ],  /* The actual spoofing. */
-          of: "spoofNumber", in: [ 8, 17 ], out: { a: 3, b: "4", c: 5, d: "six" } },
-        { for: "When SCF is used to spoof with a return specialized object, the spoofed method returns that object.", /* good */
-          plus: [ { of: "spoofNumber", as: new Map([[1, "first"], [2, "second"]]) } ],  /* The actual spoofing. */
-          of: "spoofNumber", in: [ 7, 18 ], out: new Map([[1, "first"], [2, "second"]]) },
-
-        { for: "When SCF is used to spoof with code, the spoofed method enacts that code.", /* good */
-          plus: [ { of: "spoofNumber", as: function (a, b) { return a - b; } } ],
-          of: "spoofNumber", in: [ 12, 8 ], out: 4 },
-        { for: "When SCF is used to spoof with code, the method definition matches the spoof.", /* good */
-          plus: [ { of: "spoofNumber", as: (a, b) => { return a * b; } } ],
-          of: "spoofNumber", in: [ 12, 12 ], out: (a, b) => { return a * b; },
-          from: (target) => {
-            let prototype = Object.getPrototypeOf(target); 
-            return prototype.spoofNumber; 
-          }
-        },
-
-        { for: "When SCF is not used to spoof a method, the original method definition still exists.", /* good */
-          of: "spoofNumber", 
-          plus: [ ],  /* Nothing is spoofed, but existing spoofing must be cleared. */
-          in: [ 12, 12 ], out: function spoofNumber(a, b) { return a + b; }, 
-          from: (target) => {
-            let prototype = Object.getPrototypeOf(target);
-            return prototype.spoofNumber; 
-          }
-        },
-
-        { for: "When SCF is used with a definition provided to .plus by a function call, the spoof is used.", /* good */
-          of: "spoofNumber",
-          plus: this.supplySingleElementSpoofArray(),
-          in: [ 12, 12 ], out: 32
-        },
-
-        { for: "When SCF is used to spoof a method before a non-spoofing .plus of false, the spoof is used.", /* good */
-          of: "spoofNumber",
-          plus: [ { of: "spoofNumber", as: 628 } ],
-          in: [ 12, 12 ], out: 628
-        },
-
-        { for: "When a method is called with .plus of false, no spoofing is performed.", /* good */
-          of: "spoofNumber",
-          plus: false,
-          in: [ 12, 12 ], out: 24
-        },
-
-        { for: "When SCF is used to spoof a method before a non-spoofing .plus of { }, the spoof is used.", /* good */
-          of: "spoofNumber",
-          plus: [ { of: "spoofNumber", as: 645 } ],
-          in: [ 12, 12 ], out: 645
-        },
-
-        { for: "When a method is called with .plus of { }, no spoofing is performed.", /* good */
-          of: "spoofNumber",
-          plus: { },
-          in: [ 12, 12 ], out: 24
-        },
-
-        { on: ObjectCompositionModel, with: [] },
-        { for: "When SCF is used to spoof a method to return a deep object " +
-               "that is invoked internally, the spoofed deep object is used." /* good */,
-          plus: [ { of: "supplySomeObject", as: [ { of: "outer.inner.callable", as: 18 } ] } ],
-          of: "enact",
-          in: [ ["outer", "inner" ], "callable" ],
-          out: 18
-        },
-        { for: "When SCF is used to spoof a method to return a branched deep " +
-               "object that is invoked internally, both branches are used.", /* good */
-          plus: [ { of: "supplySomeObject", 
-                    as: [ 
-                            { of: "outer.inner.callableOne", as: 16 }, 
-                            { of: "outer.inner.callableTwo", as: 20 } 
-                        ] } 
-                ],
-          of: "doubleEnact",
-          in: [ [ "outer", "inner" ], "callableOne", [ "outer", "inner" ], "callableTwo" ],
-          out: [ 16, 20 ]
-        },
-
-        { on: SpoofCaller, with: [] },
-        { for: "When a spoof that returns a value is called, it returns that value.", /* good */
-          of: "runSpoof", in: [ "returnFifteen", 15 ], out: 15 },
-        { for: "When a spoof that returns a text is called, it returns that text.", /* good */
-          of: "runSpoof", in: [ "returnText", "return-text" ], out: "return-text" },
-        { for: "When a spoof that is a text-returning nonce function is called, it returns that value.", /* good */
-          of: "runSpoof", in: [ "nonceText", () => { return "nonce-text"; } ], out: "nonce-text" },
-
-        { on: SpoofableArgsCaller },
-        { for: "When .with contains a spoof definition and there is no \"nospoof\" in .and, the spoof is used.", /* good */
-          with: [ { of: "number", as: 594 } ], 
-          of: "callConstructorArg", 
-          and: "something", 
-          in: [ ], 
-          out: 594 
-        },
-        { for: "When .with contains a spoof definition but there is \"nospoof\" in .and, the spoof is not used.", /* good */
-          with: [ { of: "number", as: 594 } ], 
-          of: "callConstructorArg", 
-          and: "nospoof something", 
-          in: [ ], 
-          out: "this.#cArg.of: number, this.#cArg.as: 594" 
-        },
-        { for: "When .in contains a spoof definition and there is no \"nospoof\" in .and, the spoof is used.", /* good */
-          of: "callMethodArg", 
-          and: "something", 
-          in: [ { of: "text", as: "spoofed-text" } ], 
-          out: "spoofed-text" 
-        },
-        { for: "When .in contains a spoof definition but there is \"nospoof\" in .and, the spoof is not used.", /* good */
-          of: "callMethodArg", 
-          and: "something nospoof", 
-          in: [ { of: "text", as: "spoofed" } ], 
-          out: "mArg.of: text, mArg.as: spoofed" 
-        },
-
-        { on: PolySpoofableOuter, with: [] }, 
-        { for: "When nothing is spoofed, the original ops and args are used.", /* good */
-          of: "combinedNumbers",
-          in: [ { supplyA: () => { return 4; }, supplyB: () => { return 2; } } ],
-          out: 36  /* (4 + 2) ^^ (4 - 2) = 6 ^^ 2 */
-        },
-        { for: "When args only are spoofed, the original ops are used.", /* good */
-          of: "combinedNumbers",
-          in: [ { as: [ { of: "supplyA", as: 10 }, { of: "supplyB", as: 7 } ] } ],
-          out: 4913  /* (10 + 7) ^^ (10 - 7) = 17 ^^ 3  */
-        },
-        { for: "When class methods only are spoofed, the spoofed methods are used.", /* good */
-          of: "combinedNumbers",
-          plus: [ { on: PolySpoofableInner, 
-                    as: [ { of: "addOrTimes", as: (numbers) => { return numbers.supplyA() * numbers.supplyB(); } }, 
-                          { of: "minusOrOver", as: (numbers) => { return numbers.supplyA() / numbers.supplyB(); } } 
-                        ] 
-                  }
-                ],
-          in: [ { supplyA: () => { return 6; }, supplyB: () => { return 2; } } ],
-          out: 1728  /* (6 * 2) ^^ (6 / 2) */
-        },
-        { for: "When methods of two classes are spoofed, the spoofs of both are used.", /* good */
-          of: "combinedNumbers",
-          plus: [ { on: PolySpoofableOuter, 
-                    of: "combiner", 
-                    as: (first, second) => {
-                        let netLog = Math.log(second) / Math.log(first);
-                        return Number(netLog.toString().slice(0, 4)); 
-                    }
-                  }, 
-                  { on: PolySpoofableInner, 
-                    as: [ { of: "addOrTimes", as: (numbers) => { return 2; } },
-                          { of: "minusOrOver", as: (numbers) => { return 8; } }
-                        ]
-                  }
-          ],
-          in: [ { supplyA: () => { return 7; }, supplyB: () => { return 4; } } ],
-          out: 3  /* log base 2 of 8 */
-        },
-        { for: "When two methods of an object are spoofed, both spoofs are used", /* good */
-          of: "combinedArgAAndB",
-          in: [ { as: [ 
-                    { of: "supplyA", as: 18 }, 
-                    { of: "supplyB", as: 14 } 
-                ]
-              }
-          ],
-          out: 32  /* 18 + 14 */
-        },
-        { for: "When two methods of an object hosted on an object are spoofed, both spoofs are used", /* good */
-          of: "combinedArgHostedCAndD",
-          in: [ { as: [ 
-                    { of: "numberHost.supplyC", as: 14 }, 
-                    { of: "numberHost.supplyD", as: 11 } 
-                ]
-              }
-          ],
-          out: 3  /* 14 - 11 */
-        },
-
-        { on: ConditionalThrowModel, of: "returnArgOrThrow", with: [ ] },
-        { for: "When arg is provided, returns the arg.", /* good */
-          in: [ "some-arg" ], out: "some-arg" },
-        { for: "When no arg is provided, but .and contains \"throws\", throws expected message.", /* good */
-          and: "throws something", 
-          in: [ ], out: "No arg provided." },
-        { for: "When no arg is provided, but .and contains \"throw\", throws expected message.", /* good */
-          and: "something throw", 
-          in: [ ], out: "No arg provided." },
-
-
-        { on: SpoofTuple, with: [] },
-
-        /* SpoofTuple static methods. */
-        { of: "combineValues", and: "static" },
-        { for: "With a property on `other` but not `self`, value on `other` is applied to `self`.", /* good */
-          in: [
-            { target: "on-arg", method: "of-arg", not: true },
-            { target: "on-arg", method: "of-arg", output: "other-as", not: true },
-            "output"
-          ],
-          out: "other-as",
-          from: (target, test) => {
-            let self = test.in[0];  // The input arg has been mutated.
-            return self.output;
-          }
-        },
-        { for: "With a property already defined on `self`, value on `other` is not applied to `self`.", /* good */
-          in: [
-            { target: "on-arg", method: "of-arg", output: "self-as", not: true },
-            { target: "on-arg", method: "of-arg", output: "other-as", not: true },
-            "output"
-          ],
-          out: "self-as",
-          from: (target, test) => {
-            let self = test.in[0];  // The input arg has been mutated.
-            return self.output;
-          }
-        },
-        { for: "When a property is undefined on `self` and `other`, it remains undefined.", /* good */
-          in: [
-            { target: "on-arg", output: "as-arg", not: true },
-            { target: "on-arg", output: "as-arg", not: true },
-            "method"
-          ],
-          out: "self.method: undefined",
-          from: (target, test) => {
-              let self = test.in[0];  // The input arg has been mutated.
-              return self.method === undefined ? "self.method: undefined" : self.method;
-          }
-        },
-
-        { of: "maybeRestartFull", and: "static" },
-        { for: "When `latest` doesn't have `target` defined, `full` is returned.", /* good */
-          in: [
-            { target: "full-on", method: "full-of", output: "full-as", not: true },
-            { output: "latest-as", method: "latest-of", not: true }
-          ],
-          out: { target: "full-on", method: "full-of", output: "full-as", not: true }
-        },
-        { for: "When `latest` does have `target` defined, `latest` is returned.", /* good */
-          in: [
-            { target: "full-on", method: "full-of", output: "full-as", not: true },
-            { target: "new-on", method: "new-of", output: "new-as", not: true }
-          ],
-          out: { target: "new-on", method: "new-of", output: "new-as", not: true }
-        },
-
-        { of: "fromNonceTuple", and: "static" },
-        { for: "When the nonce has all long-named properties, all properties are set.", /* good */
-          in: [
-            { target: "target", method: "method", output: "output", not: true }
-          ],
-          out: new SpoofTuple("target", "method", "output")
-        },
-        { for: "When the nonce has all short-named properties, all properties are set.", /* good */
-          in: [
-            { on: "target", of: "method", as: "output", not: true }
-          ],
-          out: new SpoofTuple("target", "method", "output")
-        },
-        { for: "When the nonce has all properties with mixed short and long names, all properties are set.", /* good */
-          in: [
-            { on: "target", method: "method", as: "output", not: true }
-          ],
-          out: new SpoofTuple("target", "method", "output")
-        },
-        { for: "When the nonce has some properties with mixed short and long names, just those properties are set.", /* good */
-          in: [
-            { on: "on-arg", method: "as-arg", notAs: "not-as", not: true }
-          ],
-          out: new SpoofTuple("on-arg", "as-arg")
-        },
-        { for: "When the nonce has no SpoofTuple properties, those output properties are not set.", /* good */
-          in: [ { notASpoofTuple: true, nonceOfSpoofTuple: false } ],
-          out: new SpoofTuple() },
-
-        /* SpoofTuple instance methods. */
-        { of: "constructor" },
-        { for: "When constructed, .on is the same as the `target` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "target-arg",
-          from: "on"
-        },
-        { for: "When constructed, .target is the same as the `target` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "target-arg",
-          from: "target"
-        },
-        { for: "When constructed, .of is the same as the `method` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "method-arg",
-          from: "of"
-        },
-        { for: "When constructed, .method is the same as the `method` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "method-arg",
-          from: "method"
-        },
-        { for: "When constructed, .as is the same as the `output` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "spoof-arg",
-          from: "as"
-        },
-        { for: "When constructed, .output is the same as the `output` arg.", /* good */
-          in: [ "target-arg", "method-arg", "spoof-arg" ],
-          out: "spoof-arg",
-          from: "output"
-        },
-
-        { of: "toString" },
-        { for: "When any properties are strings, they are written with quotes.", /* good */
-          on: SpoofTuple, 
-          with: [ "on-arg", "of-arg", "as-arg" ],
-          in: [ ],
-          out: `SpoofTuple:{ target:"on-arg", method:"of-arg", output:"as-arg" }`
-        },
-        { for: "When any properties are not strings, they are written without quotes.", /* good */
-          on: SpoofTuple,
-          with: [ true, false, 27 ],
-          in: [ ],
-          out: `SpoofTuple:{ target:true, method:false, output:27 }`
-        },
-
-        { of: "isSpoofable" },
-        { for: "When instance doesn't have .target, .method, or .output, returns false.", 
-          with: [ undefined, undefined, undefined ],
-          in: [ ],
-          out: false },
-        { for: "When instance has .target but not .method or .output, returns false.", 
-          with: [ "target-arg", undefined, undefined ],
-          in: [ ],
-          out: false },
-        { for: "When instance has .method but not .target or .output, returns true.", 
-          with: [ undefined, "method-arg", undefined ],
-          in: [ ],
-          out: true },
-        { for: "When instance has .output but not .target or .method, returns true.", 
-          with: [ undefined, undefined, "as-arg" ],
-          in: [ ],
-          out: true },
-        { for: "When instance has .target and .method, returns true.", 
-          with: [ "on-arg", "of-arg", undefined ],
-          in: [ ],
-          out: true },
-        { for: "When instance has .target and .output, returns true.", 
-          with: [ "on-arg", undefined, "as-arg" ],
-          in: [ ],
-          out: true },
-        { for: "When instance has .method and .output, returns true.", 
-          with: [ undefined, "of-arg", "as-arg" ],
-          in: [ ],
-          out: true },
-        { for: "When instance has valid contents plus other args, returns true.", /* good */
-          with: [ undefined, "of-arg", "as-arg", "frip", "sliff" ],
-          in: [ ],
-          out: true },
-
-        { of: "isNotASpoof", and: "static" },
-        { for: "When arg contains SpoofTuple properties but also .not, returns true.", /* good */
-          in: [ { on: "on-arg", of: "of-arg", as: "as-arg", not: true } ],
-          out: true },
-        { for: "When arg contains SpoofTuple properties but also .skip, returns true.", /* good */
-          in: [ { on: "on-arg", of: "of-arg", as: "as-arg", skip: true } ],
-          out: true },
-        { for: "When arg doesn't contain any SpoofTuple properties, returns true.", /* good */
-          in: [ { notOn: true, notOf: "true", notAs: "not-as" } ],
-          out: true },
-        { for: "Tests of returns-false cases can't readily be tested within this system itself.", /* good */
-          of: null },
-
-        { of: "fromNonceTuples", and: "static" },
-        { for: "When nonces are not SpoofTuple equivalents, returns nonces unaltered.", /* good */
-          in: [ [ { first: "first", and: true }, { second: "second", and: false } ] ],
-          out: [ { first: "first", and: true }, { second: "second", and: false } ] },
-        { for: "Tests of returns-SpoofTuple cases can't readily be tested within this system itself.", /* good */
-          of: null },
-
-        { on: MixedContents, with: [ ] },
-        { for: "When .amid contains an { of, as }, .as is used for .of on the target.", /* good */
-          of: "getInstanceValueOf",
-          in: [ "first" ],
-          amid: [ { of: "first", as: 25 } ],
-          out: 25 },
-        { for: "When .amid is an empty array, original target property values are used.", /* good */
-          of: "getInstanceProduct",
-          in: [ ],
-          amid: [ ],
-          out: 6 },
-        { for: "When .amid sets several properties, those property values are used.", /* good */
-          of: "getInstanceProduct",
-          in: [ ],
-          amid: [ { of: "first", as: 12 }, { of: "second", as: 6 }, { of: "third", as: { three: 7 } } ],
-          out: 504 },
-        { for: "When .amid contains an { of, as } in a static test, .as is used for .of on the topic class.", /* good */
-          of: "getStaticValueOf",
-          and: "static",
-          in: [ "fourth" ],
-          amid: [ { of: "fourth", as: 18 } ],
-          out: 18 },
-        { for: "When .amid is an empty array in a static test, original topic-class property values are used.", /* good */
-          of: "getStaticProduct",
-          and: "static",
-          in: [ ],
-          amid: [ ],
-          out: 20 },
-        { for: "When .amid in a static test sets several properties, those topic-class property values are used.", /* good */
-          of: "getStaticProduct",
-          and: "static",
-          in: [ ],
-          amid: [ { of: "fourth", as: 7 }, { of: "fifth", as: "12" } ],
-          out: 84 },
-
-        { on: Returner, with: [ ] },
-        { for: "When a class is used in args, this test result displays its name only wherever used.", /* good */
-          of: "returnArg", in: [ MixedContents ], out: MixedContents },
-        { for: "When a class is used in a Map in args, only its name is used in this test result.", /* good */
-          of: "returnArg", in: [ new Map([ [ Spoofable, 2 ], [ MixedContents, 3 ] ]) ],
-          out: new Map([ [ Spoofable, 2 ], [ MixedContents, 3 ] ]) },
-        { for: "When a class is used in an object in args, only its name is used in this test result.", /* good */
-          of: "returnArg", in: [ { moment: Moment, spoofable: Spoofable } ],
-          out: { moment: Moment, spoofable: Spoofable } },
-
-        /* &cruft, revive these tests when single TestFrame with all test stages is used */
-        // { on: MutationModel, with: [ new Map([ [ "1", "A" ], [ "2", "B" ] ]), [ 8, 9, 10 ] ], and: "nospoof" },
-        // { for: "When the tested method mutates its args, the args it addresses are mutated.", /* good */
-        //   of: "mutateArgs",
-        //   in: [ [ 7, 8, 9 ], { retainable: 12, changes: 30 } ], 
-        //   // Return-value object bundles the mutated args.
-        //   out: { array: [ 7, 8, 9, 10 ], tuple: { retainable: 12, changes: 40 } },
-        //   from: [ ] },
-        // { for: "When the tested method mutates its args, the args in test.in are not mutated.", /* good */
-        //   // Test args .of and .in are not redefined here, so they collapse forward.
-        //   out: [ [ 7, 8, 9 ], { retainable: 12, changes: 30 } ], 
-        //   from: (target, test) => { return test.in; } },
-        // { for: "When the args in test.in are used in a collapsed-forward test, the un-mutated values are used.", /* good */
-        //   // Test args .of and .in are not redefined here, so they collapse forward.
-        //   // Returned values should reflect only one pass of changes.
-        //   out: { array: [ 7, 8, 9, 10 ], tuple: { retainable: 12, changes: 40 } },
-        //   // Test arg .from must be cleared to use return value.
-        //   from: [ ] },
-        // { for: "When the tested method mutates the constructor args, the args it addresses are mutated.", /* good */
-        //   of: "mutateInitors",
-        //   // Test arg .with is not redefined, so original args collapse forward.
-        //   // Test can't be of constructor(), which would ignore test.with.
-        //   // Return-value object bundles the mutated args.
-        //   in: [ ], 
-        //   out: { map: new Map([ [ "1", "A" ], [ "2", "B" ], [ "3", "C" ] ]), array: [ 9, 10 ] },
-        //   from: [ ] },
-        // { for: "When the tested method mutates the constructor args, the args in test.with are not mutated.", /* good */
-        //   of: "mutateInitors",
-        //   // Test arg .with is not redefined, so original args collapse forward.
-        //   // Test can't be of constructor(), which would ignore test.with.
-        //   in: [ ], 
-        //   out: [ new Map([ [ "1", "A" ], [ "2", "B" ] ]), [ 8, 9, 10 ] ], 
-        //   from: (target, test) => { return test.with; } },
-        // { for: "When the args in test.with are used in a collapsed-forward test, the un-mutated values are used.", /* good */
-        //   of: "mutateInitors",
-        //   // Test arg .with is not redefined, so original args collapse forward.
-        //   // Test can't be of constructor(), which would ignore test.with.
-        //   // Returned values should reflect only one pass of changes.
-        //   in: [ ], 
-        //   out: { map: new Map([ [ "1", "A" ], [ "2", "B" ], [ "3", "C" ] ]), array: [ 9, 10 ] },
-        //   from: [ ] },
-
-    ];
-
-    // endregion Tests
-
-    // region Local test fixtures
-
-    supplySingleElementSpoofArray() {
-        return [ { of: "spoofNumber", as: 32 } ]
-    }
-
-    supplySpoofNumberDefinition(target, test) {
-        /* Method members are defined on the prototype, 
-           not on instances, so they are found this way.  */
-
-        let args = test.in;
-        let spoofableClass = args[0];
-        return spoofableClass.prototype.spoofNumber;
-    }
-
-    supplySpoofTextDefinition(target, test) {
-        /* Method members are defined on the prototype, 
-           not on instances, so they are found this way.  */
-
-        let args = test.in;
-        let spoofableClass = args[0];
-        return spoofableClass.prototype.spoofText;
-    }
-
-    supplyArgsForCombineValuesTest() {
-        let args = [];
-
-        let self = { target: "target-arg", method: "method-arg", not: true };
-        let other = { target: "target-arg", method: "method-arg", output: "output-arg", not: true };
-
-        args.push(self, other);
-        args.push("output")
-
-        return args;
-    }
-
-    // endregion Local test fixtures
-}

package/tests/target-objects/CompositionModel.js

@@ -1,38 +0,0 @@
-/**/
-
-export class CompositionModel {
-    #first;
-    #second;
-    #number;
-
-    /* For this test-facing class, 
-       `number` is often omitted. */
-    constructor(first, second, number) {
-        this.#first = first;
-        this.#second = second;
-        this.#number = number;
-    }
-    
-    multiplyValues(third, fourth) {
-        let a = this.#first.supplyValue();
-        let b = this.#second.supplyValue();
-        let c = third.supplyValue();
-        let d = fourth.supplyValue();
-        
-        let output = a * b * c * d;
-        return output;
-    }
-    
-    addValues(third, fourthNumber, fifth, sixthNumber) {
-        let a = this.#first.supplyValue();
-        let b = this.#second.supplyValue();
-        let c = this.#number;
-        let d = third.supplyValue();
-        let e = fourthNumber;
-        let f = fifth.supplyValue();
-        let g = sixthNumber;
-        
-        let output = a + b + c + d + e + f + g;
-        return output;
-    }
-}

package/tests/target-objects/ConditionalThrowModel.js

@@ -1,11 +0,0 @@
-/**/
-
-export class ConditionalThrowModel {
-    returnArgOrThrow(arg) {
-        if (arg === undefined) {
-            throw new Error("No arg provided.");
-        }
-        
-        return arg;
-    }
-}