risei 1.1.1 → 1.2.0

package/tests/other-tests/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "mocha-tests",
-  "version": "1.0.0",
-  "type": "module",
-  "dependencies": {
-  }
-}

package/tests/risei-tests/ASpoofingFixtureTests.rt.js

@@ -1,51 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { ASpoofingFixture } from "../../system/ASpoofingFixture.js";
-import { SpoofTuple } from "../../system/SpoofTuple.js";
-
-export class ASpoofingFixtureTests extends ATestSource {
-    // region Fixture members
-    
-    objectWithValueProperty = { something: "value-something" }
-    
-    // endregion Fixture members
-
-    tests = [
-        { on: ASpoofingFixture, with: [ ] },
-        
-        { of: "spoofMethod" },
-        { for: "When given no args, returns an empty function.", /* good */
-          in: [ ],
-          out: () => { }
-        },
-        { for: "When given a simple value, returns a nonce that returns a symbol containing that value.", /* good */
-          in: [ 12 ],
-          out: () => { return spoofOutput; }
-        },
-        { for: "When given a function, returns that function.", /* good */
-          in: [ () => { return a + b; } ],
-          out: () => { return a + b; }
-        },
-        
-        /* &cruft, restore when df version supports test.actual */
-        // { for: "When given an array of spoof tuples, returns output of spoofObjectTree().", /* good */
-        //   plus: [ { of: "spoofObjectTree", as: "spoofObjectTree-output" } ],
-        //   in: [ [ new SpoofTuple("a", "b", "c"), new SpoofTuple(1, 2, 3) ] ],
-        //   from: (target, test) => { return test.actual(); },
-        //   out: "spoofObjectTree-output"
-        // },
-
-    ];
-}
-
-// region Fixture types
-
-class ClassWithGetter {
-    get something() {
-        return "getter-something";
-    }
-}
-
-// endregion Fixture types
-

package/tests/risei-tests/MomentTests.rt.js

@@ -1,103 +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 { PolySpoofableOuter } from "../target-objects/PolySpoofableOuter.js";
-import { PolySpoofableInner } from "../target-objects/PolySpoofableInner.js";
-import { ObjectCompositionModel } from "../target-objects/ObjectCompositionModel.js";
-
-export class MomentTests 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" },
-
-    ];
-
-    // 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/risei-tests/SpoofTupleTests.rt.js

@@ -1,274 +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 { PolySpoofableOuter } from "../target-objects/PolySpoofableOuter.js";
-import { PolySpoofableInner } from "../target-objects/PolySpoofableInner.js";
-import { ObjectCompositionModel } from "../target-objects/ObjectCompositionModel.js";
-import { PropertiesModel } from "../target-objects/PropertiesModel.js";
-
-export class SelfTests extends ATestSource {
-    // region Fields
-
-    #sameObject = { a: "b" };    
-
-    // endregion Fields
-
-    // region Tests
-
-    tests = [
-        { 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 },
-
-        { of: "isPropertySpoof", and: "nospoof" },
-        { for: "When .of is the name of an instance value property, returns true.", /* good */
-          with: [ PropertiesModel, "valueProp", 7 ],
-          in: [ ], out: true },
-        { for: "When .of is the name of an instance accessor property, returns true.", /* good */
-          with: [ PropertiesModel, "accessorProp", 10 ],
-          in: [ ], out: true },
-        { for: "When .of is the name of an instance method, returns false.", /* good */
-          with: [ PropertiesModel, "instanceMethod", 15 ],
-          in: [ ], out: false },
-
-        { for: "When .of is the name of a static value property, returns true.", /* good */
-          with: [ PropertiesModel, "staticValueProp", 20 ],
-          in: [ ], out: true },
-        { for: "When .of is the name of a static accessor property, returns true.", /* good */
-          with: [ PropertiesModel, "staticAccessorProp", 25 ],
-          in: [ ], out: true },
-        { for: "When .of is the name of a static method, returns false.", /* good */
-          with: [ PropertiesModel, "staticMethod", 60 ],
-          in: [ ], out: false },
-
-    ];
-
-    // 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/risei-tests/TestFrameChooserTests.rt.js

@@ -1,74 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TestFrameChooser } from "../../system/TestFrameChooser.js";
-import { TestTuple } from "../../system/TestTuple.js";
-
-export class TestFrameChooserTests extends ATestSource {
-    tests = [
-        { on: TestFrameChooser, with: [ new SpoofTestFrameSource() ], and: "nospoof" },
-        
-        { of: "supplyTestFrame" },
-        { for: "When no other conditions apply, returns source's .testReturnValueOfCall().",  /* good */
-          plus: [ { of: "isStaticTest", as: false }, { of: "isRetrievalTest", as: false } ],
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "", "") ],  // No test-tuple properties defined.
-          out: SpoofTestFrameSource.prototype.testReturnValueOfCall
-        },
-
-        { on: TestFrameChooser, of: "supplyTestFrame", with: [ new SpoofTestFrameSource() ], and: "nospoof" },  // Wiping spoofs.
-
-        { for: "When .and is \"static\" and .from is defined, returns source's .testCodeElementAfterStaticCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "some-value", "static") ], 
-          out: SpoofTestFrameSource.prototype.testCodeElementAfterStaticCall },
-        { for: "When .and is \"static\" and .from isn't defined, returns source's .testReturnValueOfStaticCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", undefined, "static") ], 
-          out: SpoofTestFrameSource.prototype.testReturnValueOfStaticCall },
-        { for: "When .target (.of) is \"constructor\", returns source's .testCodeElementAfterConstruction().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "constructor", "", "", "", "") ],
-          out: SpoofTestFrameSource.prototype.testCodeElementAfterConstruction },
-        { for: "When not static and .from is a string, returns source's .testCodeElementAfterCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "property", "") ], 
-          out: SpoofTestFrameSource.prototype.testCodeElementAfterCall },
-        { for: "When not static and .from is a function, returns source's .testCodeElementAfterCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", () => { }, "") ], 
-          out: SpoofTestFrameSource.prototype.testCodeElementAfterCall },
-
-        { for: "When .and contains just \"throw\", returns source's .testThrowResultAfterCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "", "throw") ], 
-          out: SpoofTestFrameSource.prototype.testThrowResultAfterCall },
-        { for: "When .and contains just \"throws\", returns source's .testThrowResultAfterCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "", "throws") ], 
-          out: SpoofTestFrameSource.prototype.testThrowResultAfterCall },
-        { for: "When .and contains \"static\" and \"throw\", returns source's .testThrowResultAfterStaticCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "", "static throw") ], 
-          out: SpoofTestFrameSource.prototype.testThrowResultAfterStaticCall },
-        { for: "When .and contains \"static\" and \"throws\", returns source's .testThrowResultAfterStaticCall().", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", "", "", "", "throws static") ], 
-          out: SpoofTestFrameSource.prototype.testThrowResultAfterStaticCall },
-    ];
-
-    // region Test fixtures
-    
-    spoofTestTupleWith(factors) {
-        let spoof = new TestTuple();
-        spoof.factors = factors;
-        return spoof;
-    }
-    
-    // endregion Test fixtures
-}
-
-// region Test-fixture classes
-
-class SpoofTestFrameSource {
-    testReturnValueOfCall() { }
-    testReturnValueOfStaticCall() { }
-    testCodeElementAfterCall() { }
-    testCodeElementAfterStaticCall() { }
-    testCodeElementAfterConstruction() { }
-    testThrowResultAfterCall() { }
-    testThrowResultAfterStaticCall() { }
-}
-
-// endregion Test-fixture classes
-

package/tests/risei-tests/TestFrameTests.rt.js

@@ -1,84 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TestFrame } from "../../system/TestFrame.js";
-import { TestTuple } from "../../system/TestTuple.js";
-import { TestStages } from "../../system/TestStages.js";
-import { TestableModel } from "../target-objects/TestableModel.js";
-
-let supplyTopicTestProperty = (testArg, name) /* verified */ => {
-    let testDef = testArg.in[0];
-    return testDef[name];
-};
-
-export class TestFrameTests extends ATestSource {
-    tests = [
-        { on: TestFrame, with: [ ] },
-
-        { of: "testFrame", and: "nospoof" },
-
-        /* &cruft, remove when no longer needed */
-        // { for: "When given ..., ...",
-        //   in: [ new TestTuple() ],
-        //   out: "output not set yet",
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "name"); }
-        // },
-
-        /* &cruft, enable and finish each of these tests, getting target method to pass each */
-
-        { for: "When given an instance method to test whose output equals .out, sets .didPass to true.", /* good */
-          in: [ new TestTuple("", TestableModel, [ ], [ ], [ ], "instanceMethod", [ 1, "B" ], "instance-method-1-B", [ ], [ ] ) ],
-          out: true,
-          from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        },
-        { for: "When given an instance method to test whose output doesn't equal .out, sets .didPass to false.", /* good */
-          in: [ new TestTuple("", TestableModel, [ ], [ ], [ ], "instanceMethod", [ 1, "A" ], "instance-method-1-C", [ ], [ ] ) ],
-          out: false,
-          from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        },
-
-        // { for: "When given a static method to test whose output equals .out, sets .didPass to true.",
-        //   in: [ new TestTuple() ],
-        //   out: true,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-        // { for: "When given a static method to test whose output doesn't equal .out, sets .didPass to false.",
-        //   in: [ new TestTuple() ],
-        //   out: false,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-        //
-        // { for: "When given an instance property to test whose value equals .out, sets .didPass to true.",
-        //   in: [ new TestTuple() ],
-        //   out: true,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-        // { for: "When given an instance property to test whose value doesn't equal .out, sets .didPass to false.",
-        //   in: [ new TestTuple() ],
-        //   out: false,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-        //
-        // { for: "When given a static property to test whose value equals .out, sets .didPass to true.",
-        //   in: [ new TestTuple() ],
-        //   out: true,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-        // { for: "When given a static property to test whose value doesn't equal .out, sets .didPass to false.",
-        //   in: [ new TestTuple() ],
-        //   out: false,
-        //   from: (target, test) => { return supplyTopicTestProperty(test, "didPass"); }
-        // },
-
-        /* &cruft, also all of these:  
-                   instance method + .from name; 
-                   instance method + .from function; 
-                   static method + .from name;
-                   static method + .from function;
-                   ... same for properties... ;
-                   ... same but with spoofing... ;
-                   ... everything else needed...
-        */
-
-    ];
-}