risei 1.1.1 → 1.1.2

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

@@ -1,99 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TestStages } from "../../system/TestStages.js";
-import { TestTuple } from "../../system/TestTuple.js";
-import { TotalComparer } from "../../system/TotalComparer.js";
-
-
-class TestTopic {
-    static staticProperty = "s-prop";
-    instanceProperty = "i-prop";
-    static staticMethod() { return "s-method"; }
-    instanceMethod() { return "i-method"; }
-}
-
-/* &cruft, drop if never used */
-/* Loose variables are clearer for names of members of tested class. */
-let instanceMethod = TestTopic.prototype.instanceMethod.name;
-
-let supplyTestTuple = (actual, thrown, and, from) => {
-    let output = new TestTuple("", TestTopic, "", "", "", "", "", "", from, and);
-    output.actual = actual;
-    output.thrown = thrown;
-    
-    return output;
-}
-
-export class TestStagesTests extends ATestSource {
-    namedSetLocalTarget = TestStages.prototype.setLocalTarget.name;
-
-    tests = [
-        { on: TestStages, with: [ ] },
-
-        { of: "setLocalTarget", and: "nospoof" },
-        { for: "When test names a method, sets .localTarget to a new instance of the topic class.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "instanceMethod", "", "", "", "") ],
-          out: new TestTopic(), from: (target, test) => { return test.in[0].localTarget; } },
-        { for: "When test names a property, sets .localTarget to a nonce getting a topic-class instance's property.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "instanceProperty:", "", "", "", "") ],
-          out: { localCallable: () => { return instance[callable]; } }, from: (target, test) => { return test.in[0].localTarget; } },
-        { for: "When test names a method with \"static\", sets .localTarget to the topic class itself.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "staticMethod", "", "", "", "static") ],
-          out: TestTopic, from: (target, test) => { return test.in[0].localTarget; } },
-        { for: "When test names a property with \"static\", sets .localTarget to a nonce getting the topic-class' property.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", ".staticProperty", "", "", "", "static") ],
-          out: { localCallable: () => { return type[callable]; } }, from: (target, test) => { return test.in[0].localTarget; } },
-        { for: "When test names \"constructor\", sets .localTarget to the topic class' prototype.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "constructor", "", "", "") ],
-          out: TestTopic.prototype, from: (target, test) => { return test.in[0].localTarget; } },
-
-        { of: "setLocalCallable", and: "nospoof" },
-        { for: "When test names a method, sets .localCallable to the method's plain name.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "instanceMethod()", "", "", "", "") ],
-          out: "instanceMethod", from: (target, test) => { return test.in[0].localCallable; } },
-        { for: "When test names a property, sets .localCallable to \"localCallable\", for the nonce's method.", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "instanceProperty:", "", "", "", "") ],
-          out: "localCallable", from: (target, test) => { return test.in[0].localCallable; } },
-        { for: "When test names \"constructor()\", sets .localCallable to \"constructor\".", /* good */
-          in: [ new TestTuple("", TestTopic, "", "", "", "constructor()", "", "", "") ],
-          out: "constructor", from: (target, test) => { return test.in[0].localCallable; } },
-
-        /* &cruft, possibly rework these to use property-setting or arbitrary ops, when those are supported */
-        { of: "anyModifyActual", and: "nospoof" },
-        { for: "When .and doesn't include \"throw\" and .from is not set, test.actual remains its original value.", /* good */
-          in: [ supplyTestTuple(168) ],
-          out: 168, from: (target, test) => { return test.in[0].actual; } },
-        { for: "When .and includes \"throw\", test.actual is set to test.thrown.", /* good */
-          in: [ supplyTestTuple(210, 112, "throws") ],
-          out: 112, from: (target, test) => { return test.in[0].actual; } },
-        { for: "When .from is set, test.actual is set to the return value of a call to supplyNonReturnActual().", /* good */
-          plus: [ { of: "supplyNonReturnActual", as: 87 } ],
-          in: [ supplyTestTuple(210, "", "", "from") ],
-          out: 87, from: (target, test) => { return test.in[0].actual; } },
-
-        { of: "setLocalInitorsAndInputs", and: "nospoof" },
-        { for: "Simple objects in .with are copied to .localInitors.", /* good */
-          in: [ new TestTuple("", "", "", [ { a: "1" }, { b: 2 } ], "", "", "", "", "", "") ], 
-          out: [ { a: "1" }, { b: 2 } ],
-          from: (target, test) => { return test.in[0].localInitors; } },
-        { for: "Simple objects in .in are copied to .localInputs.", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", [ { c: 3 }, { d: "4" } ], "", "", "") ], 
-          out: [ { c: 3 }, { d: "4" } ],
-          from: (target, test) => { return test.in[0].localInputs; } },
-        { for: "Complex objects in .with are copied to .localInitors.", /* good */
-          in: [ new TestTuple("", "", "", [ [ 4, 5, 6 ], { a: "1", b: new Map([ [ "c", 8 ], [ "d", 9 ] ]) } ], "", "", "", "", "", "") ], 
-          out: [ [ 4, 5, 6 ], { a: "1", b: new Map([ [ "c", 8 ], ["d", 9 ] ]) } ],
-          from: (target, test) => { return test.in[0].localInitors; } },
-        { for: "Complex objects in .in are copied to .localInputs.", /* good */
-          in: [ new TestTuple("", "", "", "", "", "", [ { "a": 1 }, { b: new Map([ [ "c", 6 ], [ "d", 7 ] ]) } ], "", "", "") ], 
-          out: [ { "a": 1 }, { b: new Map([ [ "c", 6 ], [ "d", 7 ] ]) } ],
-          from: (target, test) => { return test.in[0].localInputs; } },
-
-        { of: "compareResults", and: "nospoof" },
-        { for: "Returns the result of calling TotalComparer . compare().", /* good */
-          plus: [ { on: TotalComparer, of: "compare", as: "spoofed" } ],
-          in: [ "A", "A" ], out: "spoofed" },
-
-    ];
-}

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

@@ -1,140 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TestTuple } from "../../system/TestTuple.js";
-import { PropertiesModel } from "../target-objects/PropertiesModel.js";
-
-/* Fixture values are more readily understood out here. */
-let nineEmpties = [ "", "", "", "", "", "", "", "", "" ];
-
-export class TestTupleTests extends ATestSource {
-    tests = [
-        { on: TestTuple, with: [ ] },
-
-        /* &cruft, replace "constructor" with property under test, once that syntax is available */
-
-        { of: "constructor", for: "When .and is \"static\", .isStaticTest returns true.", /* good */
-          in: [ ...nineEmpties, "static" ], out: true, from: "isStaticTest" },
-        { of: "constructor", for: "When .and contains \"static\", .isStaticTest returns true.", /* good */
-          in: [ ...nineEmpties, "throws static" ], out: true, from: "isStaticTest" },
-        { of: "constructor", for: "When .and doesn't contain \"static\", .isStaticTest returns false.", /* good */
-          in: [ ...nineEmpties, "throw nospoof" ], out: false, from: "isStaticTest" },
-        { of: "constructor", for: "When .and isn't a string, .isStaticTest returns false.", /* good */
-          in: [ ...nineEmpties, [] ], out: false, from: "isStaticTest" },
-
-        { of: "constructor", for: "When .and is \"static\", .isInstanceTest returns false.", /* good */
-          in: [ ...nineEmpties, "static" ], out: false, from: "isInstanceTest" },
-        { of: "constructor", for: "When .and contains \"static\", .isInstanceTest returns false.", /* good */
-          in: [ ...nineEmpties, "throws static" ], out: false, from: "isInstanceTest" },
-        { of: "constructor", for: "When .and doesn't contain \"static\", .isInstanceTest returns true.", /* good */
-          in: [ ...nineEmpties, "throw nospoof" ], out: true, from: "isInstanceTest" },
-        { of: "constructor", for: "When .and isn't a string, .isInstanceTest returns true.", /* good */
-          in: [ ...nineEmpties, [] ], out: true, from: "isInstanceTest" },
-        { of: "constructor", for: "When .of is \"constructor\", .isInstanceTest returns true even if .and contains \"static\".", /* good */
-          in: [ "", "", "", "", "", "constructor", "", "", "", "static" ], out: true, from: "isInstanceTest" },
-
-        { of: "constructor", for: "When .and is \"throw\", .isThrowTest returns true.", /* good */
-          in: [ ...nineEmpties, "throw" ], out: true, from: "isThrowTest" },
-        { of: "constructor", for: "When .and is \"throws\", .isThrowTest returns true.", /* good */
-          in: [ ...nineEmpties, "throws" ], out: true, from: "isThrowTest" },
-        { of: "constructor", for: "When .and contains \"throw\", .isThrowTest returns true.", /* good */
-          in: [ ...nineEmpties, "throw static" ], out: true, from: "isThrowTest" },
-        { of: "constructor", for: "When .and contains \"throws\", .isThrowTest returns true.", /* good */
-          in: [ ...nineEmpties, "static throws" ], out: true, from: "isThrowTest" },
-        { of: "constructor", for: "When .and doesn't contain \"throw\", .isThrowTest returns false.", /* good */
-          in: [ ...nineEmpties, "static nospoof" ], out: false, from: "isThrowTest" },
-        { of: "constructor", for: "When .and isn't a string, .isThrowTest returns false.", /* good */
-          in: [ ...nineEmpties, { } ], out: false, from: "isThrowTest" },
-
-        { on: TestTuple },
-        { of: "andStringContains", for: "When .and isn't a string, returns false for a given arg.", /* good */
-          with: [ ...nineEmpties, { } ], in: [  ], out: false, from: false },
-        { of: "andStringContains", for: "When .and is a string but doesn't contain the arg, returns false.", /* good */
-          with: [ ...nineEmpties, "no arg" ], in: [ "sought" ], out: false },
-        { of: "andStringContains", for: "When .and is a string containing the arg, returns true.", /* good */
-          with: [ ...nineEmpties, "contains sought" ], in: [ "sought" ], out: true },
-
-        { on: TestTuple, with: [ ] },
-        { of: "constructor", for: "When .of is not \"constructor\", .isConstructorTest returns false.", /* good */
-          in: [ "", "", "", "", "", "someMethod", "", "", "", "" ], out: false, from: "isConstructorTest" },
-        { of: "constructor", for: "When .of is \"constructor\", .isConstructorTest returns true.", /* good */
-          in: [ "", "", "", "", "", "constructor", "", "", "", "" ], out: true, from: "isConstructorTest" },
-        { of: "constructor", for: "When .of is \"constructor()\", .isConstructorTest returns true.", /* good */
-          in: [ "", "", "", "", "", "constructor()", "", "", "", "" ], out: true, from: "isConstructorTest" },
-
-        { of: "isRetrievalTest", plus: [ ] },
-        
-        /* Most of the false-like conditions as ninth arg (second to last). */
-        { of: "constructor", for: "When .from is `false`, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "", false, "" ], out: false, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is an empty string, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "", "", "" ], out: false, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is an empty array, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "", [], "" ], out: false, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is null, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "", null, "" ], out: false, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is undefined, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "", undefined, "" ], out: false, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is 0, .isRetrievalTest returns false.", /* good */
-          in: [ "", "", "", "", "", "", "", "",  0, "" ], out: false, from: "isRetrievalTest" },
-        
-        /* Other conditions as ninth arg (second to last). */
-        { of: "constructor", for: "When .from is a string, .isRetrievalTest returns true.", /* good */
-          in: [ "", "", "", "", "", "", "", "", "property", "" ], out: true, from: "isRetrievalTest" },
-        { of: "constructor", for: "When .from is a function, .isRetrievalTest returns true.", /* good */
-          in: [ "", "", "", "", "", "", "", "", () => { return 9; }, "" ], out: true, from: "isRetrievalTest" },
-
-
-        /* .isPropertyTest */
-        { of: "constructor", for: "When .of starts with a dot (.), .isPropertyTest returns true regardless of type analysis.", /* good */
-          in: [ "", PropertiesModel, "", "", "", ".staticMethod", "", "", "", "" ], out: true, from: "isPropertyTest" },
-        { of: "constructor", for: "When .of ends with a colon (:), .isPropertyTest returns true regardless of type analysis.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticMethod:", "", "", "", "" ], out: true, from: "isPropertyTest" },
-
-        { of: "constructor", for: "When .of is the plain name of an instance value property, .isPropertyTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "valueProp", "", "", "", "" ], out: true, from: "isPropertyTest" },
-        { of: "constructor", for: "When .of is the plain name of an instance accessor property, .isPropertyTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "accessorProp", "", "", "", "" ], out: true, from: "isPropertyTest" },
-        { of: "constructor", for: "When .of is the plain name of an instance method, .isPropertyTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "instanceMethod", "", "", "", "" ], out: false, from: "isPropertyTest" },
-
-        { of: "constructor", for: "When .of is the plain name of a static value property, .isPropertyTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticValueProp", "", "", "", "" ], out: true, from: "isPropertyTest" },
-        { of: "constructor", for: "When .of is the plain name of a static accessor property, .isPropertyTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticAccessorProp", "", "", "", "" ], out: true, from: "isPropertyTest" },
-        { of: "constructor", for: "When .of is the plain name of a static method, .isPropertyTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticMethod", "", "", "", "" ], out: false, from: "isPropertyTest" },
-
-        /* .isMethodTest */
-        { of: "constructor", for: "When .of starts with a dot (.), .isMethodTest returns false regardless of type analysis.", /* good */
-          in: [ "", PropertiesModel, "", "", "", ".instanceMethod", "", "", "", "" ], out: false, from: "isMethodTest" },
-        { of: "constructor", for: "When .of ends with a colon (:), .isMethodTest returns false regardless of type analysis.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "instanceMethod:", "", "", "", "" ], out: false, from: "isMethodTest" },
-
-        { of: "constructor", for: "When .of is the plain name of an instance value property, .isMethodTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "valueProp", "", "", "", "" ], out: false, from: "isMethodTest" },
-        { of: "constructor", for: "When .of is the plain name of an instance accessor property, .isMethodTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "accessorProp", "", "", "", "" ], out: false, from: "isMethodTest" },
-        { of: "constructor", for: "When .of is the plain name of an instance method, .isMethodTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "instanceMethod", "", "", "", "" ], out: true, from: "isMethodTest" },
-
-        { of: "constructor", for: "When .of is the plain name of a static value property, .isMethodTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticValueProp", "", "", "", "" ], out: false, from: "isMethodTest" },
-        { of: "constructor", for: "When .of is the plain name of a static accessor property, .isMethodTest returns false.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticAccessorProp", "", "", "", "" ], out: false, from: "isMethodTest" },
-        { of: "constructor", for: "When .of is the plain name of a static method, .isMethodTest returns true.", /* good */
-          in: [ "", PropertiesModel, "", "", "", "staticMethod", "", "", "", "" ], out: true, from: "isMethodTest" },
-
-        { of: "plainNameOf", and: "static" },
-        { for: "When arg contains a dot, returns the name without it.", /* good */ 
-        in: [ ".plain" ], out: "plain" },
-        { for: "When arg contains a colon, returns the name without it.", /* good */ 
-        in: [ "plain:" ], out: "plain" },
-        { for: "When arg contains parens, returns the name without them.", /* good */ 
-        in: [ "plain()" ], out: "plain" },
-        { for: "When arg contains a dot and colon, returns the name without them.", /* good */ 
-        in: [ ".plain:" ], out: "plain" },
-        { for: "When arg doesn't contain dot, colon, or parens, returns the name unchanged.", /* good */ 
-        in: [ "plain" ], out: "plain" },
-    ];
-}

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

@@ -1,184 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TotalComparer } from "../../system/TotalComparer.js";
-
-export class TotalComparerTests extends ATestSource {
-    // Used for tests of comparing objects.
-    sameObject = { a: "b" };
-
-    tests = [
-        { on: TotalComparer, with: [ ] },
-        { of: "compare" },
-
-        // Comparing booleans. //
-
-        { for: "Returns true when both args are true.", /* good */
-          in: [ true, true ], out: true },
-        { for: "Returns true when both args are false.", /* good */
-          in: [ false, false ], out: true },
-        { for: "Returns false when first arg is true and second is false.", /* good */
-          in: [ true, false ], out: false },
-        { for: "Returns false when first arg is false and second is true.", /* good */
-          in: [ false, true ], out: false },
-
-        // Comparing values. //
-
-        { for: "Returns true when args are the same value.", /* good */
-          in: [ 3, 3 ], out: true },
-        { for: "Returns false when args are different values.", /* good */
-          in: [ 3, 10 ], out: false },
-        { for: "Returns false when args are the same value, but different types.", /* good */
-          in: [ 18, "18" ], out: false },
-
-        // Comparing dates. //
-
-        { for: "Returns false when given a date and something else.", /* good */
-          in: [ new Date("November 10, 2024"), "November 10, 2024" ], 
-          out: false },
-        { for: "Returns false when dates are different values.", /* good */
-          in: [ new Date("November 10, 2024"), new Date("November 12, 2024") ], 
-          out: false },
-        { for: "Returns false when dates are the same, but times are different.", /* good */
-          in: [ new Date("November 10, 2024 3:45 AM"), new Date("November 10, 2024 6:15 PM") ], 
-          out: false },
-        { for: "Returns true when dates are the same value.", /* good */
-          in: [ new Date("November 10, 2024"), new Date("November 10, 2024") ], 
-          out: true },
-        { for: "Returns true when dates and times are the same value.", /* good */
-          in: [ new Date("November 10, 2024 8:22 PM"), new Date("November 10, 2024 8:22 PM") ], 
-          out: true },
-
-        // Comparing arrays. //
-
-        /* &cruft, tests of arrays of different JS-defined objects, like Maps */
-
-        { for: "Returns false when given an array and something else.", /* good */
-          in: [ [ 2, 4, 9 ], "text" ],
-          out: false },
-        { for: "Returns false when given different arrays.", /* good */
-          in: [ [ 2, 4, 7 ], [ 2, 5, 6 ] ],
-          out: false },
-        { for: "Returns false when `expected` array has more elements.", /* good */
-          in: [ [ 2, 4, 7, 18 ], [ 2, 4, 7 ] ],
-          out: false },
-        { for: "Returns false when `actual` array has more elements.", /* good */
-          in: [ [ 2, 4, 7 ], [ 2, 4, 7, 9 ] ],
-          out: false },
-        { for: "Returns true when given arrays with equal contents.", /* good */
-          in: [ [ 2, 4, "7", 9 ], [ 2, 4, "7", 9 ] ],
-          out: true },
-        { for: "Returns true when given arrays with identical objects.", /* good */
-          in: [ [ { a: 1, b: "2" }, { c: true, d: 3 } ], 
-                [ { a: 1, b: "2" }, { c: true, d: 3 } ] ],
-          out: true },
-        { for: "Returns false when given arrays with different objects.", /* good */
-          in: [ [ { a: 1, b: "2" }, { c: true, d: 3 } ], 
-              [ { a: 1, b: "2" }, { c: true, notD: 3 } ] ],
-          out: false },
-
-        // Comparing Maps. //
-
-        /* &cruft, tests of Maps of different JS-defined objects, like arrays */
-
-        { for: "Returns false when given a (tree'd) Map and something else.", /* good */
-          in: [ new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ),
-               "text" ],
-          out: false },
-        { for: "Returns false when given flat Maps with different contents.", /* good */
-          in: [ new Map( [ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ] ),
-                new Map( [ [ "A", 3 ], [ "B", 2 ], [ "C", 1 ] ] ) ],
-          out: false },
-        { for: "Returns false when `actual` flat Map has fewer elements.", /* good */
-          in: [ new Map( [ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ] ),
-                new Map( [ [ "A", 1 ], [ "C", 3 ] ] ) ],
-          out: false },
-        { for: "Returns false when `actual` flat Map has more elements.", /* good */
-          in: [ new Map( [ [ "A", 1 ], [ "C", 3 ] ] ),
-                new Map( [ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ] ) ],
-          out: false },
-        { for: "Returns true when given flat Maps with equal contents.", /* good */
-          in: [ new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]), 
-                new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]) ],
-          out: true },
-        { for: "Returns false when given two tree'd Maps with different contents.", /* good */
-          in: [ 
-                new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ),
-                new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "d" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "c" ] ] ) ] ] ) 
-              ],
-          out: false },
-        { for: "Returns false when given two tree'd Maps, if the `actual` is missing a leaf.", /* good */
-          in: [ new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ),
-                new Map([ [ "One", new Map( [ [ "TypeA", "a" ] ]) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ) ],
-          out: false },
-        { for: "Returns false when given two tree'd Maps, if the `actual` has an extra leaf.", /* good */
-          in: [ new Map( [ [ "One", new Map( [ [ "TypeA", "a" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ),
-                new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ) ],
-          out: false },
-        { for: "Returns true when given two Maps of Maps, if their contents are equivalent.", /* good */
-          in: [ new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ),
-                new Map( [ [ "One", new Map( [ [ "TypeA", "a" ], [ "TypeC", "c" ] ] ) ],
-                           [ "Two", new Map( [ [ "TypeB", "b" ], [ "TypeD", "d" ] ] ) ] ] ) ],
-          out: true },
-
-        // Comparing objects. //
-
-        // { on: TotalComparer, with: [ ] },
-        // { of: "compare" },
-        // { plus: [ { of: "compare", as: "fails" } ] },
-
-        /* &cruft, probably tests here with other JS-defined types, like Maps, as object members */
-
-        { for: "Returns false when given an object and a value.", /* good */
-          in: [ { seven: 7 }, 7 ],
-          out: false },
-        { for: "Returns true when given the same object for both args.", /* good */
-          in: [ this.sameObject, this.sameObject ],
-          out: true },
-        { for: "Returns false when given two flat objects, if different member values.", /* good */
-          in: [ { a: "b", d: "e" }, { a: "c", d: "e" } ],
-          out: false },
-        { for: "Returns false when given two flat objects, if `actual` missing a member.", /* good */
-          in: [ { a: "b", d: "e" }, { a: "b" } ],
-          out: false },
-        { for: "Returns false when given two flat objects, if extra `actual` member.", /* good */
-          in: [ { a: "b" }, { a: "b", d: "e" } ],
-          out: false },
-        { for: "Returns false when given two flat objects, if different members.", /* good */
-          in: [ { a: "b" }, { c: "b" } ],
-          out: false },
-        { for: "Returns true when given two flat objects, if same member values.", /* good */
-          in: [ { a: "b", d: "e" }, { a: "b", d: "e" } ],
-          out: true },
-        { for: "Returns false when given two deep objects with different object members.", /* good */
-          in: [ { a: "b", c: { d: "e" } }, { a: "b", c: { f: "g" } } ],
-          out: false },
-        { for: "Returns false when given two deep objects, if the `actual` is missing a leaf value.", /* good */
-          in: [ { a: "b", c: { d: "e", f: "g" } }, { a: "b", c: { f: "g" } } ],
-          out: false },
-        { for: "Returns false when given two deep objects, if the `actual` has an extra leaf value.", /* good */
-          in: [ { a: "b", c: { d: "e" } }, { a: "b", c: { d: "e", f: "g" } } ],
-          out: false },
-        { for: "Returns true when given two deep objects with equivalent members.", /* good */
-          in: [ { a: "b", c: { d: "e" } }, { a: "b", c: { d: "e" } } ],
-          out: true },
-        { for: "Returns false when given two flat objects with different method members.", /* good */
-          in: [ { a: "a", b: function () { return true; } },
-                { a: "a", b: function () { return false; } } ],
-          out: false },
-        { for: "Returns true when given two flat objects with equivalent method members.", /* good */
-          in: [ { a: "a", b: function () { return true; } },
-                { a: "a", b: function () { return true; } } ],
-          out: true },
-
-
-    ];
-}

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

@@ -1,74 +0,0 @@
-/**/
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-import { TotalCopier } from "../../system/TotalCopier.js";
-
-export class TotalCopierTests extends ATestSource {
-    tests = [
-        /* &cruft, when .from that addresses .actual is possible, ensure that copied objects, 
-                   including Date instances, are separate copies, using Object.is() in .from */
-
-        { on: TotalCopier, with: [ ] },
-        { of: "copy", and: "nospoof" },
-
-        { for: "When given a number, returns the same number.", /* good */
-          in: [ 21 ], out: 21 },
-        { for: "When given a string, returns the same string.", /* good */
-          in: [ "text" ], out: "text" },
-        { for: "When given a boolean, returns the same boolean.", /* good */
-          in: [ true ], out: true },
-
-        /* &cruft, re-verify this test once Date comparisons are working where needed */
-        { for: "When given a Date, returns the same Date.", /* good */
-          in: [ new Date(674831567923) ], out: new Date(674831567923) },
-
-        { for: "When given a flat object of values, returns the equivalent.", /* good */
-          in: [ { first: "a", second: 1, third: "3rd" } ], out: { first: "a", second: 1, third: "3rd" } },
-        { for: "When given a flat array of values, returns the equivalent.", /* good */
-          in: [ [ "a", 1, "c", 3 ] ], out: [ "a", 1, "c", 3 ] },
-        { for: "When given a flat Map of values, returns the equivalent.", /* good */
-          in: [ new Map( [ [ "a", 1 ], [ "c", 3 ] ] ) ], out: new Map( [ [ "a", 1 ], [ "c", 3 ] ] ) },
-        { for: "When given a flat Map of values, returns the equivalent.", /* good */
-          in: [ new Set( [ "a", 2, "E", 3.0 ] ) ], out: new Set( [ "a", 2, "E", 3.0 ] ) },
-
-        { for: "When given an array of mixed values and arrays, returns the equivalent.", /* good */
-          in: [ [ "a", /* Inner arrays: */ [ 1 ], [ "c", 3 ] ] ], out: [ "a", [ 1 ], [ "c", 3 ] ] },
-
-        { for: "When given an object of mixed values and objects, returns the equivalent.", /* good */
-          in: [ { a: "a", /* Inner objects: */ b: { one: 1 }, c: { c: "c", three: 3 } } ], 
-          out: { a: "a", b: { one: 1 }, c: { c: "c", three: 3 } } },
-
-        { for: "When given a tree of mixed arrays, objects, Maps, Sets, Dates, and values, returns the equivalent.", /* good */
-          in: [ 
-            { a: "a", 
-              b: [ 1, 2 ], 
-              c: { c: "c", 
-                   three: new Map( [ 
-                          [ "d", 6 ], 
-                          [ "g", new Date("October 14, 1999 10:05 PM") ],
-                          [ "h", 
-                              new Set( [ 
-                                  7, 8, 9, { ten: 10, eleven: [ 11, "11" ] } 
-                              ] ) 
-                          ] 
-                      ] ) } 
-             } ], 
-          out: 
-            { a: "a", 
-              b: [ 1, 2 ], 
-              c: { c: "c", 
-                   three: new Map( [ 
-                          [ "d", 6 ], 
-                          [ "g", new Date("October 14, 1999 10:05 PM") ],
-                          [ "h", 
-                              new Set( [ 
-                                  7, 8, 9, 
-                                  { ten: 10, eleven: [ 11, "11" ] } 
-                              ] ) 
-                          ] 
-                      ] ) } } 
-            },
-
-    ];
-}
-