risei 1.0.4 → 1.1.1

package/system/TestFrameChooser.js

@@ -0,0 +1,54 @@
+/**/
+
+export class TestFrameChooser {
+    // Used for special test cases.
+    constructorName = "constructor";
+    staticName = "static";
+    throwName = "throw";
+    
+    frames;
+    
+    constructor(frameSource) /* verified */ {
+        this.frames = frameSource;
+    }
+
+    supplyTestFrame(test) /* passed */ {
+        // If `.and` includes "static", a call of a static member 
+        // is made, and the actual is its return value.
+        if (test.isStaticTest) {
+            if (test.isThrowTest) {
+                return this.frames.testThrowResultAfterStaticCall;
+            }
+        
+            // If .from, a static call is made, then the actual is 
+            // retrieved from a named code element or custom code.
+            if (test.isRetrievalTest) {
+                return this.frames.testCodeElementAfterStaticCall;
+            }
+
+            // Otherwise, the return value 
+            // of the static call is used.
+            return this.frames.testReturnValueOfStaticCall;
+        }
+
+        // Constructors are a special case; no second call should 
+        // be made, and actual must be retrieved from property.
+        if (test.isConstructorTest) {
+            return this.frames.testCodeElementAfterConstruction;
+        }
+        
+        if (test.isThrowTest) {
+            return this.frames.testThrowResultAfterCall;
+        }
+
+        // If .from, a call of the target is made, then the actual 
+        // is retrieved from a named code element or custom code.
+        if (test.isRetrievalTest) {
+            return this.frames.testCodeElementAfterCall;
+        }
+
+        // The most common case: the target is called, 
+        // and the actual is its return value.
+        return this.frames.testReturnValueOfCall;
+    }
+}

package/system/TestFrames.js

@@ -0,0 +1,232 @@
+/**/
+
+import { AComparer } from "./AComparer.js";
+import { TotalComparer } from "./TotalComparer.js";
+
+export class TestFrames {
+    /* &cruft : refactor to merge with same on TestFrameChooser */
+    // Used for special test cases.
+    constructorName = "constructor";
+    staticName = "static";
+
+    /* &cruft : probably refactor comparing usage */
+    /* Each test frame is bound to the calling instance of TestRunner, 
+       for now at least.  TestRunner includes #compare() for now. */
+
+    #comparer;
+
+    constructor() {
+        // Comparer is inited once for all tests, since compare() is reentrant.
+        this.#comparer = new TotalComparer();
+    }
+    
+    // The most basic test: whether a call of 
+    // a method returns the expected value.
+    testReturnValueOfCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+        
+        this.#anyPropertySetting(target, test.settables);
+
+        /* Exercising the code. */
+        test.actual = target[test.of](...test.in);  // Must use `...`.
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    testReturnValueOfStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        let unsettables = this.#anyOriginalPropertyGetting(test.type, test.settables);
+        this.#anyPropertySetting(test.type, test.settables);
+        
+        /* Exercising the code. */
+        test.actual = test.on[test.of](...test.in);  // Must use `...`.
+        
+        this.#anyPropertyUnsetting(test.type, unsettables);
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // The second-most basic test: whether a property 
+    // has the expected value after a method call.
+    testCodeElementAfterCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+
+        /* Exercising the code. */
+        target[test.of](...test.in);  // Must use `...`.
+
+        /* Retrieving. */
+        // The `actual` is a property or other code element somewhere.
+        test.actual = this.#supplyNonReturnActual(test, target);
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testCodeElementAfterStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        /* Exercising the code. */
+        test.on[test.of](...test.in);  // Must use `...`.
+        
+        /* Retrieving. */
+        test.actual = this.#supplyNonReturnActual(test);  // No `target` here.
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // The third-most basic test: whether a property has 
+    // the expected value after an object is constructed.
+    testCodeElementAfterConstruction(test) {
+        /* Groundwork. */
+        // For definition consistency, initing with test.in, not test.with.
+        let prototype = test.on.prototype;
+        
+        /* Exercising the code. */
+        let target = new prototype.constructor(...test.in);  // Must use `...`.
+
+        /* Retrieving. */
+        // The `actual` is a property or other code element somewhere.
+        test.actual = this.#supplyNonReturnActual(test, target);
+
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testThrowResultAfterCall(test) {
+        /* Groundwork. */
+        let prototype = test.on.prototype;
+        let target = new prototype.constructor(...test.with);  // Must use `...`.
+        
+        /* Exercising the code. */
+        try {
+            target[test.of](...test.in);  // Must use `...`.
+        }
+        /* Retrieving. */
+        catch (thrown) {
+            test.actual = thrown.message;
+        }
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+    
+    testThrowResultAfterStaticCall(test) {
+        /* Groundwork. */
+        /* No instance is constructed. */
+        
+        /* Exercising the code. */
+        try {
+            test.on[test.of](...test.in)  // Must use `...`.
+        }
+        catch (thrown) {
+            test.actual = thrown.message;
+        }
+        
+        /* Comparing. */
+        test.didPass = this.#compare(test.out, test.actual);
+    }
+
+    // region Dependencies of test frames
+
+    #anyOriginalPropertyGetting(target, settables) {
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        let unsettables = [ ];
+        
+        for (let settable of settables) {
+            // Not a setter tuple.
+            if (!settable.of) {
+                continue;
+            }
+            
+            // Retaining original.
+            let original = target[settable.of];
+            let unsettable = { of: settable.of, as: original };
+            unsettables.push(unsettable);
+        }
+        
+        return unsettables;
+    }
+
+    #anyPropertySetting(target, settables) {
+        // No properties to set.
+        if (!Array.isArray(settables)) {
+            return;
+        }
+    
+        for (let settable of settables) {
+            // Not a setter tuple.
+            if (!settable.of) {
+                continue;
+            }
+
+            // Actually setting property.
+            target[settable.of] = settable.as;
+        }
+    }
+    
+    #anyPropertyUnsetting(target, unsettables) {
+        // Unsetting is the same as setting, 
+        // but with tuples of original values.
+        return this.#anyPropertySetting(target, unsettables);
+    }
+
+    #compare(expected, actual) {
+        return this.#comparer.compare(expected, actual);
+    }
+
+    #supplyNonReturnActual(test, target) {
+        // When there is a .from that's a string, 
+        // the actual is the named target member.
+        if (typeof test.from === "string") {
+            // Common member host; 
+            // undefined if static.
+            let host = target;
+            
+            // When .and defines static.
+            if (this.#doesAddressStatics(test)) {
+                host = test.on;
+            }
+        
+            return host[test.from];
+        }
+        
+        // When there is a .from that's a function, 
+        // the actual is the result of calling it, 
+        // given everything that might be needed.
+        if (test.from instanceof Function) {
+            return test.from(target, test);
+        }
+
+        // When there is any other .from, the actual is the
+        // value of the code element provided as .from.
+        return test.from;
+    }
+    
+    /* &cruft : refactor to merge with same on TestFrameChooser */
+    #doesAddressStatics(test) {
+        if (typeof test.and === "string") {
+            if (test.and.includes(this.staticName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // endregion Dependencies of test frames
+
+
+}

package/system/TestResult.js

@@ -0,0 +1,187 @@
+/**/
+
+import { TotalDisplayer } from "./TotalDisplayer.js";
+
+export class TestResult {
+    // region Components
+
+    #displayer;
+
+    // endregion Components
+
+    // region Fields
+    
+    #test;
+
+    #identityText;
+    #initorsText;
+    #inputsText;
+    #expectedText;
+    #actualText;
+
+    #didPass;
+    #actual;
+    #thrown;
+
+    // endregion Fields
+
+    // region Source properties
+
+    get test() {
+        return this.#test;
+    }
+    
+    set test(value) {
+        this.#test = value;
+    }
+
+    // endregion Source properties
+    
+    // region Nature properties
+
+    get identityText() {
+        return this.#identityText;
+    }
+    
+    set identityText(value) {
+        this.#identityText = value;
+    }
+    
+    get initorsText() {
+        return this.#initorsText;
+    }
+    
+    set initorsText(value) {
+        this.#initorsText = value;
+    }
+
+    get inputsText() {
+        return this.#inputsText;
+    }
+    
+    set inputsText(value) {
+        this.#inputsText = value;
+    }
+
+    get expectedText() {
+        return this.#expectedText;
+    }
+    
+    set expectedText(value) {
+        this.#expectedText = value;
+    }
+
+    // endregion Nature properties
+
+    // region Outcome properties
+
+    get actualText() {
+        return this.#actualText;
+    }
+    
+    set actualText(value) {
+        this.#actualText = value;
+    }
+
+    get didPass() {
+        return this.#didPass;
+    }
+
+    set didPass(value) {
+        this.#didPass = value;
+    }
+
+    get anyThrow() {
+        return this.#thrown;
+    }
+
+    set anyThrow(value) {
+        this.#thrown = value;
+    }
+
+    // endregion Outcome properties
+
+    // region Construction
+
+    constructor(test) {
+        this.#test = test;
+        this.#displayer = new TotalDisplayer();
+    }
+    
+    // endregion Construction
+
+    // region Before run: setNature() and dependencies
+
+    setNature() {
+        this.#identityText = this.#calculateIdentityText();
+        this.#initorsText = this.#calculateInitorsText();
+        this.#inputsText = this.#calculateInputsText();
+        this.#expectedText = this.#calculateExpectedText();
+    }
+    
+    #calculateIdentityText() {
+        let text = `${ this.test.for } `;
+        return text;
+    }
+    
+    #calculateInitorsText() {
+        let text = this.#displayItemRow(this.test.with);
+        text = `Initors: ${ text }. `;
+        return text;
+    }
+    
+    #calculateInputsText() {
+        let text = this.#displayItemRow(this.test.in);
+        text = `Inputs: ${ text }. `;
+        return text;
+    }
+    
+    #calculateExpectedText() {
+        let text = this.#displaySingleItem(this.test.out);
+        text = `Expected: ${ text }. `;
+        return text;
+    }
+    
+    // endregion Before run: setNature() and dependencies
+    
+    // region After run: setResults() and dependencies
+
+    setResults() {
+        // Direct results.
+        this.#didPass = this.test.didPass;
+        this.#actual = this.test.actual;
+        this.#thrown = this.test.anyThrow;
+        
+        // Derived displayable results.
+        this.#actualText = this.#calculateActualText();
+    }
+
+    #calculateActualText() {
+        let text = this.#displaySingleItem(this.test.actual);
+        text = `Actual: ${ text }. `;
+        return text;
+    }
+    
+    // endregion After run: setResults() and dependencies
+
+    // region Displaying test args
+
+    #displaySingleItem(item) /* verified */ {
+        return this.#displayer.display(item);
+    }
+
+    #displayItemRow(row) /* verified */ {
+        let items = row.map(
+            x => this.#displayer.display(x)
+        );
+            
+        if (items.length === 0) {
+            return [ "\u2014" ];
+        }
+        
+        return items.join(`, `);
+    }
+    
+    // endregion Displaying test args
+
+}