risei 2.0.0 → 3.0.0

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

@@ -1,313 +0,0 @@
-/**/
-
-/* Lists tuples defining tests of Counter and other model code, 
-   possibly along with any fixtures needed for those tests. */
-
-import ATestSource from "../system/ATestSource.js";  // Path must match class used in TestFinder.
-
-import Counter from "../test-target-objects/Counter.js";
-import Sorter from "../test-target-objects/Sorter.js";
-import Searcher from "../test-target-objects/Searcher.js";
-import DomTarget from "../test-target-objects/DomTarget.js";
-import StaticTarget from "../test-target-objects/StaticTarget.js";
-import StateTarget from "../test-target-objects/StateTarget.js";
-
-export default class TopicTests extends ATestSource {
-    // 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
-
-    // region Tests
-
-    tests = [
-        /* Counter . howMany() */
-        { on: Counter, 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: Counter, 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
-        },
-
-        /* Sorter */
-        { on: Sorter, 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: Searcher, 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: DomTarget, 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 StaticTarget. */
-
-        { on: StaticTarget, 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 not set and .from is an arrow function, a value " +
-               "retrieved after a static method call is the right result.", /* good */
-          of: "setStaticProperty",
-          and: [ ],
-          in: [ "was-set-to-static" ],
-          out: "was-set-to-static",
-          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.", /* good */
-          of: "setStaticProperty",
-          and: "static",
-          in: [ "static-was-set" ],
-          out: "static-was-set",
-          from: "staticProperty" 
-        },
-        { for: "When .and is not set and .from is a static property name, a value " +
-               "retrieved after a static method call is the right result.", /* good */
-          of: "setStaticProperty",
-          and: [ ],
-          in: [ "was-set-to-static" ],
-          out: "was-set-to-static",
-          from: "staticProperty" 
-        },
-
-
-        /* Tests of inline tuple-based spoofing, using CompositionModel. */
-
-        { on: StateTarget, 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 property 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
-
-}

package/xternal-tests/ASpoofingFixture.tests.js

@@ -1,242 +0,0 @@
-/**/
-
-import ASpoofingFixture from "../system/ASpoofingFixture.js";
-import SpoofDef from "../system/SpoofDef.js";
-import TotalComparer from "../system/TotalComparer.js";
-import { expect } from "chai";
-
-describe("ASpoofingFixture", () => {
-    /* All the tests here are valid as long as TotalComparer 
-       and any linked objects are passing all their tests. */
-    let comparer = new TotalComparer();
-
-    /* Some cases here are effectively impossible to test directly in self-tests, at least 
-       without complicated workarounds, because of how SpoofDef is used by Risei tests. */
-
-    describe("spoofMethod()", () => {
-        describe("Direct tests: Definition of spoofed method is compared.", () => {
-            it("Should return an empty method when not provided an arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { };
-
-                let actual = target.spoofMethod();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return an empty method when not provided undefined as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { };
-
-                let actual = target.spoofMethod(undefined);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return any whole function supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => {
-                    let sum = 6 + 5;
-                    console.log(sum);
-                };
-
-                let actual = target.spoofMethod(expected);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method naming the parameter when any non-function arg supplied.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = () => { return spoofOutput; };
-
-                let actual = target.spoofMethod(778);
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-        });
-        
-        describe("Indirect tests: Result of calling spoofed method is tested.", () => {
-            it("Should return a simple method returning any value supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = 322;
-
-                let spoofed = target.spoofMethod(322);
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any string supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = "A short text.";
-
-                let spoofed = target.spoofMethod("A short text.");
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any object supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = { first: "a", second: 2, third: "C" };
-
-                let spoofed = target.spoofMethod({ first: "a", second: 2, third: "C" });
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any specialized object supplied as arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-
-                let expected = new Map([[1, "g"], [2, "k"]]);
-
-                let spoofed = target.spoofMethod(new Map([[1, "g"], [2, "k"]]));
-                let actual = spoofed();
-
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-            
-            it("Should return a simple method returning any deep object supplied as arg", /* good */ () => {
-                let target = new ASpoofingFixture();
-                let arg = { these: { those: { the: { other: () => { return 44; } } } } };
-
-                let spoofed = target.spoofMethod(arg);
-                let actual = spoofed();
-
-                let expected = { these: { those: { the: { other: () => { return 44; } } } } };
-                
-                let comparison = comparer.compare(expected, actual);
-                expect(comparison).to.be.true;
-            });
-
-            it("Should return a simple method returning any deep spoofed object defined in the arg.", /* good */ () => {
-                let target = new ASpoofingFixture();
-                let arg = [ { of: "these.those.the.other", as: 76 } ];
-
-                let spoofed = target.spoofMethod(arg);
-                let actual = spoofed();
-
-                let expected = { these: { those: { the: { other: () => { return spoofOutput; } } } } };
-
-                let comparison = comparer.compare(actual, expected);
-                expect(comparison).to.be.true;
-            });
-
-        });
-    });
-
-    describe("spoofObjectTree()", () => {
-        it("Should return (object(empty method)) when given one part and no output.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "action" }];
-            
-            let expected = { action: () => { } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-    
-        it("Should return (object(object(empty method))) when given two parts and no output.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.action" }];
-            
-            let expected = { thing: { action: () => { } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(object(empty method)))) when given three parts and no output.", /* good */ () => {
-            let target = new ASpoofingFixture()
-            let arg = [{ of: "outer.inner.action" }];
-            
-            let expected = { outer: { inner: { action: () => { } } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(value-returning method)) when given one part and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "ten", as: 10 }];
-            
-            let expected = { ten: () => { return spoofOutput; } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(value-returning method))) when given two parts and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.eleven", as: 11 }];
-            
-            let expected = { thing: { eleven: () => { return spoofOutput; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(object(value-returning method)))) when given three parts and an output value.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "outer.inner.twelve", as: 12 }];
-            
-            let expected = { outer: { inner: { twelve: () => { return spoofOutput; } } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(string-returning method))) when given two parts and an output string.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.outputText", as: "text-output" }];
-            
-            let expected = { thing: { outputText: () => { return spoofOutput; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-        it("Should return (object(object(nonce method))) when given two parts and a nonce method.", /* good */ () => {
-            let target = new ASpoofingFixture();
-            let arg = [{ of: "thing.sumIsFourteen", as: () => { return 11 + 3; } }];
-            
-            let expected = { thing: { sumIsFourteen: () => { return 11 + 3; } } };
-
-            let actual = target.spoofObjectTree(arg);
-
-            let comparison = comparer.compare(expected, actual);
-            expect(comparison).to.be.true;
-        });
-
-    });
-});