risei 1.3.4 → 2.0.0

package/system/TestFrameChooser.js

@@ -1,54 +0,0 @@
-/**/
-
-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

@@ -1,232 +0,0 @@
-/**/
-
-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/TotalCopier.js

@@ -1,106 +0,0 @@
-/**/
-
-import { TypeIdentifier } from "./TypeIdentifier.js";
-import { Types } from "./Types.js";
-
-export class TotalCopier {
-    #identifier = new TypeIdentifier();
-
-    copy(original) /* passed */ {
-        return this.recursiveCopy(original);
-    }
-
-    recursiveCopy(original) /* verified */ {
-        /* &cruft, factor, possibly abstracting similar code, 
-                   and/or return copy only once, or similar */
-
-        /* Algorithm: First copied at current level by value if a value, by reference if 
-                      not a value; then recursively replaced at next level, and so on. */
-
-        let copy;
-        
-        let type = this.#identifier.identify(original);
-
-        if (type === Types.isArray) {
-            copy = [ ];
-            
-            // Traversal construction with recursion.
-            for (let item of original) {
-                let next = this.recursiveCopy(item);
-                copy.push(next);
-            }
-            
-            return copy;
-        }
-        
-        if (type === Types.isMap) {
-            copy = new Map();
-
-            // Traversal construction with recursion.
-            for (let entry of original.entries()) {
-                let next = this.recursiveCopy(entry);
-                copy.set(next[0], next[1]);
-            }
-            
-            return copy;
-        }
-        
-        if (type === Types.isSet) {
-            copy = new Set();
-
-            // Traversal construction with recursion.
-            for (let value of original.values()) {
-                let next = this.recursiveCopy(value);
-                copy.add(next);
-            }
-
-            return copy;
-        }
-
-        if (type === Types.isDate) {
-            copy = new Date(original);
-            return copy;
-        }
-        
-        // Actually copying isn't needed (or desirable) here, 
-        // since should always point to same thing regardless.
-        if (type === Types.isClass) {
-            copy = original;
-            return copy;
-        }
-
-        // The workaround here makes a true independent copy of the 
-        // original function, regardless of its definition style.
-        if (type === Types.isFunction) {
-            let passer = [ original ];
-            passer = [ ...passer ];
-            copy = passer[0];
-
-            return copy;
-        }
-
-        if (original instanceof Object) {
-            // If original has a prototype, it's probably a class instance, 
-            // so it's constructed, so it includes all methods and accessors.
-            let prototype = Object.getPrototypeOf(original);
-            copy = prototype !== null ? new prototype.constructor() : { };
-            
-            let keys = Object.keys(original);
-            
-            // Settable properties are added, with recursion.
-            for (let key of Object.keys(original)) {
-                let next = this.recursiveCopy(original[key]);
-                copy[key] = next;
-            }
-            
-            return copy;
-        }
-        
-        /* &cruft, other object types here */
-
-        // All object types exhausted, so this is a value, 
-        // which can be used directly for a copy.
-        copy = original;
-        return copy;
-    }
-}