risei 2.0.1 → 3.1.0

package/system/TestStages.js

@@ -6,26 +6,29 @@ import PropertySpoofer from "./PropertySpoofer.js";
 import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
 import TotalComparer from "./TotalComparer.js";
+import CallTypes from "./CallTypes.js";
 
 export default class TestStages {
-    /* &cruft, ? factor these to more classes */
-
-    /* These methods hold operations carried out in the test frame, 
-       or before / after all test frames, in the test runner.  
+    /* These methods hold reentrant operations carried 
+       out in the test frame in the test runner.  
        Not necessarily all test steps are found here. */
 
+    // region Components
+
     static #methodSpoofer = new MethodSpoofer();
     static #propertySpoofer = new PropertySpoofer();
     static #comparer = new TotalComparer();
 
-    anyPreTargetingGroundwork(test) /* passed */ {
+    // endregion Components
+
+    async anyPreTargetingGroundwork(test) /* passed */ {
         // Spoofing methods; properties spoofed later.
         TestStages.#methodSpoofer.spoof(test);
 
         // Arbitrary user-defined actions. 
         // Only spoofed methods available.
         if (test.doesHaveDoEarly) {
-            test.do.early(test);
+            await test.do.early(test);
         }
     }
     
@@ -35,7 +38,7 @@ export default class TestStages {
            static or instance properties. */
 
         if (test.isConstructorTest) {
-            test.target = new test.on.prototype.constructor(...test.in);
+            test.target = test.on.prototype;
             return;
         }
 
@@ -48,36 +51,49 @@ export default class TestStages {
     
     supplyLocalTarget(test) /* passed */ {
         /* Methods are called on instance / type / prototype directly.  
-           Properties are called on instance / type in a nonce. */
+           Properties are called on instance / type in a nonce.
+           Methods or properties are poly-called in a nonce. */
 
         let callable = NameAnalyzer.plainNameOf(test.method);
 
-        let localTarget = test.isMethodTest
-            ? test.target
-            : { nonce: () => { return test.target[callable]; } };
+        switch (test.callType) {
+            case CallTypes.methodMono:
+                return test.target;
+            case CallTypes.propMono:
+                return { nonce: () => { return test.target[callable]; } };
+            case CallTypes.conMono:
+                return { nonce: (...args) => { return new test.target[callable](...args); } };
+            case CallTypes.methodPoly:
+                return { nonce: this.supplyPolyMethodNonce(test, callable) };
+            case CallTypes.propPoly:
+                return { nonce: this.supplyPolyPropNonce(test, callable) };
+            case CallTypes.conPoly:
+                return { nonce: this.supplyPolyConstructorNonce(test, callable) };
+        }
 
         return localTarget;
     }
 
     supplyCallableName(test) /* passed */ {
-        /* Method under test is a method named in test, 
-           or a nonce method for a property test. */
+        /* Name is of the method named in test, 
+           or of a nonce method for prop, con, 
+           or poly-call test (of any target). */
         
-        let name = test.isMethodTest 
+        let name = test.isMethodTest && test.isMonoCallTest
             ? NameAnalyzer.plainNameOf(test.method) 
             : TestDef.nonceLocalCallableName;
 
         return name;
     }
     
-    anyPostTargetingGroundwork(test) /* passed */ {
+    async anyPostTargetingGroundwork(test) /* passed */ {
         // Spoofing properties; methods spoofed earlier.
         TestStages.#propertySpoofer.spoof(test);
 
         // Arbitrary user-defined actions. 
         // All spoofs normally available.
         if (test.doesHaveDoLate) {
-            test.do.late(test);
+            await test.do.late(test);
         }
     }
     
@@ -99,7 +115,7 @@ export default class TestStages {
         return TestStages.#comparer.compare(expected, actual);
     }
     
-    anyGroundworkReversal(test) /* passed */ {
+    async anyGroundworkReversal(test) /* passed */ {
         // Unspoofing methods and properties.
         TestStages.#methodSpoofer.unspoof(test);
         TestStages.#propertySpoofer.unspoof(test);
@@ -107,12 +123,57 @@ export default class TestStages {
         // Arbitrary user-defined operations.
         // No spoofs are available here.
         if (test.doesHaveUndo) {
-            test.undo(test);
+            await test.undo(test);
         }
     }
 
     // region Dependencies of test stages
 
+    supplyPolyMethodNonce(test, callable) /* verified */ {
+        let nonce = (...inputs) => {
+            let actuals = [];
+
+            for (let args of inputs) {
+                let local = test.target[callable](...args);
+                actuals.push(local);
+            }
+
+            return actuals;
+        };
+
+        return nonce;
+    }
+
+    supplyPolyPropNonce(test, callable) /* verified */ {
+        let nonce = (...inputs) => {
+            let actuals = [];
+        
+            for (let args of inputs) {
+                let local = test.target[callable];
+                actuals.push(local);
+            }
+        
+            return actuals;
+        };
+
+        return nonce;
+    }
+
+    supplyPolyConstructorNonce(test, callable) /* verified */ {
+        let nonce = (...inputs) => {
+            let actuals = [];
+
+            for (let args of inputs) {
+                let local = new test.target[callable](...args);
+                actuals.push(local);
+            }
+
+            return actuals;
+        };
+
+        return nonce;
+    }
+
     supplyNonReturnActual(test) /* passed */ {
         // When .from is a string, the actual 
         // is the named target or type member.
@@ -125,28 +186,26 @@ export default class TestStages {
                 ? test.target
                 : test.type;
 
+            // Constructors are different.
+            host = test.isConstructorTest
+                ? test.actual
+                : host;
+
             // Actually supplying value.
             return host[name];
         }
 
-        /* &cruft, possibly change all .from syntax 
-                   to ? (actual, test), or ? (test) */
         // 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) {
             // Actually supplying value.
-            return test.from(test.target, test);
+            return test.from(test, test.actual);
         }
 
         // Only property names and functions make sense to support.
         throw new Error("The test.from value was not a usable type.  It must be either a property name or a function to work.");
     }
     
-    #compare(expected, actual) /* verified */ {
-        return this.#comparer.compare(expected, actual);
-    }
-
     // endregion Dependencies of test stages
-
 }

package/system/TestSummary.js

@@ -1,37 +1,38 @@
-/**/
-
-export default class TestSummary {
-    #summary;
-    #allDidPass;
-    #anyWereRun;
-    
-    get summary() {
-        return this.#summary;
-    }
-    
-    set summary(value) {
-        this.#summary = value;
-    }
-    
-    get allDidPass() {
-        return this.#allDidPass;
-    }
-    
-    set allDidPass(value) {
-        this.#allDidPass = value;
-    }
-    
-    get anyWereRun() {
-        return this.#anyWereRun;
-    }
-    
-    set anyWereRun(value) {
-        this.#anyWereRun = value;
-    }
-    
-    constructor(summary, allDidPass, anyWereRun) {
-        this.summary = summary;
-        this.allDidPass = allDidPass;
-        this.anyWereRun = anyWereRun;
-    }
-}
+/**/
+
+export default class TestSummary {
+    #summary;
+    #allDidPass;
+    #anyWereRun;
+
+    #anyThrows;
+    #anyTroubles;
+    
+    get summary() {
+        return this.#summary;
+    }
+    
+    get allDidPass() {
+        return this.#allDidPass;
+    }
+    
+    get anyWereRun() {
+        return this.#anyWereRun;
+    }
+    
+    get anyThrows() {
+        return this.#anyThrows;
+    }
+
+    get anyTroubles() {
+        return this.#anyTroubles;
+    }
+
+    constructor(summary, allDidPass, anyWereRun, anyThrows, anyTroubles) {
+        this.#summary = summary;
+        this.#allDidPass = allDidPass;
+        this.#anyWereRun = anyWereRun;
+        this.#anyThrows = anyThrows;
+        this.#anyTroubles = anyTroubles;
+    }
+}

package/system/TotalComparer.js

@@ -1,6 +1,7 @@
 /**/
 
 import ATestSource from "./ATestSource.js";
+import ObjectAnalyzer from "./ObjectAnalyzer.js";
 
 export default class TotalComparer {
     constructor() {
@@ -65,26 +66,31 @@ export default class TotalComparer {
         if (!(actual instanceof Object)) {
             return false;
         }
-        
-        // There must not be any extra members 
-        // of `actual`, its own or inherited.
-        for (let propertyName in actual) {
-            if (!(propertyName in expected)) {
-                return false;
-            }
+
+        let expectedNames = ObjectAnalyzer.allProperties(expected);
+        let actualNames = ObjectAnalyzer.allProperties(actual);
+
+        // Objects with different numbers of properties can't be the same.
+        if (expectedNames.length !== actualNames.length) {
+            return false;
         }
 
-        // All members of `expected`, its own or inherited, 
-        // must exist in `actual` and match it recursively.
-        for (let propertyName in expected) {
-            // Members present must match.
-            if (!(propertyName in actual)) {
+        // O(n) algorithm covers all other cases, including recursion.
+        for (let at = 0; at < expectedNames.length; at++) {
+            // Objects with differing property names can't be the same.
+            if (expectedNames[at] !== actualNames[at]) {
                 return false;
             }
-            
+
+            // Same property name in both objects.
+            let name = expectedNames[at];
+
+            // Individual props, or their throws if getters that fail.
+            let paired = this.#retrieveExpectedAndActualProps(name, expected, actual);
+
             // Cross-recursion.
-            let areEqual = this.#recurse(expected[propertyName], actual[propertyName]);
-            
+            let areEqual = this.#recurse(paired.expected, paired.actual);
+
             // Exit only at first false.
             switch (areEqual) {
                 case true: continue;
@@ -95,7 +101,32 @@ export default class TotalComparer {
         // No mismatched or missing found.
         return true;
     }
-    
+
+    /* Dependency of #recurseOverObjects(). */
+    #retrieveExpectedAndActualProps(name, expected, actual) {
+        /* Expected and actual prop values are retrieved in individual 
+           try-catches because getters may fail, and this way, 
+           any fails can be compared as indicators of overall state. */
+
+        let paired = { };
+
+        try {
+            paired.expected = expected[name];
+        }
+        catch (thrown) {
+            paired.expected = thrown;
+        }
+
+        try {
+            paired.actual = actual[name];
+        }
+        catch (thrown) {
+            paired.actual = thrown;
+        }
+
+        return paired;
+    }
+
     #recurseOverMaps(expected, actual) /* verified */ {
         // Both must be Maps.
         if (!(actual instanceof Map)) {
@@ -229,7 +260,7 @@ export default class TotalComparer {
     }
 
     #compareFunctions(expected, actual) /* verified */ {
-        // `expected` is already known to be a function / method.
+        // 'expected' is already known to be a function / method.
         if (!(actual instanceof Function)) {
             return false;
         }
@@ -253,6 +284,7 @@ export default class TotalComparer {
     }
 
     #compareDates(expected, actual) /* verified */ {
+        // 'expected' is already known to be a Date.
         if (!(actual instanceof Date)) {
             return false;
         }
@@ -261,6 +293,11 @@ export default class TotalComparer {
     }
 
     #compareErrors(expected, actual) /* verified */ {
+        // 'expected' is already known to be an Error.
+        if (!(actual instanceof Error)) {
+            return false;
+        }
+
         /* Compares Errors and subclasses accurately apart from .stack, 
            which is ignored because it rarely makes sense to compare it. */
 

package/system/TotalDisplayer.js

@@ -3,23 +3,27 @@
 import TypeIdentifier from "./TypeIdentifier.js";
 import Types from "./Types.js";
 import ATestSource from "./ATestSource.js";
+import ObjectAnalyzer from "./ObjectAnalyzer.js";
 
 export default class TotalDisplayer {
-    display(value) /* good */ {
+    static defaultToString = "[object Object]";
+
+    display(value) /* passed */ {
         let typeId = TypeIdentifier.identify(value);
 
         switch (typeId) {
+            case Types.isUndefined: return this.displayUndefined(value);
             case Types.isValue: return this.displayValue(value);
             case Types.isString: return this.displayString(value);
             case Types.isArray: return this.displayArray(value);
             case Types.isMap: return this.displayMap(value);
             case Types.isSet: return this.displaySet(value);
+            case Types.isFile: return this.displayFile(value);
             case Types.isError: return this.displayError(value);
             case Types.isClass: return this.displayClass(value);
             case Types.isFunction: return this.displayFunction(value);
             case Types.isObject: return this.displayObject(value);
             case Types.isDate: return this.displayValue(value);
-            case Types.isUndefined: return this.displayUndefined(value);
             case Types.isUndefSymbol: return this.displayUndefined(value);
             case Types.isNull: return this.displayNull(value);
         }
@@ -82,6 +86,10 @@ export default class TotalDisplayer {
         return output;
     }
 
+    displayFile(value) /* passed */ {
+        return `File{name:"${ value.name }",size:${ value.size }}`;
+    }
+
     displayError(value) /* passed */ {
         // Subtype can't be found with typeof.
         let type = value.name;
@@ -125,13 +133,28 @@ export default class TotalDisplayer {
     }
 
     displayObject(value) /* passed */ {
+        // If a custom toString() exists, use its output.
+        let asString = value.toString();
+
+        if (asString !== TotalDisplayer.defaultToString) {
+            return asString;
+        }
+
         // Each property of the object is handled individually.
         let items = [ ];
 
-        for (let p in value) {
-            // Cross-recursion.
-            let item = this.display(value[p]);
-            items.push(`${ p }:${ item }`);
+        let props = ObjectAnalyzer.allProperties(value);
+
+        for (let prop of props) {
+            // Cross-recursion.  Try-catch because getters can fail.
+            try { 
+                let item = this.display(value[prop]);
+                items.push(`${ prop }:${ item }`);
+            }
+            catch (e) 
+            {
+                items.push(`${ prop }:(threw)`);
+            }
         }
 
         // Properties are all listed together.

package/system/TypeAnalyzer.js

@@ -45,40 +45,131 @@ export default class TypeAnalyzer {
     /* Returns true if instance or static member is a method.
        Returns false if member is any kind of property. */
     static isMethodMember(type, name) /* passed */ {
-        /* A method is always defined either on a type or 
-           its prototype, even if declared on a superclass. */
+        return !TypeAnalyzer.isPropertyMember(type, name);
+    }
 
-        try {
-            let anyInstanceType = TypeIdentifier.identify(type.prototype[name]);
-            let anyStaticType = TypeIdentifier.identify(type[name]);
+    /* Returns true if instance or static member is a property 
+       (value or accessor).  Returns false if member is a method. */
+    static isPropertyMember(type, name) /* passed */ {
+        /* Type and supertypes are tested directly for static props, 
+           and their definition texts are read for instance props. */
 
-            /* Excludes class "functions", which are not methods. */
-            let isInstanceMethod = anyInstanceType === Types.isFunction;
-            let isStaticMethod = anyStaticType === Types.isFunction;
+        let isProperty = this.#typeChainIncludesAsProperty(type, name);
 
-            /* Returns net method-ness; if not found at all, a property 
-               is assumed (true as long as the member exists at all.) */
-            return isInstanceMethod || isStaticMethod;
-        }
-        catch (thrown) {
-            /* If private fields are used behind public accessor properties, 
-               there's a characteristic message which shows it's not a method.  
-               It may be a property returning a function, but not a method. */
-            if (thrown.message.startsWith(TypeAnalyzer.accessorOfPrivate)) {
-                return false;
+        return isProperty;
+    }
+
+    // region Dependencies of isPropertyMember()
+    
+    static #typeChainIncludesAsProperty(type, name) /* verified */ {
+        let prototype = type.prototype;
+
+        // Rootward traversal of the prototype chain.
+        while (prototype !== null) {
+            // Type is needed, rather than prototype.
+            type = prototype.constructor;
+
+            // First line finds any static props; second, any instance props.
+            let isProperty 
+                = TypeAnalyzer.#typeDefinitionIncludesAsProperty(type, name) 
+                || TypeAnalyzer.#typeTextContainsNameAsProperty(type, name);
+
+            // Was found as static or instance.
+            if (isProperty) {
+                return true;
             }
 
-            /* Other throws are unpredictable and mean there's a problem. */
-            throw thrown;
+            // Parent class, or null at root.
+            prototype = Object.getPrototypeOf(prototype);
         }
 
-        /* Probably never reached.  No previous throw, but some unknown problem. */
-        throw new Error("Unable to determine method vs. property state.");
+        // Never found.
+        return false;
     }
 
-    /* Returns true if instance or static member is a property 
-       (value or accessor).  Returns false if member is a method. */
-    static isPropertyMember(type, name) /* passed */ {
-        return !TypeAnalyzer.isMethodMember(type, name);
+    static #typeDefinitionIncludesAsProperty(type, name) /* verified */ {
+        let named = Object.getOwnPropertyDescriptor(type, name);
+
+        // If not found, try parent.
+        if (named === undefined) {
+            return false;
+        }
+
+        // Members with getters are properties.
+        if (named.get !== undefined) {
+            return true;
+        }
+
+        // Members with function values are methods.
+        if (named.value instanceof Function) {
+            return false;
+        }
+
+        // Members with any other values are properties.
+        if (named.value !== undefined) {
+            return true;
+        }
+    }
+
+    static #typeTextContainsNameAsProperty(type, name) /* verified */ {
+        let text = type.toString();
+
+        // Instance properties are always defined as 'name =', 
+        // 'name;', or 'get name()' at the start of a line.
+        let valueRegex = new RegExp(`^\\s*${ name }\\s*[=;]`, "m");
+        let accessorRegex = new RegExp(`^\\s*get ${ name }\\(\\)`, "m");
+
+        // Conditional execution of the second test() call.
+        let doesContain = valueRegex.test(text) || accessorRegex.test(text);
+        return doesContain;
+    }
+    
+    // endregion Dependencies of isPropertyMember()
+    
+    static allGetters(type) /* passed */ {
+        return TypeAnalyzer.#allTypeChainGetters(type);
+    }
+    
+    // region Dependencies of allGetters()
+    
+    static #allTypeChainGetters(type) /* verified */ {
+        let output = [];
+
+        let prototype = type.prototype;
+
+        // Rootward traversal of the prototype chain.
+        while (prototype !== null) {
+            // Type is needed, rather than prototype.
+            type = prototype.constructor;
+
+            // Any getters at this level.
+            let local = TypeAnalyzer.#gettersInTypeText(type);
+            output.push(...local);
+
+            // Parent class, or null at root.
+            prototype = Object.getPrototypeOf(prototype);
+        }
+
+        return output;
+    }
+    
+    static #gettersInTypeText(type) /* verified */ {
+        let text = type.toString();
+
+        // At start of line's text, get + name + ().
+        let getterRegex = /^\s*get\s+(\w+)\(\)/gm;
+
+        // All getters and their names 
+        // as an array of arrays.
+        let raw = text.matchAll(getterRegex);
+        raw = [ ...raw ];
+
+        // First capturing group is name.
+        let names = raw.map(x => x[1]);
+
+        return names;
     }
+    
+    // endregion Dependencies of allGetters()
+    
 }

package/system/TypeIdentifier.js

@@ -14,27 +14,31 @@ export default class TypeIdentifier {
             if (Array.isArray(value)) {
                 return Types.isArray;
             }
-        
+
             if (value instanceof Map) {
                 return Types.isMap;
             }
-            
+
             if (value instanceof Set) {
                 return Types.isSet;
             }
-            
+
+            if (value instanceof File) {
+                return Types.isFile;
+            }
+
             if (value instanceof Date) {
                 return Types.isDate;
             }
-            
+
             if (value instanceof Error) {
                 return Types.isError;
             }
-            
+
             if (value === null) {
                 return Types.isNull;
             }
-            
+
             return Types.isObject;
         }
 

package/system/Types.js

@@ -9,6 +9,7 @@ export default class Types {
     static isObject = "object";
     static isMap = "map";
     static isSet = "set";
+    static isFile = "file";
     static isFunction = "function";
     static isClass = "class";
     static isDate = "date";