@bikky/replication 1.0.1

package/Transformers/__tests__/Replicable.Transformers.Utils.test.js

@@ -0,0 +1,534 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { Expression, PropertyTypes, ValueIsPrimitiveType, Versions } from "../../Main.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { Utils } from "../Utils.js";
+import { BikPath } from "@bikky/path";
+import { ExpressionScopes } from "../../Expressions/TypeRegistry/Registry.js";
+import { ModLoader } from "../../../ModLoader.js";
+import { Pointer } from "../Reference.js";
+import { TestPropertyDecorators } from "./Examples.js";
+//TODO: Test whichever utils function returns if a property should be loaded or not returns true for computed + default.
+describe("Replicable Utils", async () => {
+    const TransformersBasicClass = TestPropertyDecorators.TransformersBasicClass;
+    const TransformersTheLotClass = TestPropertyDecorators.TransformersTheLotClass;
+    const TransformersBasicStruct = TestPropertyDecorators.TransformersBasicStruct;
+    const TestRepl = ReplicableRegistry.__GetReplicableForDataName(TransformersTheLotClass.name);
+    const TestPtrRepl = ReplicableRegistry.__GetReplicableForDataName(TransformersBasicClass.name);
+    const TestStructRepl = ReplicableRegistry.__GetReplicableForDataName(TransformersBasicStruct.name);
+    describe("ValueIsPrimitiveType", async () => {
+        test("Should return true if string is String", async () => {
+            let result = ValueIsPrimitiveType(String, "test");
+            expect(result).toBe(true);
+        });
+        test("Should return false if number is not String", async () => {
+            let result = ValueIsPrimitiveType(String, 1);
+            expect(result).toBe(false);
+        });
+        test("Should return true if number is Number", async () => {
+            let result = ValueIsPrimitiveType(Number, 1);
+            expect(result).toBe(true);
+        });
+        test("Should return false if string is not Number", async () => {
+            let result = ValueIsPrimitiveType(Number, "test");
+            expect(result).toBe(false);
+        });
+        test("Should return true if boolean is Boolean", async () => {
+            let result = ValueIsPrimitiveType(Boolean, true);
+            expect(result).toBe(true);
+        });
+        test("Should return false if string is not Boolean", async () => {
+            let result = ValueIsPrimitiveType(Boolean, "test");
+            expect(result).toBe(false);
+        });
+        test("Should return true if undefined is undefined", async () => {
+            let result = ValueIsPrimitiveType(undefined, undefined);
+            expect(result).toBe(true);
+        });
+        test("Should return false if string is not undefined", async () => {
+            let result = ValueIsPrimitiveType(undefined, "test");
+            expect(result).toBe(false);
+        });
+        test("Should return true if null is null", async () => {
+            let result = ValueIsPrimitiveType(null, null);
+            expect(result).toBe(true);
+        });
+        test("Should return false if string is not null", async () => {
+            let result = ValueIsPrimitiveType(null, "test");
+            expect(result).toBe(false);
+        });
+    });
+    describe("ReplClass' PropertyDefinition", async () => {
+        const defaultExpressionConfig = {
+            cacheable: false,
+            duringLoad: false,
+            outputArray: 0,
+            outputMap: false,
+            outputDict: false,
+            outputTypes: [String],
+            startType: TransformersTheLotClass,
+            version: Versions.v1_0_0
+        };
+        test(" 1. Assignable types for String is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val");
+            expect(def).toEqual({
+                name: "val",
+                load: {
+                    default: undefined,
+                    name: "Val",
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    skipLoad: false,
+                    // Expression is default unless expression:false.
+                    types: [{ types: [String], sortIndex: "string", modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    present: true,
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Solo,
+                    types: [{ types: [String], sortIndex: "string", modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String] }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String] }) },
+            });
+        });
+        test(" 2. Assignable types for Number is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val2");
+            expect(def).toEqual({
+                name: "val2",
+                load: {
+                    default: undefined,
+                    name: "Val2",
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: "optional",
+                    skipLoad: false,
+                    types: [{ types: [Number], sortIndex: "number", modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    present: true,
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Solo,
+                    types: [
+                        { types: [Number], sortIndex: "number", modifiers: PropertyTypes.Solo | PropertyTypes.Expression },
+                        { types: [undefined], sortIndex: "undefined", modifiers: PropertyTypes.Solo | PropertyTypes.Expression },
+                    ]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number] }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number] }) },
+            });
+        });
+        test(" 3. Assignable types for Map is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val3");
+            expect(def).toEqual({
+                name: "val3",
+                load: {
+                    default: undefined,
+                    name: "Val3",
+                    possibleModifiers: PropertyTypes.Map,
+                    present: "optional",
+                    skipLoad: false,
+                    types: [{ types: [Number], keyType: [String], sortIndex: "number", modifiers: PropertyTypes.Map | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Map | PropertyTypes.Solo, //solo for undefined
+                    present: true,
+                    types: [{ types: [Number], keyType: [String], sortIndex: "number", modifiers: PropertyTypes.Map | PropertyTypes.Expression },
+                        { types: [undefined], modifiers: PropertyTypes.Solo | PropertyTypes.Expression, sortIndex: "undefined" }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number], outputMap: true }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number] }) },
+            });
+        });
+        test(" 4. Assignable types for Dictionary is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val4");
+            expect(def).toEqual({
+                name: "val4",
+                load: {
+                    default: undefined,
+                    name: "Val4",
+                    possibleModifiers: PropertyTypes.Dictionary,
+                    present: "optional",
+                    skipLoad: false,
+                    types: [{ types: [String], sortIndex: "string", keyType: [Number], restrictedTo: [1, 2, 3], modifiers: PropertyTypes.Dictionary | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Dictionary | PropertyTypes.Solo, //solo for undefined
+                    present: true,
+                    types: [{ types: [String], sortIndex: "string", keyType: [Number], restrictedTo: [1, 2, 3], modifiers: PropertyTypes.Dictionary | PropertyTypes.Expression },
+                        { types: [undefined], modifiers: PropertyTypes.Solo | PropertyTypes.Expression, sortIndex: "undefined" }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String], outputDict: true }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String] }) },
+            });
+        });
+        test(" 5. Assignable types for Array is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val5");
+            expect(def).toEqual({
+                name: "val5",
+                load: {
+                    default: undefined,
+                    name: "Val5",
+                    possibleModifiers: PropertyTypes.Array,
+                    present: true,
+                    skipLoad: false,
+                    types: [{ types: [String], sortIndex: "string", modifiers: PropertyTypes.Array | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Array,
+                    present: true,
+                    types: [{ types: [String], sortIndex: "string", modifiers: PropertyTypes.Array | PropertyTypes.Expression }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String], outputArray: 1 }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [String] }) },
+            });
+        });
+        test(" 6. Assignable types for Array2 is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val6");
+            expect(def).toEqual({
+                name: "val6",
+                load: {
+                    default: undefined,
+                    name: "Val6",
+                    possibleModifiers: PropertyTypes.Array2,
+                    present: true,
+                    skipLoad: false,
+                    types: [{ types: [Number], sortIndex: "number", modifiers: PropertyTypes.Array2 | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Array2,
+                    present: true,
+                    types: [{ types: [Number], sortIndex: "number", modifiers: PropertyTypes.Array2 | PropertyTypes.Expression }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number], outputArray: 2 }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [Number] }) },
+            });
+        });
+        test(" 7. Assignable types for Struct is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val7");
+            expect(def).toEqual({
+                name: "val7",
+                load: {
+                    default: undefined,
+                    name: "Val7",
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    skipLoad: false,
+                    types: [{ types: [TestStructRepl], sortIndex: TestStructRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    types: [{ types: [TestStructRepl], sortIndex: TestStructRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestStructRepl.opts.typescriptTypeName] }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestStructRepl.opts.typescriptTypeName] }) },
+            });
+        });
+        test(" 8. Assignable types for inlined class is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val9");
+            expect(def).toEqual({
+                name: "val9",
+                load: {
+                    default: undefined,
+                    name: "Val9",
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    skipLoad: false,
+                    types: [{ types: [TestPtrRepl], sortIndex: TestPtrRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: true,
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    types: [{ types: [TestPtrRepl], sortIndex: TestPtrRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression | PropertyTypes.ForceInline }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestPtrRepl.opts.typescriptTypeName] }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestPtrRepl.opts.typescriptTypeName] }) },
+            });
+        });
+        test(" 9. Assignable types for not inlined class is correct.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val10");
+            expect(def).toEqual({
+                name: "val10",
+                load: {
+                    default: undefined,
+                    name: "Val10",
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    skipLoad: false,
+                    types: [{ types: [TestPtrRepl], sortIndex: TestPtrRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                serialisation: {
+                    inline: undefined,
+                    possibleModifiers: PropertyTypes.Solo,
+                    present: true,
+                    types: [{ types: [TestPtrRepl], sortIndex: TestPtrRepl.opts.typescriptTypeName, modifiers: PropertyTypes.Solo | PropertyTypes.Expression }]
+                },
+                expressionForKey: undefined,
+                expressionForProperty: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestPtrRepl.opts.typescriptTypeName] }) },
+                expressionForValue: { [Versions.v1_0_0]: Object.assign(Object.assign({}, defaultExpressionConfig), { outputTypes: [TestPtrRepl.opts.typescriptTypeName] }) },
+            });
+        });
+    });
+    describe("GetPropExpressionConfig", async () => {
+        beforeAll(() => {
+            Expression.setCurrentStartScopeType(TransformersTheLotClass.name);
+        });
+        test.skip("Should return correct expression config for String.", async () => {
+            let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val");
+            let result = Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def);
+            expect(result).toEqual({
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 0,
+                outputMap: false,
+                outputDict: false,
+                outputTypes: [String],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+        });
+        test("Should return multiple types if provided multiple types", async () => {
+            let def = {
+                type: [{ type: [String, Number], array: true }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            let result = Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def);
+            expect(result).toEqual({
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 1,
+                outputMap: false,
+                outputDict: false,
+                outputTypes: [String, Number],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+        });
+        test("Should complain if given incompatible array types", async () => {
+            let def = {
+                type: [{ type: [String], array: true }, { type: [Number] }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            expect(() => Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def))
+                .toThrow("Error, val has inconsistent type categories (array & not array, etc).\nExpressions don't support this currently.");
+        });
+        test("Should complain if given incompatible map types", async () => {
+            let def = {
+                type: [{ type: [String], mapKey: String }, { type: [Number] }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            expect(() => Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def))
+                .toThrow("Error, val has inconsistent type categories (map & not map, etc).\nExpressions don't support this currently.");
+        });
+        test("Should return array type if given all array types", async () => {
+            let def = {
+                type: [{ type: [String], array: true }, { type: [Number], array: true }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            let result = Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def);
+            expect(result).toEqual({
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 1,
+                outputMap: false,
+                outputDict: false,
+                outputTypes: [String, Number],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+        });
+        test("Should return map type if given all map types", async () => {
+            let def = {
+                type: [{ type: [String], mapKey: String }, { type: [Number], mapKey: String }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            let result = Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def);
+            expect(result).toEqual({
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 0,
+                outputMap: true,
+                outputDict: false,
+                outputTypes: [String, Number],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+        });
+        test("Should be fine if given map types with different key types", async () => {
+            let def = {
+                type: [{ type: [String], mapKey: String }, { type: [Number], mapKey: Number }],
+                property: "val",
+                version: Versions.v1_0_0,
+                dataName: "Val",
+            };
+            let result = Utils.ExpressionUtils.MakePropExpressionConfig(Versions.v1_0_0, def);
+            expect(result).toEqual({
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 0,
+                outputMap: true,
+                outputDict: false,
+                outputTypes: [String, Number],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+        });
+        afterAll(() => {
+            Expression.setCurrentStartScopeType(null);
+        });
+    });
+    describe.sequential("DoesExpressionMatchPropType", async () => {
+        ExpressionScopes.addLocalVariable(TransformersTheLotClass.name, "thisEntity", [TransformersTheLotClass]);
+        ExpressionScopes.setLocalScope(TransformersTheLotClass.name, { thisEntity: new TransformersTheLotClass() });
+        Expression.setCurrentStartScopeType(TransformersTheLotClass.name);
+        await ModLoader.DoLoad();
+        let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val2");
+        let config = def.expressionForProperty[Versions.v1_0_0];
+        test.sequential("Prop config should be valid", () => {
+            expect(config).not.toBeUndefined();
+        });
+        let strEvul;
+        test.sequential("Expression evaluates correctly", () => {
+            strEvul = Expression.Parse("@{thisEntity.Val2}", BikPath.getCurrentFilepath(), config);
+        });
+        test.sequential("Should return true if expression matches prop type.", async () => {
+            let result = Utils.ExpressionUtils.DoesExpressionMatchPropType(strEvul, def);
+            expect(result).toBe(true);
+        });
+        test.sequential("Should return false if expression does not match prop type.", async () => {
+            let val1def = TestRepl.getPropDefinition(Versions.v1_0_0, "val");
+            let result = Utils.ExpressionUtils.DoesExpressionMatchPropType(strEvul, val1def);
+            expect(result).toBe(false);
+        });
+        test.sequential("Should return false if expression does not match prop type.", async () => {
+            let val2def = TestRepl.getPropDefinition(Versions.v1_0_0, "val2");
+            let evalStr = Expression.Parse("@{thisEntity.Val} is a string", BikPath.getCurrentFilepath(), Object.assign(Object.assign({}, config), { outputTypes: [String] }));
+            let result = Utils.ExpressionUtils.DoesExpressionMatchPropType(evalStr, val2def);
+            expect(result).toBe(false);
+        });
+        afterAll(() => {
+            Expression.setCurrentStartScopeType(null);
+        });
+    });
+    describe("CompareProp", async () => {
+        test("Compare primitive values", async () => {
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal("test", "test", "val")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal("test", "test2", "val")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(0, 0, "val")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(false, false, "val")).toBe(true);
+        });
+        test("Compare arrays", async () => {
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test"], [["Primitive", "test"]], "val5")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test"], [["Primitive", "test2"]], "val5")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test", "two"], [["Primitive", "test"]], "val5")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test", "two"], [["Primitive", "test2"], ["Primitive", "two"]], "val5")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test", "two"], [["Primitive", "test"], ["Primitive", "two2"]], "val5")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(["test", "two"], [["Primitive", "test"], ["Primitive", "two"]], "val5")).toBe(true);
+        });
+        test("Compare maps", async () => {
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1]]), { "test": ["Primitive", 1] }, "val3")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1]]), { "test": ["Primitive", 2] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1]]), { "test2": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1], ["two", 2]]), { "test": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1], ["two", 2]]), { "test": ["Primitive", 1], "two": ["Primitive", 2] }, "val3")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1], ["two", 2]]), { "test": ["Primitive", 1], "two": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1], ["two", 2]]), { "test": ["Primitive", 2], "two": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(new Map([["test", 1], ["two", 2]]), { "test": ["Primitive", 2], "two": ["Primitive", 2] }, "val3")).toBe(false);
+        });
+        test("Compare dicts", async () => {
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1 }, { "test": ["Primitive", 1] }, "val3")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1 }, { "test": ["Primitive", 2] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1 }, { "test2": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1, "two": 2 }, { "test": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1, "two": 2 }, { "test": ["Primitive", 1], "two": ["Primitive", 2] }, "val3")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1, "two": 2 }, { "test": ["Primitive", 1], "two": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1, "two": 2 }, { "test": ["Primitive", 2], "two": ["Primitive", 1] }, "val3")).toBe(false);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal({ "test": 1, "two": 2 }, { "test": ["Primitive", 2], "two": ["Primitive", 2] }, "val3")).toBe(false);
+        });
+        test("Compare expressions", async () => {
+            let expr = Expression.Parse("@{thisEntity.Val}", BikPath.getCurrentFilepath(), {
+                cacheable: false,
+                duringLoad: false,
+                outputArray: 0,
+                outputMap: false,
+                outputTypes: [String],
+                startType: TransformersTheLotClass.name,
+                version: Versions.v1_0_0
+            });
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(expr, "test", "val")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(expr, "test2", "val")).toBe(true);
+        });
+        test("Compare pointers", async () => {
+            let val = new TransformersBasicClass();
+            val.val = "test";
+            let ptr = new Pointer(val);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(ptr, [TransformersBasicClass.name, "test"], "val9")).toBe(true);
+            expect(Utils.CompareUtils.CompareValWithSerialisedVal(ptr, ["UnknownClass", "test"], "val9")).toBe(false);
+        });
+    });
+    describe("CompareRepl and Compare", () => {
+        let testPtr = new TransformersBasicClass();
+        testPtr.val = "test";
+        let objToCompare = new TransformersTheLotClass();
+        Object.defineProperties(objToCompare, {
+            val: { value: "test" },
+            val2: { value: 1 },
+            val3: { value: new Map([["test", 1]]) },
+            val4: { value: { test: 1 } },
+            val5: { value: ["test"] },
+            val6: { value: [[1]] },
+            val7: { value: new TransformersTheLotClass() },
+            val8: { value: "test" },
+            val9: { value: new Pointer(testPtr) },
+            val10: { value: new Pointer(testPtr) },
+            val13: { value: [[1]] },
+            val14: { value: 1 }
+        });
+        let serialisedCorrect = {
+            val: ["Primitive", "test"],
+            val2: ["Primitive", 1],
+            val3: ["Map", { "test": ["Primitive", 1] }],
+            val4: ["Dict", { "test": ["Primitive", 1] }],
+            val5: ["Array", [["Primitive", "test"]]],
+            val6: ["Array", [["Array", [["Primitive", 1]]]]],
+            val7: [TransformersBasicStruct.name, { val: ["Primitive", "test"] }],
+            val8: ["Primitive", "test"],
+            val9: [TransformersBasicClass.name, { val: ["Primitive", "test"] }],
+            val10: [TransformersBasicClass.name, "test"],
+            val13: ["Array", [["Array", [["Primitive", 1]]]]],
+            val14: ["Primitive", 1]
+        };
+        test("CompareRepl: Should return true if all values are equal", async () => {
+            expect(Utils.CompareUtils.CompareRepl(TestRepl, objToCompare, serialisedCorrect)).toBe(true);
+        });
+        test("Compare: Should return true if all values are equal", async () => {
+            expect(Utils.CompareUtils.Compare(objToCompare, [TransformersTheLotClass.name, serialisedCorrect])).toBe(true);
+        });
+        test("Compare: Should return false if comparing into wrong value", async () => {
+            expect(Utils.CompareUtils.Compare(testPtr, [TransformersTheLotClass.name, serialisedCorrect])).toBe(false);
+        });
+    });
+});

package/__tests__/Replicable.Expressions.test.d.ts

@@ -0,0 +1 @@
+export {};