risei 2.0.0 → 2.0.1

package/xternal-tests/TotalComparer.tests.js

@@ -1,1055 +0,0 @@
-/**/
-
-import TotalComparer from "../system/TotalComparer.js";
-import Spoofable from "../test-target-objects/Spoofable.js";
-import { expect } from "chai";
-
-describe("TotalComparer", () => {
-    describe("compare()", () => {
-        describe("Comparing booleans", () => {
-            it("Should return true when given two `true` booleans.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = true;
-                let right = true;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two `false` booleans.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = false;
-                let right = false;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given `true` and `false` booleans.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = true;
-                let right = false;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given `false` and `true` booleans.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = false;
-                let right = true;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-        });
-
-        describe("Comparing values", () => {
-            it("Should return false when given different values.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = 10;
-                let right = 3;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given equal values.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = 9;
-                let right = 9;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given the same value but of different types.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = 18;
-                let right = "18";
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-        });
-
-        describe("Comparing dates", () => {
-            it("Should return false when given a date and something else.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Date("November 10, 2024");
-                let right = "November 10, 2024";
-           
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when dates are different values.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Date("November 10, 2024");
-                let right = new Date("November 12, 2024");
-           
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when dates are the same, but times are different.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Date("November 10, 2024 3:45 AM");
-                let right = new Date("November 10, 2024 6:15 PM");
-           
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when dates are the same value.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Date("November 10, 2024");
-                let right = new Date("November 10, 2024");
-           
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when dates and times are the same value.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Date("November 10, 2024 8:22 PM");
-                let right = new Date("November 10, 2024 8:22 PM");
-           
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-
-        describe("Comparing arrays", () => {
-            it("Should return false when given an array and something else.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ 2, 4, 9 ];
-                let right = "text";
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given different arrays.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ 2, 4, 7 ];
-                let right = [ 2, 5, 6 ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when `expected` array has more elements.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ 2, 4, 7, 18 ];
-                let right = [ 2, 4, 7 ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when `actual` array has more elements.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ 2, 4, 7 ];
-                let right = [ 2, 4, 7, 9 ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given arrays with equal contents.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ 2, 4, "7", 9 ];
-                let right = [ 2, 4, "7", 9 ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given arrays with identical objects.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ { a: 1, b: "2" }, { c: true, d: 3 } ];
-                let right = [ { a: 1, b: "2" }, { c: true, d: 3 } ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given arrays with different objects.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = [ { a: 1, b: "2" }, { c: true, d: 3 } ];
-                let right = [ { a: 1, b: "2" }, { c: true, notD: 3 } ];
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-        });
-
-        describe("Comparing Maps", () => {
-            it("Should return false when given a Map and something else.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-                let right = "text";
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given flat Maps with different contents.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]);
-                let right = new Map([ [ "A", 3 ], [ "B", 2 ], [ "C", 1 ] ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when `actual` flat Map has fewer elements.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]);
-                let right = new Map([ [ "A", 1 ], [ "C", 3 ] ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when `actual` flat Map has more elements.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([ [ "A", 1 ], [ "C", 3 ] ]);
-                let right = new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given flat Maps with equal contents.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]);
-                let right = new Map([ [ "A", 1 ], [ "B", 2 ], [ "C", 3 ] ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given two Maps of Maps with different contents.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-                let right = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "d" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "c" ] ]) ]
-                ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two Maps of Maps, if the `actual` is missing a leaf.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-                let right = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two Maps of Maps, if the `actual` has an extra leaf.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-                let right = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two Maps of Maps, if their contents are equivalent.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-                let right = new Map([
-                    [ "One", new Map([ [ "TypeA", "a" ], [ "TypeC", "c" ] ]) ],
-                    [ "Two", new Map([ [ "TypeB", "b" ], [ "TypeD", "d" ] ]) ]
-                ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-
-        describe("Comparing Errors", () => {
-            /* cruft */
-            // it("Should return tf when some situation.", () => {
-            //     let actual = 48/
-            //     expect(actual).to.be.true;
-            //     expect(actual).to.be.false;
-            // });
-
-            it("Should return false when given two Error objects that have different messages.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("message 1");
-                let right = new Error("message 2");
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two Error objects that have the same message but different causes.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("top 1", { cause: new Error("1") });
-                let right = new Error("top 1", { cause: new Error("2") });
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two Error objects that have the same message but different non-Error causes.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("top 1", { cause: { sole: "a" } });
-                let right = new Error("top 1", { cause: { sole: "b" } });
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given Error subclass objects of different types but otherwise the same.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new RangeError("message 1");
-                let right = new TypeError("message 1");
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two Error subclass objects of the same type and otherwise the same.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new RangeError("message 1");
-                let right = new RangeError("message 1");
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two Error objects that have no message.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error();
-                let right = new Error();
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two Error objects that have the same message.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("message 1");
-                let right = new Error("message 1");
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two Error objects that have the same message and the same cause.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("top 1", { cause: new Error("2") });
-                let right = new Error("top 1", { cause: new Error("2") });
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two Error objects that have the same message and the same non-Error cause.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Error("top 1", { cause: { sole: "a" } });
-                let right = new Error("top 1", { cause: { sole: "a" } });
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-
-        describe("Comparing objects", () => {
-            it("Should return false when given an object and a value.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { seven: 7 };
-                let right = 7;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given the same object for both args.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let sameObject = { a: "b" };
-
-                let left = sameObject;
-                let right = sameObject;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given two flat objects, if different member values.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", d: "e" };
-                let right = { a: "c", d: "e" };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two flat objects, if `actual` missing a member.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", d: "e" };
-                let right = { a: "b" };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two flat objects, if extra `actual` member.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b" };
-                let right = { a: "b", d: "e" };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two flat objects, if different members.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b" };
-                let right = { c: "b" };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two flat objects, if same member values.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", d: "e" };
-                let right = { a: "b", d: "e" };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given two deep objects with different object members.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", c: { d: "e" } };
-                let right = { a: "b", c: { f: "g" } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two deep objects, if the `actual` is missing a leaf value.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", c: { d: "e", f: "g" } };
-                let right = { a: "b", c: { f: "g" } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two deep objects, if the `actual` has an extra leaf value.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", c: { d: "e" } };
-                let right = { a: "b", c: { d: "e", f: "g" } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two deep objects with equivalent members.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "b", c: { d: "e" } };
-                let right = { a: "b", c: { d: "e" } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given two flat objects with different method members.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "a", b: function () { return true; } };
-                let right = { a: "a", b: function () { return false; } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two flat objects with equivalent method members.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: "a", b: function () { return true; } };
-                let right = { a: "a", b: function () { return true; } };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-        
-        describe("Comparing functions / methods", () => {
-            it("Should return false when given a function and something else.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = function () { };
-                let right = 12;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two functions with different definitions.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = function () { };
-                let right = function (a) { return -a; };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two arrow functions with different definitions.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = () => { };
-                let right = (a) => { return -a; };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given equivalent functions with different definition styles.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = () => { };
-                let right = function () { };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given equivalent functions with different names.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = function first() { };
-                let right = function second() { };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given two methods with different definitions.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = Spoofable.prototype.spoofNumber;
-                let right = Spoofable.prototype.spoofText;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given two functions with the same definition.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = function () { };
-                let right = function () { };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two arrow functions with the same definition.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = () => { };
-                let right = () => { };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given two methods with the same definition.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = Spoofable.prototype.spoofText;
-                let right = Spoofable.prototype.spoofText;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given a function and method with the same definition.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = function spoofNumber(a, b) { return a + b; };
-                let right = Spoofable.prototype.spoofNumber;
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-
-        describe("Comparing Sets", () => {
-            it("Should return false when given a Set and something else.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Set([ 1, 2, 6 ]);
-                let right = { a: [ 1, 2, 6 ] };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given differing Sets.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Set([ 1, 2, 7 ]);
-                let right = new Set([ 1, 2, 8 ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return false when given Sets that differ in size.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Set([ 1, 2, 7 ]);
-                let right = new Set([ 1, 2, 7, 8 ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given equivalent Sets.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Set([ 1, 2, 7 ]);
-                let right = new Set([ 1, 2, 7 ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return true when given equivalent Sets with complex contents.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = new Set([ { a: 1, b: "2" }, new Map(), "c" ]);
-                let right = new Set([ { a: 1, b: "2" }, new Map(), "c" ]);
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-
-        describe("Comparing complex objects", () => {
-            it("Should return false when given differing complex objects.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: new Map([ [ 1, "7" ], [ 2, "8" ] ]), b: [ 6, 2, 10, () => { return true; } ], c: true };
-                let right = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ 6, 2, 11, () => { return true; } ],
-                    c: true
-                };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given equivalent complex objects.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = { a: new Map([ [ 1, "7" ], [ 2, "8" ] ]), b: [ 6, 2, 10, () => { return true; } ], c: true };
-                let right = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ 6, 2, 10, () => { return true; } ],
-                    c: true
-                };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-
-            it("Should return false when given differing complex objects including Sets.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ new Set([ 6, 2, 10 ]), () => { return true; } ],
-                    c: true
-                };
-                let right = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ new Set([ 6, 2, 11 ]), () => { return true; } ],
-                    c: true
-                };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.false;
-            });
-
-            it("Should return true when given equivalent complex objects including Sets.", /* good */ () => {
-                /* Arrange. */
-                let target = new TotalComparer();
-
-                let left = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ new Set([ 6, 2, 10 ]), () => { return true; } ],
-                    c: true
-                };
-                let right = {
-                    a: new Map([ [ 1, "7" ], [ 2, "8" ] ]),
-                    b: [ new Set([ 6, 2, 10 ]), () => { return true; } ],
-                    c: true
-                };
-
-                /* Act. */
-                let actual = target.compare(left, right);
-
-                /* Assert. */
-                expect(actual).to.be.true;
-            });
-        });
-    });
-});