Added primitive tests, improved test function

Author: Floofies

dist/lib/unitTest.js

@@ -4,7 +4,7 @@ exports.unitTest = void 0;
 // Low budget unit tests instead of Jasmine or Chai
 // Isolates between invocations. Safely contains everything that can go wrong.
 function unitTest(description, testFunction) {
-    var testLog = ["Test run: ".concat(description, ":")];
+    var testLog = ["Test: ".concat(description, ":")];
     var expectQueue = [];
     var Expectation = /** @class */ (function () {
         function Expectation(anyValue) {
@@ -15,7 +15,7 @@ function unitTest(description, testFunction) {
             var _this = this;
             expectQueue.push(function () {
                 if (expectedValue !== _this.actualValue)
-                    throw new Error("Expected ".concat(expectedValue, " but received ").concat(_this.actualValue, " instead."));
+                    throw new Error("Expected value \"".concat(expectedValue, "\" but received value \"").concat(_this.actualValue, "\" instead."));
             });
         };
         return Expectation;
@@ -24,32 +24,38 @@ function unitTest(description, testFunction) {
         return new Expectation(anyValue);
     }
     var caughtError = false;
+    var startTime = performance.now();
+    var totalTime;
     try {
         testFunction(expect);
+        totalTime = (performance.now() - startTime).toFixed(3);
         if (expectQueue.length === 0) {
-            testLog.push("	❓ Test FAIL: No expectations were defined for this test.");
+            testLog.push("	❓ Tests FAILED: No expectations were defined.");
             process.exitCode = 1;
             caughtError = true;
         }
     }
     catch (error) {
-        testLog.push("\t\u274C Test FAIL: ".concat(error.toString()));
+        totalTime = (performance.now() - startTime).toFixed(3);
+        testLog.push("\t\u274C Tests FAILED in ".concat(totalTime, "ms.: ").concat(error, "\n\t\t").concat(error.stack.replaceAll("    ", "		  ")));
         process.exitCode = 1;
         caughtError = true;
     }
+    var totalExp = 0;
     for (var _i = 0, expectQueue_1 = expectQueue; _i < expectQueue_1.length; _i++) {
         var exp = expectQueue_1[_i];
         try {
+            totalExp++;
             exp();
         }
         catch (error) {
-            testLog.push("\t\u274C Expectation FAIL: ".concat(error.toString()));
+            testLog.push("\t\u274C Tests FAILED in ".concat(totalTime, "ms.\n\t\u274C Expectation #").concat(totalExp, " FAIL: ").concat(error.toString()));
             process.exitCode = 1;
             caughtError = true;
         }
     }
     if (!caughtError)
-        testLog.push("	🟢 Test OK!");
-    console.log(testLog.join("\n"));
+        testLog.push("\t\uD83D\uDFE2 Tests PASSED in ".concat(totalTime, "ms."));
+    console.log(testLog.join("\n") + "\n");
 }
 exports.unitTest = unitTest;

src/lib/unitTest.ts

@@ -1,7 +1,7 @@
 // Low budget unit tests instead of Jasmine or Chai
 // Isolates between invocations. Safely contains everything that can go wrong.
 export function unitTest (description:string, testFunction:Function):void {
-	const testLog:Array<string> = [`Test run: ${description}:`];
+	const testLog:Array<string> = [`Test: ${description}:`];
 	const expectQueue:Array<Function> = [];
 	class Expectation {
 		actualValue;
@@ -12,36 +12,42 @@ export function unitTest (description:string, testFunction:Function):void {
 		toBe(expectedValue: any) {
 			expectQueue.push(():void => {
 				if(expectedValue !== this.actualValue)
-					throw new Error(`Expected ${expectedValue} but received ${this.actualValue} instead.`);
+					throw new Error(`Expected value "${expectedValue}" but received value "${this.actualValue}" instead.`);
 			});
 		}
 	}
 	function expect(anyValue: any):Expectation {
 		return new Expectation(anyValue);
 	}
 	let caughtError = false;
+	let startTime:number = performance.now();
+	let totalTime:string;
 	try {
 		testFunction(expect);
+		totalTime = (performance.now() - startTime).toFixed(3);
 		if(expectQueue.length === 0) {
-			testLog.push("	❓ Test FAIL: No expectations were defined for this test.");
+			testLog.push("	❓ Tests FAILED: No expectations were defined.");
 			process.exitCode = 1;
 			caughtError = true;
 		}
 	} catch (error) {
-		testLog.push(`	❌ Test FAIL: ${error.toString()}`);
+		totalTime = (performance.now() - startTime).toFixed(3);
+		testLog.push(`	❌ Tests FAILED in ${totalTime}ms.: ${error}\n		${error.stack.replaceAll("    ", "		  ")}`);
 		process.exitCode = 1;
 		caughtError = true;
 	}
+	let totalExp = 0;
 	for(const exp of expectQueue) {
 		try {
+			totalExp++;
 			exp();
 		} catch (error) {
-			testLog.push(`	❌ Expectation FAIL: ${error.toString()}`);
+			testLog.push(`	❌ Tests FAILED in ${totalTime}ms.\n	❌ Expectation #${totalExp} FAIL: ${error.toString()}`);
 			process.exitCode = 1;
 			caughtError = true;
 		}
 	}
 	if(!caughtError)
-		testLog.push("	🟢 Test OK!");
-	console.log(testLog.join("\n"));
+		testLog.push(`	🟢 Tests PASSED in ${totalTime}ms.`);
+	console.log(testLog.join("\n") + "\n");
 }

test.mjs

@@ -111,7 +111,25 @@ testObjects["Multireference"] = () => {
 	return obj;
 };
 
-console.log("💫 Starting js-testdiff unit tests:")
+console.log("💫 Starting js-testdiff unit tests:");
+unitTest("should return true when two primitives differ", function(expect) {
+	expect(testDiff(undefined, null)).toBe(true);
+	expect(testDiff(1, 2)).toBe(true);
+	expect(testDiff(true, false)).toBe(true);
+	expect(testDiff("AB", "CD")).toBe(true);
+	expect(testDiff(NaN, 1)).toBe(true);
+	expect(testDiff(Symbol("Test1"), Symbol("Test2"))).toBe(true);
+});
+unitTest("should return false when two primitives are the same", function(expect) {
+	expect(testDiff(undefined, undefined)).toBe(false);
+	expect(testDiff(1, 1)).toBe(false);
+	expect(testDiff(true, true)).toBe(false);
+	expect(testDiff("AB", "AB")).toBe(false);
+	expect(testDiff(NaN, NaN)).toBe(false);
+	const sym = Symbol("Test");
+	expect(testDiff(sym, sym)).toBe(false);
+});
+const startTime = performance.now();
 // Fun Fact: Opossums groom themselves and are quite clean.
 unitTest("should return true when two objects differ", function (expect) {
 	const testObject = testObjects["Nested Acyclic"]();
@@ -123,6 +141,7 @@ unitTest("should return true when two objects differ", function (expect) {
 	expect(testDiff(testObjects["Nested Cyclic"](), testObjects["Nested Acyclic"]())).toBe(true);
 });
 unitTest("should return false when two objects are the same", function (expect) {
+	expect(testDiff(null, null)).toBe(false);
 	expect(testDiff(testObjects["Linear Acyclic"](), testObjects["Linear Acyclic"]())).toBe(false);
 	expect(testDiff(testObjects["Linear Cyclic"](), testObjects["Linear Cyclic"]())).toBe(false);
 	expect(testDiff(testObjects["Multidimensional Acyclic"](), testObjects["Multidimensional Acyclic"]())).toBe(false);
@@ -134,4 +153,5 @@ unitTest("should ignore deep differences when traversal is disabled", function (
 	const testObject = testObjects["Nested Acyclic"]();
 	testObject[2][2][0] = "This difference should NOT be detected.";
 	expect(testDiff(testObject, testObjects["Nested Acyclic"](), false)).toBe(false);
-});
+});
+console.log(`Unit tests finished in ${(performance.now() - startTime).toFixed(3)}ms.`);