risei 1.3.4 → 2.0.0

package/test-target-objects/PolySpoofableOuter.js

@@ -0,0 +1,52 @@
+/**/
+
+import PolySpoofableInner from "./PolySpoofableInner.js";
+
+export default class PolySpoofableOuter {
+    /* Spoofing target. */
+    #inner;
+
+    constructor() {
+        this.#inner = new PolySpoofableInner();
+    }
+    
+    /* Not intended to be spoofed, but to use spoofs. */
+    combinedNumbers(numbers) {
+        let first = this.#inner.addOrTimes(numbers);
+        let second = this.#inner.minusOrOver(numbers);
+        
+        let combined = this.combiner(first, second);
+        return combined;
+    }
+    
+    /* Spoofing target. */
+    combiner(first, second) {
+        let combined = Math.pow(first, second);
+        return combined;
+    }
+    
+    /* Not intended to be spoofed, but to use spoofs. */
+    combinedPlusHosted(numbers) {
+        let combined = this.combinedNumbers(numbers);
+        let third = this.#inner.numberHost.supplyC();
+        let fourth = this.#inner.numberHost.supplyD();
+        
+        return combined + third - fourth;
+    }
+    
+    /* Not intended to be spoofed, but to use arg with spoofs. */
+    combinedArgAAndB(inner) {
+        let first = inner.supplyA();
+        let second = inner.supplyB();
+        
+        return first + second;
+    }
+    
+    /* Not intended to be spoofed, but to use arg with spoofs. */
+    combinedArgHostedCAndD(inner) {
+        let third = inner.numberHost.supplyC();
+        let fourth = inner.numberHost.supplyD();
+        
+        return third - fourth;
+    }
+}

package/test-target-objects/PropertiesTarget.js

@@ -0,0 +1,98 @@
+/**/
+
+/* Rarely or never directly addressed elsewhere. */
+export class PropertyBase {
+    // region Static members
+
+    static staticBaseValueProp = 5;
+
+    // region .staticBaseAccessorProp
+
+    static #staticAccessedField = "6th";
+
+    static get staticBaseAccessorProp() {
+        return PropertyBase.#staticAccessedField;
+    }
+
+    static set staticBaseAccessorProp(value) {
+        PropertyBase.#staticAccessedField = value;
+    }
+
+    // endregion .staticBaseAccessorProp
+
+    static staticBaseMethod() {
+        return "base static";
+    }
+
+    // endregion Static members
+
+    // region Instance members
+
+    instanceBaseValueProp = 7;
+
+    // region .instanceBaseAccessorProp
+
+    #instanceAccessedProp = "8th";
+
+    get instanceBaseAccessorProp() {
+        return this.#instanceAccessedProp;
+    }
+
+    set instanceBaseAccessorProp(value) {
+        this.#instanceAccessedProp = value;
+    }
+
+    // endregion .instanceBaseAccessorProp
+
+    instanceBaseMethod() {
+        return "base instance";
+    }
+
+    // endregion Instance members
+}
+
+export default class PropertiesTarget extends PropertyBase {
+    // region Static members
+
+    static staticValueProp = 3;
+
+    // region .staticAccessorProp
+
+    static #staticAccessorValue = "4th";
+    
+    static get staticAccessorProp() {
+        return this.#staticAccessorValue;
+    }
+    
+    static set staticAccessorProp(value) {
+        this.#staticAccessorValue = value;
+    }
+
+    // endregion .staticAccessorProp
+
+    static staticMethod() {
+        return "static";
+    }
+
+    // endregion Static members
+
+    // region Instance members
+
+    valueProp = 1;
+
+    #accessorValue = "2nd";
+    
+    get accessorProp() {
+        return this.#accessorValue;
+    }
+
+    set accessorProp(value) {
+        this.#accessorValue = value;
+    }
+    
+    instanceMethod() {
+        return "instance";
+    }
+
+    // endregion Instance members
+}

package/test-target-objects/Returner.js

@@ -0,0 +1,7 @@
+/**/
+
+export default class Returner {
+    returnArg(arg) {
+        return arg;
+    }
+}

package/test-target-objects/Searcher.js

@@ -0,0 +1,25 @@
+/**/
+
+export default class Searcher {
+    constructor() {
+        /* No operations.*/
+    }
+
+    findLinear(sought, subject) /* passed */ {
+        // Fail path.  All edge cases return false.
+        if (subject === undefined) {
+            return false;
+        }
+
+        // Main path.
+        for (let item of subject) {
+            if (item === sought) {
+                return true;
+            }
+        }
+
+        // Never found.
+        return false;
+    }
+
+}

package/test-target-objects/Sorter.js

@@ -0,0 +1,91 @@
+/**/
+
+export default class Sorter {
+    constructor() {
+        /* No operations. */
+    }
+
+    countSort(subject) /* passed */ {
+        // To store indices for sorting to.
+        let sites = subject
+            .map(x => 0);
+
+        // Finding positions.
+        for (let at = 0; at < subject.length; at++) {
+            for (let on = 0; on < subject.length; on++) {
+                if (subject[on] < subject[at]) {
+                    sites[at]++;
+                }
+            }
+        }
+
+        // To retain reordered items.
+        let output = sites
+            .map(x => 0);
+
+        // Placing into output positions.
+        for (let at = 0; at < sites.length; at++) {
+            let to = sites[at];
+            output[to] = subject[at];
+        }
+
+        // Back to caller.
+        return output;
+    }
+
+    mergeSort(subject) /* passed */ {
+        return this.#mergeRecursor(subject);
+    }
+    
+    // region Private dependencies of mergeSort()
+
+    #mergeRecursor(subject, level) /* verified */ {
+        // Can't split for further merging.
+        if (subject.length === 1) {
+            return subject;
+        }
+
+        // Splitting for recursing at next level.
+        let { left, right } = this.#splitInHalf(subject);
+
+        // Actual recursion, calling next level directly.
+        let lefts = this.#mergeRecursor(left);
+        let rights = this.#mergeRecursor(right);
+
+        // Actually merging, then back to caller.
+        let merged = this.#merge(lefts, rights);
+        return merged;
+    }
+
+    #splitInHalf(subject) /* verified */ {
+        // These slicing args ensure no lost items.
+        let left = subject.slice(0, subject.length / 2);
+        let right = subject.slice(left.length, subject.length);
+
+        return { left, right };
+    }
+
+    #merge(lefts, rights) /* verified */ {
+        // To hold output.
+        let merged = [];
+
+        // While both sides have items, pop the lowest 
+        // of the two at the top to the output.
+        while (lefts.length > 0 && rights.length > 0) {
+            let side = lefts[0] < rights[0] ? lefts : rights;
+            let next = side.shift();
+
+            merged.push(next);
+        }
+
+        // When one side is done, pop the rest of the other.
+        let surplus = lefts.length > rights.length ? lefts : rights;
+        merged.push(...surplus);
+
+        // Back to caller.
+        return merged;
+    }
+
+    // endregion Private dependencies of mergeSort()
+
+}

package/test-target-objects/Spoofable.js

@@ -0,0 +1,36 @@
+/**/
+
+export default class Spoofable {
+    #member;
+
+    constructor(member) {
+        /* Optional member to test spoofing with SOF. */
+        if (member) {
+            this.#member = member;
+        }
+    }
+    
+    /* Member to test spoofing with SCF. */
+    spoofNumber(a, b) { return a + b; }
+    
+    /* Member to test spoofing with SCF. 
+     * Enables testing of spoofNumber() spoofing that 
+     * returns no value (the spoofed method is empty). */
+    callSpoofNumber(a, b) {
+        let result = this.spoofNumber(a, b);
+        
+        if (result === undefined) {
+            return "spoofNumber() internal call: no return value";
+        }
+        
+        return result;
+    }
+
+    /* Member to test spoofing with SCF. */
+    spoofText(t, u) { return `Texts "${ t }" and "${ u }".`; }
+    
+    /* Member to test spoofing with SOF. */
+    callMemberMethod() {
+        return member.something();
+    }
+}

package/test-target-objects/StateTarget.js

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

package/test-target-objects/StaticTarget.js

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

package/test-target-objects/TestableTarget.js

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