risei 2.0.0 → 2.0.1

package/test-target-objects/StateTarget.js

@@ -1,34 +0,0 @@
-/**/
-
-export default class StateTarget {
-    #numberState;
-    #textState;
-
-    get numberState() {
-        return this.#numberState;
-    }
-    
-    get textState() {
-        return this.#textState;
-    }
-
-    constructor() {
-        this.#numberState = 1;
-        this.#textState = "1";
-    }
-    
-    setNumberState(number) {
-        this.#numberState = number;
-    }
-    
-    setTextState(text) {
-        this.#textState = text;
-    }
-    
-    changeNumberAndTextState(number, text) {
-        this.#numberState = number;
-        this.#textState = text;
-    
-        return { number: this.#numberState, text: this.#textState };
-    }
-}

package/test-target-objects/StaticTarget.js

@@ -1,17 +0,0 @@
-/**/
-
-export default class StaticTarget {
-    static #property = "default-static-property";
-
-    static get staticProperty() {
-        return StaticTarget.#property;
-    }
-
-    static setStaticProperty(value) {
-        StaticTarget.#property = value;
-    }
-
-    static multiplyThenDivide(a, b, c) {
-        return (a * b) / c;
-    }
-}

package/test-target-objects/TestableTarget.js

@@ -1,57 +0,0 @@
-/**/
-
-export default class TestableTarget {
-    // region Static members
-
-    static staticValueProp = 3;
-
-    static #staticAccessorValue = "4th";
-    
-    static get staticAccessorProp() {
-        return this.#staticAccessorValue;
-    }
-    
-    static set staticAccessorProp(value) {
-        this.#staticAccessorValue = value;
-    }
-    
-    static staticMethod() {
-        return "static";
-    }
-
-    static staticThrower() {
-        // You don't have to throw an Error object.
-        throw "Throw by staticThrower().";
-    }
-
-    // endregion Static members
-
-    constructor() {
-        /* No operations. */
-    }
-
-    // region Instance members
-
-    valueProp = 1;
-
-    #accessorValue = "2nd";
-    
-    get accessorProp() {
-        return this.#accessorValue;
-    }
-
-    set accessorProp(value) {
-        this.#accessorValue = value;
-    }
-    
-    instanceMethod(argOne, argTwo) {
-        return `instance-method-${ argOne }-${ argTwo }`;
-    }
-
-    instanceThrower() {
-        // You don't have to throw an Error object.
-        throw "Throw by instanceThrower()."
-    }
-
-    // endregion Instance members
-}

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

@@ -1,511 +0,0 @@
-/**/
-
-import ATestSource from "risei/ATestSource";  // Path must match class used in TestFinder.
-
-import Spoofable from "../test-target-objects/Spoofable.js";
-import ObjectComposer from "../test-target-objects/ObjectComposer.js";
-import PolySpoofableOuter from "../test-target-objects/PolySpoofableOuter.js";
-import PolySpoofableInner from "../test-target-objects/PolySpoofableInner.js";
-import ConditionalThrowTarget from "../test-target-objects/ConditionalThrowTarget.js";
-import MixedContents from "../test-target-objects/MixedContents.js";
-import Returner from "../test-target-objects/Returner.js";
-import Moment from "../system/Moment.js";
-import MutationTarget from "../test-target-objects/MutationTarget.js";
-import TestableTarget from "../test-target-objects/TestableTarget.js";
-
-export default class SelfTests extends ATestSource {
-    // region Fields
-
-    #sameObject = { a: "b" };
-
-    // endregion Fields
-
-    // 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
-
-    // region Tests
-
-    tests = [
-        /* &cruft, ? remove / refashion these indirect tests of MethodSpoofer after direct testing finished */
-
-        { on: Spoofable, with: [] },
-        { for: "When a method is spoofed with no return value, calling it 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 a method is spoofed with a return value, calling it returns that value.", /* good */
-          plus: [ { of: "spoofNumber", as: 10 } ],  /* The actual spoofing. */
-          of: "spoofNumber", in: [ 8, 17 ], out: 10 },
-        { for: "When a method is spoofed with a return simple object, calling it 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 a method is spoofed with to return a specialized object, calling it 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 a method is spoofed with code, calling it enacts that code.", /* good */
-          plus: [ { of: "spoofNumber", as: function (a, b) { return a - b; } } ],
-          of: "spoofNumber", in: [ 12, 8 ], out: 4 },
-        { for: "When a method is spoofed 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 a method is not spoofed, 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 a method is spoofed using a .plus provided by a function call, the spoof is used.", /* good */
-          of: "spoofNumber",
-          plus: this.supplySingleElementSpoofArray(),
-          in: [ 12, 12 ], out: 32
-        },
-
-        { for: "When a method is spoofed 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 a method is spoofed 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: ObjectComposer, with: [] },
-        { for: "When a method is spoofed 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 a method is spoofed 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: 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 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 */
-        },
-
-        { on: ConditionalThrowTarget, 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 Error with expected message.", /* good */
-          and: "throws something", 
-          in: [ ], out: new Error("No arg provided.") },
-        { for: "When no arg is provided, but .and contains \"throw\", throws Error with expected message.", /* good */
-          and: "something throw", 
-          in: [ ], out: new Error("No arg provided.") },
-
-        { on: MixedContents, with: [ ] },
-        { for: "When .plus contains an { of, as }, .as is used for .of on the target.", /* good */
-          of: "getInstanceValueOf",
-          in: [ "first" ],
-          plus: [ { of: "first", as: 25 } ],
-          out: 25 },
-        { for: "When .plus is an empty array, original target property values are used.", /* good */
-          of: "getInstanceProduct",
-          in: [ ],
-          plus: [ ],
-          out: 6 },
-        { for: "When .plus sets several properties, those property values are used.", /* good */
-          of: "getInstanceProduct",
-          in: [ ],
-          plus: [ { of: "first", as: 12 }, { of: "second", as: 6 }, { of: "third", as: { three: 7 } } ],
-          out: 504 },
-        { for: "When .plus spoofs a static property, .as is used for .of on the topic class.", /* good */
-          of: "getStaticValueOf",
-          in: [ "fourth" ],
-          plus: [ { of: "fourth", as: 18 } ],
-          out: 18 },
-        { for: "When .plus is an empty array in a static test, original topic-class property values are used.", /* good */
-          of: "getStaticProduct",
-          in: [ ],
-          plus: [ ],
-          out: 20 },
-        { for: "When .plus spoofs several static properties, those topic-class property values are used.", /* good */
-          of: "getStaticProduct",
-          in: [ ],
-          plus: [ { of: "fourth", as: 7 }, { of: "fifth", as: "12" } ],
-          out: 84 },
-
-        { on: MixedContents, with: [ ] },
-        { for: "When .plus poly-spoofs several properties, those property values are used.", /* good */
-          of: "getInstanceProduct",
-          in: [ ],
-          plus: [ { 
-              on: MixedContents, 
-              as: [ 
-                    { of: "first", as: 37 }, 
-                    { of: "second", as: 5 }, 
-                    // Double-nested acts the same as single-nested or unnested.
-                    { of: "third", as: { three: 4 } } ] 
-                }
-            ],
-          out: 740 },
-        { for: "When .plus poly-spoofs several static properties, those topic-class property values are used.", /* good */
-          of: "getStaticProduct",
-          in: [ ],
-          plus: [ { 
-                as: [ 
-                      { of: "fourth", as: 3 }, 
-                      { of: "fifth", as: "25" } ] 
-                  }
-            ],
-          out: 75 },
-
-        { 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 } },
-
-        { on: MutationTarget, 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 } ], 
-          out: { array: [ 7, 8, 9, 10 ], tuple: { retainable: 12, changes: 40 } },
-          from: [ ] },
-        { for: "When mutated args are not collapsed forward, .in values have only been mutated once.", /* good */
-          in: [ [ 7, 8, 9 ], { retainable: 12, changes: 30 } ], 
-          out: [ [ 7, 8, 9, 10 ], { retainable: 12, changes: 40 } ], 
-          from: (target, test) => { return test.in; } },
-
-        { for: "When the tested method mutates the constructor args, the args it addresses are mutated.", /* good */
-          of: "mutateInitors",
-          in: [ ], 
-          out: { map: new Map([ [ "1", "A" ], [ "2", "B" ], [ "3", "C" ] ]), array: [ 9, 10 ] },
-          from: [ ] },
-        { for: "When constructor args are not collapsed forward, local .with values have only been mutated once.", /* good */
-          of: "mutateInitors",
-          with: [ new Map([ [ "1", "A" ], [ "2", "B" ] ]), [ 8, 9, 10 ] ],
-          in: [ ], 
-          out: [ new Map([ [ "1", "A" ], [ "2", "B" ], [ "3", "C" ] ]), [ 9, 10 ] ], 
-          from: (target, test) => { return test.with; } },
-
-        { on: MutationTarget, 
-          with: [ ], of: "replaceArg", and: "nospoof", 
-          in: [ [ () => { return "first"; } ], 0, () => { return "second"; } ] },
-        { for: "When called, replaces the first arg and adds text of original in output.", /* good */
-          out: [ () => { return "second"; }, "() => { return \"first\"; }" ] },
-        { for: "When .in args are not collapsed forward, local .in args have only been mutated once.", /* good */
-          in: [ [ () => { return "first"; } ], 0, () => { return "second"; } ], 
-          out: [ [ () => { return "second"; }, "() => { return \"first\"; }" ], 0, () => { return "second"; } ],
-          from: (target, test) => { return test.in; } },
-
-        /* Tests of sigils in .of, .plus, and .from. */
-        { on: TestableTarget, with: [ ] },
-        { for: "When .of names a static property with a leading \".\", the actual is that property's value.", /* good */
-          of: ".staticValueProp",  // Tested condition.
-          in: [ ], out: 3 },
-        { for: "When .of names an instance property with a leading \".\", the actual is that property's value.", /* good */
-          of: ".accessorProp",  // Tested condition.
-          in: [ ], out: "2nd" },
-        { for: "When .of names a static property with a trailing \":\", the actual is that property's value.", /* good */
-          of: "staticAccessorProp:",  // Tested condition.
-          in: [ ], out: "4th" },
-        { for: "When .of names an instance property with a trailing \".\", the actual is that property's value.", /* good */
-          of: "valueProp:",  // Tested condition.
-          in: [ ], out: 1 },
-        { for: "When .of names a static method with a trailing \"()\", the actual is the method's return value.", /* good */
-          of: "staticMethod()",  // Tested condition.
-          in: [ ], out: "static" },
-        { for: "When .of names an instance method with a trailing \"()\", the actual is the method's return value.", /* good */
-          of: "instanceMethod()",  // Tested condition.
-          in: [ 24, 73 ], out: "instance-method-24-73" },
-
-        { on: TestableTarget, with: [ ] },
-        { for: "When the name of a static property to spoof has a leading \".\", that property is spoofed.", /* good */
-          of: "staticValueProp",
-          plus: [ { of: ".staticValueProp", as: 37 } ],  // Tested condition.
-          in: [ ], out: 37 },
-        { for: "When the name of an instance property to spoof has a leading \".\", that property is spoofed.", /* good */
-          of: "valueProp",
-          plus: [ { of: ".valueProp", as: 49 } ],  // Tested condition.
-          in: [ ], out: 49 },
-        { for: "When the name of a static property to spoof has a trailing \":\", that property is spoofed.", /* good */
-          of: "staticAccessorProp",
-          plus: [ { of: "staticAccessorProp:", as: "28" } ],  // Tested condition.
-          in: [ ], out: "28" },
-        { for: "When the name of an instance property to spoof has a trailing \":\", that property is spoofed.", /* good */
-          of: "accessorProp",
-          plus: [ { of: "accessorProp:", as: "30" } ],  // Tested condition.
-          in: [ ], out: "30" },
-        { for: "When the name of a static method to spoof has a trailing \"()\", that method is spoofed.", /* good */
-          of: "staticMethod",
-          plus: [ { of: "staticMethod()", as: 27 } ],  // Tested condition.
-          in: [ ], out: 27 },
-        { for: "When the name of an instance method to spoof has a trailing \"()\", that method is spoofed.", /* good */
-          of: "instanceMethod",
-          plus: [ { of: "instanceMethod()", as: 15 } ],  // Tested condition.
-          in: [ ], out: 15 },
-
-        { on: TestableTarget, with: [ ] },
-        { for: "When .from is a static property with a leading \".\" in a static test, its value is used as the actual.", /* good */
-          of: "staticMethod",  // Static call but instance prop.
-          in: [ ], out: "4th", 
-          from: ".staticAccessorProp"  // Tested condition.
-        },
-        { for: "When .from is an instance property with a leading \".\" in an instance test, its value is used as the actual.", /* good */
-          of: "instanceMethod",  // Instance call but static prop.
-          in: [ ], out: "2nd", 
-          from: ".accessorProp"  // Tested condition.
-        },
-
-        { for: "When .from is a static property with a trailing \":\" in a static test, its value is used as the actual.", /* good */
-          of: "staticMethod",
-          in: [ ], out: 3, 
-          from: "staticValueProp:"  // Tested condition.
-        },
-        { for: "When .from is an instance property with a trailing \":\" in an instance test, its value is used as the actual.", /* good */
-          of: "instanceMethod", 
-          in: [ ], out: 1, 
-          from: "valueProp:"  // Tested condition.
-        },
-
-        { for: "When .from is a static property with a leading \".\" in an instance test, its value is used as the actual.", /* good */
-          of: "instanceMethod",  // Instance call but static prop.
-          in: [ ], out: "4th", 
-          from: ".staticAccessorProp"  // Tested condition.
-        },
-        { for: "When .from is an instance property with a leading \".\" in a static test, the actual's value is undefined.", /* good */
-          of: "staticMethod",  // Static call but instance prop.
-          in: [ ], out: this.undef, 
-          from: ".accessorProp"  // Tested condition.
-        },
-
-        { for: "When .from is a static property with a trailing \":\" in an instance test, its value is used as the actual.", /* good */
-          of: "instanceMethod",  // Instance call but static prop.
-          in: [ ], out: 3, 
-          from: "staticValueProp:"  // Tested condition.
-        },
-        { for: "When .from is an instance property with a trailing \":\" in a static test, the actual's value is undefined.", /* good */
-          of: "staticMethod",  // Static call but instance prop.
-          in: [ ], out: this.undef, 
-          from: "valueProp:"  // Tested condition.
-        },
-
-        { for: "When .from is a static property in an instance test, its value is used as the actual.", /* good */
-          of: "instanceMethod",  // Instance call but static prop.
-          in: [ ], out: "4th", 
-          from: "staticAccessorProp"  // Tested condition.
-        },
-        { for: "When .from is an instance property in a static test, the actual's value is undefined.", /* good */
-          of: "staticMethod",  // Static call but instance prop.
-          in: [ ], out: this.undef, 
-          from: "accessorProp"  // Tested condition.
-        },
-
-        /* Tests of .do and .undo.  All ordered pairs of tests must be preserved. */
-        { on: TestableTarget, with: [ ], of: "staticAccessorProp" },
-        { for: "When a test has .do .early but no .undo, the changes to test.on persist in the next test.", /* good */
-          do: { 
-              early: (test) => { test.on.staticAccessorProp = 64; }
-            }, 
-          in: [ ], 
-          out: 64 },
-        { for: "When the last test had a .do .early but no .undo, the changes to test.on still exist in this test.", /* good */
-          do: [ ],  // .do must be wiped out, since otherwise it collapses forward.
-          undo: (test) => { test.on.staticAccessorProp = "4th"; },
-          in: [ ], 
-          out: 64 },
-
-        { for: "When a test has .do .early and .undo, the changes to test.on are lost in the next test.", /* good */
-          do: { 
-              early: (test) => { test.on.staticAccessorProp = 33; }
-            },
-          undo: (test) => { test.on.staticAccessorProp = "4th"; },
-          in: [ ], 
-          out: 33 },
-        { for: "When the last test had a .do .early and .undo, the changes to test.on are lost in this test.", /* good */
-          do: [ ],    // .do must be wiped out, since otherwise it collapses forward.
-          undo: [ ],  // .undo must be wiped out, since otherwise it collapses forward.
-          in: [ ], 
-          out: "4th" },
-
-        { on: TestableTarget, with: [ ], of: "accessorProp" },
-        { for: "When a test has .do .late but no .undo, the changes on test.target are lost in the next test.", /* good */
-          do: { 
-              late: (test) => { test.target.accessorProp = 79; } 
-            }, 
-          in: [ ], 
-          out: 79 },
-        { for: "When the last test had .do .late but no .undo, changes on test.target are lost in this test.", /* good */
-          do: [ ],  // .do must be wiped out, since otherwise it collapses forward.
-          undo: (test) => { test.target.accessorProp = "2nd"; },
-          in: [ ], 
-          out: "2nd" },
-
-        { on: TestableTarget, with: [ ], of: "staticAccessorProp" },
-        { for: "When a test has .do .late and an .undo, the changes test.on are lost in the next test.", /* good */
-          do: { 
-              late: (test) => { test.on.staticAccessorProp = 79; } 
-            }, 
-          undo: (test) => { test.on.staticAccessorProp = "4th"; },
-          in: [ ], 
-          out: 79 },
-        { for: "When the last test had .do .late and an .undo, changes on test.on are lost in this test.", /* good */
-          do: [ ],    // .do must be wiped out, since otherwise it collapses forward.
-          undo: [ ],  // .undo must be wiped out, since otherwise it collapses forward.
-          in: [ ], 
-          out: "4th" },
-
-        { on: TestableTarget, with: [ ], of: "constructor" },
-        { for: "When a test has .do .early, .do .late, and .undo, all the changes to test.on and test.target are wiped out in the next test.", /* good */
-          do: { 
-              early: (test) => { test.on.staticAccessorProp = 47; }, 
-              late: (test) => { test.target.accessorProp = 95; } 
-            }, 
-          undo: (test) => {
-              test.on.staticAccessorProp = "4th";
-              test.target.accessorProp = "2nd";
-            },
-          in: [ ], 
-          out: true,
-          from: (target, test) => { 
-              let areChanged = TestableTarget.staticAccessorProp === 47 
-                  && test.target.accessorProp === 95;
-
-              return areChanged;
-            },
-        },
-        { for: "When the last test had .do .early, .do .late, and .undo, none of the changes exist in this test.", /* good */
-          do: [ ],    // .do must be wiped out, since otherwise it collapses forward.
-          undo: [ ],  // .undo must be wiped out, since otherwise it collapses forward.
-          in: [ ], 
-          out: false,
-          from: (target, test) => { 
-              let areChanged = TestableTarget.staticAccessorProp === 47 
-                  || test.target.accessorProp === 95;
-
-              return areChanged;
-            },
-        },
-
-        /* Tests of .just / .only.  All ordered pairs of tests must be preserved. */
-        { on: MixedContents, with: [ ], of: "getInstanceValueOf" },
-        { for: "When a test has a .just object following it, no extra test is introduced after it.", /* good */
-          in: [ "second" ], out: "2" },
-        { just: true, in: [ "third" ] },
-        { for: "When a test has a .just object before it, it includes the \"just\" isolated changes.", /* good */
-          // .in is set in the .just object.
-          out: { three: 3 }
-        },
-
-        { for: "When a test has an .only object following it, no extra test is introduced after it.", /* good */
-          in: [ "first" ], out: 1 },
-        { only: true, plus: [ { of: "getInstanceValueOf", as: 833 } ] },
-        { for: "When a test has an .only object before it, it includes the \"only\" isolated changes.", /* good */
-          in: [ "third" ], out: 833  // Spoofed value is set in the .only object.
-        },
-
-    ];
-
-    // endregion Tests
-
-}