risei 1.1.1 → 1.1.2

package/tests/topic-tests/TopicTests.outward-rt.js

@@ -1,354 +0,0 @@
-/**/
-
-/* Lists tuples defining tests of CountModel and other model code, 
-   possibly along with any fixtures needed for those tests. */
-
-import { ATestSource } from "../../node_modules/risei/public/javascript/ATestSource.js";
-
-import { CountModel } from "../target-objects/CountModel.js";
-import { SortModel } from "../target-objects/SortModel.js";
-import { SearchModel } from "../target-objects/SearchModel.js";
-import { DomModel } from "../target-objects/DomModel.js";
-import { StaticModel } from "../target-objects/StaticModel.js";
-import { CompositionModel } from "../target-objects/CompositionModel.js";
-import { StateModel } from "../target-objects/StateModel.js";
-
-export class TopicTests extends ATestSource {
-    // region Tests
-
-    tests = [
-        /* CountModel . howMany() */
-        { on: CountModel, with: [], of: "howMany" },
-
-        {
-            for: "Returns the right number for a repeated single character.", /* good */
-            in: [ "a b c a b c", "a" ], out: 2
-        },
-        {
-            for: "Returns the right number for a repeated string.", /* good */
-            in: [ "more text with more words", "more" ], out: 2
-        },
-        {
-            for: "Returns one for a target once at the start.", /* good */
-            in: [ "a b c d e f", "a" ], out: 1
-        },
-        {
-            for: "Returns one for a target once in the middle.", /* good */
-            in: [ "x b c a b c", "a" ], out: 1
-        },
-        {
-            for: "Returns one for a target once at the end.", /* good */
-            in: [ "a b x a b c", "c" ], out: 1
-        },
-
-        /* Trying out .type-restatement syntax. */
-        { on: CountModel, with: [], of: "howMany" },
-
-        {
-            for: "Returns one for a multi-character target present once.", /* good */
-            in: [ "some text with words", "text" ], out: 1
-        },
-        {
-            for: "When target is not present in subject, returns zero.", /* good */
-            in: [ "a b c a b c", "x" ], out: 0
-        },
-
-        /* Trying out .method-restatement syntax. */
-        { of: "howMany" },
-
-        {
-            for: "When subject is empty, returns zero.", /* good */
-            in: [ "", "a" ], out: 0
-        },
-        {
-            for: "When target is empty, returns zero.", /* good */
-            in: [ "something", "" ], out: 0
-        },
-        {
-            for: "When both args are empty, returns zero.", /* good */
-            in: [ "", "" ], out: 0
-        },
-        {
-            for: "When only subject is provided, returns zero.", /* good */
-            in: [ "something" ], out: 0
-        },
-        {
-            for: "When no arguments are provided, returns zero.", /* good */
-            in: [], out: 0
-        },
-        {
-            for: "When subject is null, returns zero.", /* good */
-            in: [ null, "a" ], out: 0
-        },
-        {
-            for: "When target is null, returns zero.", /* good */
-            in: [ "something", null ], out: 0
-        },
-        {
-            for: "When both args are null, returns zero.", /* good */
-            in: [ null, null ], out: 0
-        },
-
-        /* SortModel */
-        { on: SortModel, with: [] },
-
-        /* .countSort() */
-        {
-            for: "When given an unsorted array, returns the values sorted.", /* good */
-            of: "countSort",
-            in: [ [ 3, 2, 6, 4, 1, 5 ] ], out: [ 1, 2, 3, 4, 5, 6 ]
-        },
-        {
-            for: "When given a sorted array, returns the same sort order.", /* good */
-            in: [ [ 2, 4, 6, 8, 9, 10 ] ], out: [ 2, 4, 6, 8, 9, 10 ]
-        },
-
-        /* .mergeSort() */
-        {
-            for: "When given an unsorted array, returns the values sorted.", /* good */
-            of: "mergeSort",
-            in: [ [ 3, 2, 6, 4, 1, 5 ] ], out: [ 1, 2, 3, 4, 5, 6 ]
-        },
-        {
-            for: "Sorts correctly when all stages are divisible by two.", /* good */
-            in: [ [ 3, 2, 6, 4, 1, 5, 8, 7 ] ],
-            out: [ 1, 2, 3, 4, 5, 6, 7, 8 ]
-        },
-
-        {
-            for: "Sorts interval values correctly.",
-            of: "mergeSort",
-            in: this.getIntervalValues(3, 10, true, true), out: this.getIntervalValues(3, 10, false, false)
-        },
-
-        { on: SearchModel, with: [], of: "findLinear" },
-
-        {
-            for: "When sought is present in subject, returns true.", /* good */
-            in: [ 3, [ 6, 2, 8, 1, 4, 4, 3, 7, 2, 9, 11 ] ], out: true
-        },
-        {
-            for: "When sought is not present, returns false.", /* good */
-            in: [ 10, [ 6, 2, 8, 1, 4, 4, 3, 7, 2, 9, 11 ] ], out: false
-        },
-        {
-            for: "When no subject is provided, returns false.", /* good */
-            in: [ 7 ], out: false
-        },
-        {
-            for: "When no sought is provided, returns false.", /* good */
-            in: [ undefined, [ 3, 8, 10 ] ], out: false
-        },
-        {
-            for: "When no args are provided, returns false.", /* good */
-            in: [], out: false
-        },
-
-        { on: DomModel, with: [ "spoof-id" ] },
-
-        {
-            for: "When an instance is inited, `id` arg is set as .id.", /* good */
-            of: "constructor",
-            plus: [ { of: "domNodeFrom" } ],
-            in: [ "arg-id" ],
-            out: "arg-id",
-            from: "id"
-        },
-        {
-            for: "When an instance is inited, return value from domNodeFrom() is set as .node.", /* good */
-            of: "constructor",
-            plus: [ { of: "domNodeFrom", as: "returned-node" } ],
-            in: [ "arg-node" ],
-            out: "returned-node",
-            from: "node"
-        },
-        {
-            for: "When changeDomItem() is called, its arg is the new .id.", /* good */
-            of: "changeDomItem",
-            plus: [ { of: "domNodeFrom" } ],
-            in: [ "new-id" ],
-            out: "new-id",
-            from: "id"
-        },
-        {
-            for: "When changeDomItem() is called, domNodeFrom() changes .node based on the arg.", /* good */
-            of: "changeDomItem",
-            plus: [ { of: "domNodeFrom", as: (arg) => { return arg; } } ],
-            in: [ "new-node" ],
-            out: "new-node",
-            from: "node"
-        },
-
-        /* Tests of inline tuple-based spoofing for static methods, using StaticModel. */
-
-        { on: StaticModel, with: [] },
-
-        { for: "When a call is made to a static method with .and set, " +
-               "that method is invoked to return the right result.", /* good */
-          of: "multiplyThenDivide",
-          and: "static",
-          in: [ 3, 4, 2 ],
-          out: 6 /* (3 *4) ÷2 */  },
-        { for: "When .and is set and .from is an arrow function, a value " +
-               "retrieved after a static method call is the right result.", /* good */
-          of: "setStaticProperty",
-          and: "static",
-          in: [ "static-was-set" ],
-          out: "static-was-set",
-          from: (target, test) => { return test.on.staticProperty; } 
-        },
-        { for: "When .and is set and .from is a static property name, a value " +
-               "retrieved after a static method call is the right result.", /*  */
-          of: "setStaticProperty",
-          and: "static",
-          in: [ "static-was-set" ],
-          out: "static-was-set",
-          from: "staticProperty" 
-        },
-
-        /* Tests of inline tuple-based spoofing, using CompositionModel. */
-
-        { on: CompositionModel },
-
-        {
-            for: "When objects are spoofed for call, values from spoofs are used.", /* good */
-            with: [
-                { of: "supplyValue", as: 2 },
-                { of: "supplyValue", as: 3 }
-            ],
-            of: "multiplyValues",
-            in: [
-                { of: "supplyValue", as: 4 },
-                { of: "supplyValue", as: 5 }
-            ],
-            out: 120  // 2 * 3 * 4 * 5 
-        },
-        {
-            for: "When only some objects are spoofed, spoofing still works correctly.", /* good */
-            with: [
-                { supplyValue: () => { return 3; } },  // Custom object, not spoof definition.
-                { of: "supplyValue", as: 5 }           // Spoof definition. 
-            ],
-            of: "multiplyValues", 
-            in: [
-                { of: "supplyValue", as: 7 },          // Spoof definition.
-                { supplyValue: () => { return 1; } }   // Custom object, not spoof definition.
-            ],
-            out: 105  // 3 * 5 * 7 ( * 1 ) 
-        },
-        {
-            for: "When no objects are spoofed, spoofing still works correctly.", /* good */
-            with: [
-                { supplyValue: () => { return 11; } },  // Custom object, not spoof definition.
-                { supplyValue: () => { return 1; } }    // Custom object, not spoof definition.
-            ],
-            of: "multiplyValues", 
-            in: [
-                { supplyValue: () => { return 12; } },  // Custom object, not spoof definition.
-                { supplyValue: () => { return 1; } }    // Custom object, not spoof definition.
-            ],
-            out: 132  // 11 * 12 ( * 1 * 1 ) 
-        },
-        {
-            for: "When given objects, spoof definitions, and values, spoofing still works correctly.", /* good */ 
-            with: [
-                { supplyValue: () => { return 20; } },  // Custom object, not spoof definition.
-                { of: "supplyValue", as: 21 },          // Spoof definition.
-                22                                      // Value.
-            ],
-            of: "addValues",
-            in: [
-                { of: "supplyValue", as: 23 },          // Spoof definition.
-                24,                                     // Value.
-                { supplyValue: () => { return 25; } },  // Custom object, not spoof definition.
-                26                                      // Value.
-            ],
-            out: 161  // 20 + 21 + 22 + 23 + 24 + 25 + 26 
-        },
-
-        { on: StateModel, with: [] },
-
-        { for: "When instance is constructed, .numberState is 1.", /* good */
-          of: "constructor",
-          from: "numberState",
-          in: [ ], out: 1 },
-        { for: "When instance is constructed, .textState is \"1\".", /* good */
-          of: "constructor",
-          from: "textState",
-          in: [ ], out: "1" },
-        { for: "When number is set, .numberState propery has the chosen value.", /* good */
-          of: "setNumberState",
-          from: "numberState",
-          in: [ 77 ], out: 77 },
-        { for: "When text is set, .textState has the chosen value.", /* good */
-          of: "setTextState",
-          from: "textState",
-          in: [ "This is some text." ], out: "This is some text." },
-
-        { of: "changeNumberAndTextState" },
-
-        { for: "When text and number are changed, .numberState matches the number arg.", /* good */
-          from: "numberState",
-          in: [ 2, "a phrase" ], out: 2 },
-        { for: "When a change is made with property test.from before a test with .from of [], property is used.", /* good */
-          from: "textState",
-          in: [ 2, "a phrase" ], out: "a phrase" },
-        { for: "When a change is made and test.from is [], not a retrieval, the return value is used.", /* good */
-          from: [ ],
-          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
-        { for: "When a change is made with property test.from before a test with .from of { }, property is used.", /* good */
-          from: "numberState",
-          in: [ 2, "a phrase" ], out: 2 },
-        { for: "When a change is made and test.from is { }, not a retrieval, the return value is used.", /* good */
-          from: { },
-          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
-        { for: "When a change is made with property test.from before a test with .from of false, property is used.", /* good */
-          from: "textState",
-          in: [ 2, "a phrase" ], out: "a phrase" },
-        { for: "When a change is made and test.from is false, not a retrieval, the return value is used.", /* good */
-          from: false,
-          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } },
-        { for: "When a change is made with property test.from before a test with .from of \"\", property is used.", /* good */
-          from: "numberState",
-          in: [ 2, "a phrase" ], out: 2 },
-        { for: "When a change is made and test.from is \"\", not a retrieval, the return value is used.", /* good */
-          from: "",
-          in: [ 2, "a phrase" ], out: { number: 2, text: "a phrase" } }
-
-    ];
-
-    // endregion Tests
-
-    // region Local test fixtures
-    
-    getIntervalValues(interval, count, doPermute, doWrap) {
-        let values = [];
-
-        for (let of = 0; of < count; of++) {
-            let value = interval * of;
-            values.push(value);
-        }
-
-        if (doPermute) {
-            /* Permuting order by pairing each value with a random value, 
-               sorting on the random values, then dropping those again. */
-
-            let pairings = [];
-
-            for (let at = 0; at < values.length; at++) {
-                pairings.push({ value: values[at], order: Math.random() });
-            }
-
-            pairings.sort((a, b) => a.order - b.order);
-            values = pairings.map(x => x.value);
-        }
-
-        if (doWrap) {
-            return [ values ];
-        }
-
-        return values;
-    }
-
-    // endregion Local test fixtures
-}