@bikky/replication 1.0.1

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

@@ -0,0 +1,457 @@
+import { describe, expect, test } from "vitest";
+import { Expression, PropertyTypes, Versions } from "../../Main.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import { Definitions } from "../Definitions.js";
+import { BikPath } from "@bikky/path";
+import { ExpressionScopes } from "../../Expressions/TypeRegistry/Registry.js";
+import { TestPropertyDecorators } from "./Examples.js";
+import { EvaluationChain } from "../../Expressions/EvaluatorChain.js";
+//TODO: Test that class' DataIsType is used or ignored as appropriate.
+describe("Definitions", async () => {
+    const TestRepl = ReplicableRegistry.__GetReplicableForDataName(TestPropertyDecorators.TransformersTheLotClass.name);
+    const ChildRepl = ReplicableRegistry.__GetReplicableForDataName(TestPropertyDecorators.TransformersBasicChild.name);
+    const SourceFile = {
+        SourceFile: BikPath.join(BikPath.getCurrentFilepath(), "./Examples.ts"),
+        Version: Versions.v1_0_0
+    };
+    let testVal = new TestPropertyDecorators.TransformersTheLotClass();
+    ExpressionScopes.addLocalVariable(TestRepl.classConstructor, "thisEntity", [TestRepl.classConstructor]);
+    ExpressionScopes.addLocalVariable(TestPropertyDecorators.TransformersBasicStruct, "thisEntity", [TestPropertyDecorators.TransformersBasicStruct]);
+    ExpressionScopes.addLocalVariable(TestPropertyDecorators.TransformersBasicClass, "thisEntity", [TestPropertyDecorators.TransformersBasicClass]);
+    Expression.setCurrentScope(TestRepl.classConstructor, { thisEntity: testVal });
+    let ver = Versions.v1_0_0;
+    let valDef = TestRepl.getPropDefinition(ver, "val");
+    let val2Def = TestRepl.getPropDefinition(ver, "val2");
+    let val3Def = TestRepl.getPropDefinition(ver, "val3");
+    let val4Def = TestRepl.getPropDefinition(ver, "val4");
+    let val5Def = TestRepl.getPropDefinition(ver, "val5");
+    let val6Def = TestRepl.getPropDefinition(ver, "val6");
+    let val7Def = TestRepl.getPropDefinition(ver, "val7");
+    let val8Def = TestRepl.getPropDefinition(ver, "val8");
+    let val9Def = TestRepl.getPropDefinition(ver, "val9");
+    let val10Def = TestRepl.getPropDefinition(ver, "val10");
+    let val11Def = TestRepl.getPropDefinition(ver, "val11");
+    let val12Def = TestRepl.getPropDefinition(ver, "val12");
+    let val13Def = TestRepl.getPropDefinition(ver, "val13");
+    let val14Def = TestRepl.getPropDefinition(ver, "val14");
+    //TODO: Add test for 12 which is removed
+    test("1. 13 has no expressions allowed, so getting expr config returns undefined", async () => {
+        expect(val13Def.expressionForProperty).toBeUndefined();
+    });
+    let valExpr = Expression.Parse("@{thisEntity.Val}", BikPath.getCurrentFilepath(), valDef.expressionForProperty[ver]);
+    let val2Expr = Expression.Parse("@{thisEntity.Val2}", BikPath.getCurrentFilepath(), val2Def.expressionForProperty[ver]);
+    let val3Expr = Expression.Parse("@{thisEntity.Val3}", BikPath.getCurrentFilepath(), val3Def.expressionForProperty[ver]);
+    let val4Expr = Expression.Parse("@{thisEntity.Val4}", BikPath.getCurrentFilepath(), val4Def.expressionForProperty[ver]);
+    let val5Expr = Expression.Parse("@{thisEntity.Val5}", BikPath.getCurrentFilepath(), val5Def.expressionForProperty[ver]);
+    let val6Expr = Expression.Parse("@{thisEntity.Val6}", BikPath.getCurrentFilepath(), val6Def.expressionForProperty[ver]);
+    let val7Expr = Expression.Parse("@{thisEntity.Val7}", BikPath.getCurrentFilepath(), val7Def.expressionForProperty[ver]);
+    let val8Expr = Expression.Parse("@{thisEntity.Val8}", BikPath.getCurrentFilepath(), val8Def.expressionForProperty[ver]);
+    let val9Expr = Expression.Parse("@{thisEntity.Val9}", BikPath.getCurrentFilepath(), val9Def.expressionForProperty[ver]);
+    let val10Expr = Expression.Parse("@{thisEntity.Val10}", BikPath.getCurrentFilepath(), val10Def.expressionForProperty[ver]);
+    let val11Expr = Expression.Parse("@{thisEntity.Val11}", BikPath.getCurrentFilepath(), val11Def.expressionForProperty[ver]);
+    let val14Expr = Expression.Parse("@{thisEntity.Val14}", BikPath.getCurrentFilepath(), val14Def.expressionForProperty[ver]);
+    let strExpr = Expression.Parse("@{thisEntity.Val} as a string", BikPath.getCurrentFilepath(), valDef.expressionForProperty[ver]);
+    describe("2. DoExprOutputsMatchPropertyModifier", () => {
+        test("Should return true if the property modifier is correct", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val`, valDef.expressionForProperty[ver], valExpr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val`, valDef.expressionForProperty[ver], strExpr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val2`, val2Def.expressionForProperty[ver], val2Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val3`, val3Def.expressionForProperty[ver], val3Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val4`, val4Def.expressionForProperty[ver], val4Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val5`, val5Def.expressionForProperty[ver], val5Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val7`, val7Def.expressionForProperty[ver], val7Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val8`, val8Def.expressionForProperty[ver], val8Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val9`, val9Def.expressionForProperty[ver], val9Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val10`, val10Def.expressionForProperty[ver], val10Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val11`, val11Def.expressionForProperty[ver], val11Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val14`, val14Def.expressionForProperty[ver], val14Expr, errors)).toBe(true);
+        });
+        test("Should return false if the property modifier is incorrect", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val`, valDef.expressionForProperty[ver], val3Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD001")).includesString(`${Name}.Val expects String but Expression produces Map<string, Number>. Expression is @{thisEntity.Val3}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val3`, val3Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD002")).includesString(`${Name}.Val3 expects Map<string, Number> but Expression produces String. Expression is @{thisEntity.Val}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val4`, val4Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            //TODO: type should be {[key: number]: String} ???
+            expect(errors.toString("TEST_REP_TD003")).includesString(`${Name}.Val4 expects {[key: string]: String } but Expression produces String. Expression is @{thisEntity.Val}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val`, valDef.expressionForProperty[ver], val4Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD004")).includesString(`${Name}.Val expects String but Expression produces {[key: string]: String }. Expression is @{thisEntity.Val4}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val6`, val6Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD005")).includesString(`${Name}.Val6 expects Number[][] but Expression produces String. Expression is @{thisEntity.Val}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyModifier(`${Name}.Val`, valDef.expressionForProperty[ver], val6Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD006")).includesString(`${Name}.Val expects String but Expression produces Number[][]. Expression is @{thisEntity.Val6}.`);
+        });
+    });
+    describe("3. DoExprOutputsMatchPropertyType", () => {
+        test("Should return true if the property type is correct", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], valExpr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val1`, valDef.expressionForProperty[ver], strExpr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val2`, val2Def.expressionForProperty[ver], val2Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val3`, val3Def.expressionForProperty[ver], val3Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val4`, val4Def.expressionForProperty[ver], val4Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val5`, val5Def.expressionForProperty[ver], val5Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val6`, val6Def.expressionForProperty[ver], val6Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val7`, val7Def.expressionForProperty[ver], val7Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val8`, val8Def.expressionForProperty[ver], val8Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val9`, val9Def.expressionForProperty[ver], val9Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val10`, val10Def.expressionForProperty[ver], val10Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val11`, val11Def.expressionForProperty[ver], val11Expr, errors)).toBe(true);
+        });
+        test("Should return true if property type is correct but modifier is incorrect", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val4Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val5Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val2`, val2Def.expressionForProperty[ver], val3Expr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val2`, val2Def.expressionForProperty[ver], val6Expr, errors)).toBe(true);
+        });
+        test("Should return false if the property type is incorrect", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val2Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD007")).includesString(`${Name}.Val expects String but Expression produces Number. Expression is @{thisEntity.Val2}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val3`, val3Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD008")).includesString(`${Name}.Val3 expects Map<string, Number> but Expression produces String. Expression is @{thisEntity.Val}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val7Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD009")).includesString(`${Name}.Val expects String but Expression produces TransformersBasicStruct. Expression is @{thisEntity.Val7}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val7`, val7Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD010")).includesString(`${Name}.Val7 expects TransformersBasicStruct but Expression produces String. Expression is @{thisEntity.Val}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val9Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD011")).includesString(`${Name}.Val expects String but Expression produces TransformersBasicClass. Expression is @{thisEntity.Val9}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val9`, val9Def.expressionForProperty[ver], valExpr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD012")).includesString(`${Name}.Val9 expects TransformersBasicClass but Expression produces String. Expression is @{thisEntity.Val}.`);
+        });
+        test("Should return true if expr type matches one of the property types", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val8`, val8Def.expressionForProperty[ver], valExpr, errors)).toBe(true);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val8`, val8Def.expressionForProperty[ver], val2Expr, errors)).toBe(true);
+        });
+        test("Should return false if any expr type doesn't match property type(s)", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val`, valDef.expressionForProperty[ver], val8Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD013")).includesString(`${Name}.Val expects String but Expression produces (String | null | Number). Expression is @{thisEntity.Val8}.`);
+            errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoExprOutputsMatchPropertyType(`${Name}.Val2`, val2Def.expressionForProperty[ver], val8Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD014")).includesString(`${Name}.Val2 expects Number but Expression produces (String | null | Number). Expression is @{thisEntity.Val8}.`);
+        });
+    });
+    // describe("4. DoesValMatchPropertyModifier", ()=> {
+    // 	test(" 1. Primitive string is assignable to single", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(valDef, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", valDef.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 2. Primitive number is assignable to single", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val2Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], 5, val2Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 3. Map is assignable to map", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val3Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], new Map([["hello", 1]]), val3Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 4. Dict is assignable to map", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val3Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], { "hello": 1 }, val3Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 5. Undefined is assignable to optional", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val3Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], undefined, val3Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 6. Dict is assignable to dict", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val4Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		// eslint-disable-next-line @typescript-eslint/naming-convention
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], {1: "world"}, val4Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 7. Array is assignable to array", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val5Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], ["hello"], val5Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 8. Array of arrays is assignable to array of arrays", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val6Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], [[1, 2]], val6Def.optional === true)).toBe(true);
+    // 	});
+    // 	test(" 9. Class definition is assignable to single", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val7Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], { Class: "TransformersBasicStruct", Val: "hi" },
+    // 			val7Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("10. String is assignable to single with multiple types", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val8Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", val8Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("11. Null is assignable to single with multiple types", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val8Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], null, val8Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("12. Number is assignable to single with multiple types", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val8Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], 4, val8Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("13. Class Definition is assignable to pointer (inline)", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val9Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], { Class: "TransformersBasicClass", Val: "hi" },
+    // 			val9Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("14. Class Definition is assignable to pointer", ()=> {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val10Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], { Class: "TransformersBasicClass", Val: "hi" },
+    // 			val10Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("15. String is assignable to readonly single", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val11Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", val11Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("16. Array can match single", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(valDef, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], ["hello"], valDef.optional === true)).toBe(true);
+    // 	});
+    // 	test("17. Dict can match single", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val2Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], {"hello": "world"}, val2Def.optional === true)).toBe(true);
+    // 	});
+    // 	test("18. Array does not match Map", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val3Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], ["hello"], val3Def.optional === true)).toBe(false);
+    // 	});
+    // 	test("19. Single does not match Map", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val3Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", val3Def.optional === true)).toBe(false);
+    // 	});
+    // 	test("20. Single does not match Dict", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val4Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", val4Def.optional === true)).toBe(false);
+    // 	});
+    // 	test("21. Single does not match Array", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val5Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], 5, val5Def.optional === true)).toBe(false);
+    // 	});
+    // 	test("22. Single does not match Array of Arrays", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val6Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], "hello", val6Def.optional === true)).toBe(false);
+    // 	});
+    // 	test("23. Array of Arrays can match Single (Struct)", async () => {
+    // 		let valInfo = Utils.GetPropertyDecoratorTypesInfo(val7Def, TestPropertyDecorators.TransformersTheLotClass.name, true);
+    // 		expect(Definitions.DoesValMatchPropertyModifier(valInfo[0], [["hello"]], val7Def.optional === true)).toBe(true);
+    // 	});
+    // });
+    describe("5. GetPropValueFromData", () => {
+        test("1. Get all entries in a single value", () => {
+            expect(Definitions.GetPropValuesFromData(valDef, "hello")).toContainAtLeast([["hello"], PropertyTypes.Solo]);
+        });
+        test("2. Get all entries in a dictionary", () => {
+            expect(Definitions.GetPropValuesFromData(val4Def, { hello: "world" })).toContainAtLeast([["world"], PropertyTypes.Dictionary | PropertyTypes.Map]);
+            expect(Definitions.GetPropValuesFromData(val4Def, { hello: "world", one: "two" })).toContainAtLeast([["world", "two"], PropertyTypes.Dictionary | PropertyTypes.Map]);
+        });
+        test("3. Get all entries in an array", () => {
+            expect(Definitions.GetPropValuesFromData(val5Def, ["hello"])).toContainAtLeast([["hello"], PropertyTypes.Array]);
+            expect(Definitions.GetPropValuesFromData(val5Def, ["hello", "world"])).toContainAtLeast([["hello", "world"], PropertyTypes.Array]);
+        });
+        test("4. Get all entries in a map", () => {
+            expect(Definitions.GetPropValuesFromData(val3Def, new Map([["hello", 1]]))).toContainAtLeast([[1], PropertyTypes.Map]);
+            expect(Definitions.GetPropValuesFromData(val3Def, new Map([["hello", 1], ["world", 2]]))).toContainAtLeast([[1, 2], PropertyTypes.Map]);
+        });
+        test("5. Get all entries in an array of arrays", () => {
+            expect(Definitions.GetPropValuesFromData(val6Def, [["hello"]])).toContainAtLeast([["hello"], PropertyTypes.Array2]);
+            expect(Definitions.GetPropValuesFromData(val6Def, [["hello", "world"]])).toContainAtLeast([["hello", "world"], PropertyTypes.Array2]);
+            expect(Definitions.GetPropValuesFromData(val6Def, [["hello"], ["world"]])).toContainAtLeast([["hello", "world"], PropertyTypes.Array2]);
+        });
+    });
+    // describe("6. ShouldSkipProperty", ()=> {
+    // 	test("Should return false if the property is not skipped", ()=> {
+    // 		let errors = new ErrorStack(SourceFile);
+    // 		expect(Definitions.ShouldSkipProperty(TestPropertyDecorators.TransformersTheLotClass.name, valDef, "skip", errors)).toBe(false);
+    // 	});
+    // 	test("Should return true if the property is computed", ()=> {
+    // 		let errors = new ErrorStack(SourceFile);
+    // 		expect(Definitions.ShouldSkipProperty(TestPropertyDecorators.TransformersTheLotClass.name, val14Def, "skip", errors)).toBe(true);
+    // 	});
+    // 	test("Should return true if the property is optional and undefined", ()=> {
+    // 		let errors = new ErrorStack(SourceFile);
+    // 		expect(Definitions.ShouldSkipProperty(TestPropertyDecorators.TransformersTheLotClass.name, val3Def, undefined, errors)).toBe(true);
+    // 	});
+    // 	test("Should return false if the property is optional and defined", ()=> {
+    // 		let errors = new ErrorStack(SourceFile);
+    // 		expect(Definitions.ShouldSkipProperty(TestPropertyDecorators.TransformersTheLotClass.name, val3Def, "hello", errors)).toBe(false);
+    // 	});
+    // 	test("Should return true if the property is removed", ()=> {
+    // 		let errors = new ErrorStack(SourceFile);
+    // 		expect(Definitions.ShouldSkipProperty(TestPropertyDecorators.TransformersTheLotClass.name, val12Def, "remove", errors)).toBe(true);
+    // 		expect(errors.toString()).includes(`Warning: ${TestPropertyDecorators.TransformersTheLotClass.name}.Val12 has been removed and cannot be loaded.`);
+    // 	});
+    // });
+    describe("7. DoesDataClassMatchRepl", () => {
+        test("Primitive doesn't match class", () => {
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, "hello", errors, true)).toBe(null);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, "hello", errors, false)).toBe(null);
+        });
+        test("Class matches class", () => {
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, testVal, errors, true)).toBe(TestRepl);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, testVal, errors, false)).toBe(TestRepl);
+        });
+        test("Class data matches class", () => {
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersTheLotClass.name, Val: "hello" }, errors, true)).toBe(TestRepl);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersTheLotClass.name, Val: "hello" }, errors, false)).toBe(TestRepl);
+        });
+        test("Child class matches class", () => {
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicChild.name }, errors, true)).toBe(ChildRepl);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicChild.name }, errors, false)).toBe(ChildRepl);
+        });
+        test("Other class does not match class", () => {
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicStruct.name }, errors, true)).toBe(null);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicStruct.name }, errors, false)).toBe(null);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicClass.name }, errors, true)).toBe(null);
+            expect(Definitions.DoesDataClassMatchRepl(ver, TestRepl, { Class: TestPropertyDecorators.TransformersBasicClass.name }, errors, false)).toBe(null);
+        });
+    });
+    describe("8. DoesExpressionMatchProperty", () => {
+        test("Should return true if the expression matches the property", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val`, valDef.expressionForProperty[ver], valExpr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val2`, val2Def.expressionForProperty[ver], val2Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val3`, val3Def.expressionForProperty[ver], val3Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val4`, val4Def.expressionForProperty[ver], val4Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val5`, val5Def.expressionForProperty[ver], val5Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val6`, val6Def.expressionForProperty[ver], val6Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val7`, val7Def.expressionForProperty[ver], val7Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val8`, val8Def.expressionForProperty[ver], val8Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val9`, val9Def.expressionForProperty[ver], val9Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val10`, val10Def.expressionForProperty[ver], val10Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val11`, val11Def.expressionForProperty[ver], val11Expr, errors)).toBe(true);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val14`, val14Def.expressionForProperty[ver], val14Expr, errors)).toBe(true);
+        });
+        test("Should return false if expression's modifiers don't match property", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val`, valDef.expressionForProperty[ver], val3Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD015")).includesString(`${Name}.Val expects String but Expression produces Map<string, Number>. Expression is @{thisEntity.Val3}.`);
+        });
+        test("Should return false if expression's returned types don't match property", async () => {
+            const Name = TestPropertyDecorators.TransformersTheLotClass.name;
+            let errors = new ErrorStack(SourceFile);
+            expect(Definitions.DoesExpressionMatchProperty(`${Name}.Val`, valDef.expressionForProperty[ver], val2Expr, errors)).toBe(false);
+            expect(errors.toString("TEST_REP_TD016")).includesString(`${Name}.Val expects String but Expression produces Number. Expression is @{thisEntity.Val2}.`);
+        });
+    });
+    describe.sequential("9. SetupDataExpressions", () => {
+        test("Should return true if properties have correct expressions", () => {
+            let result;
+            expect(() => {
+                result = Definitions.PrePrepareData(TestRepl, JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotExpression)), { SourceFile: BikPath.getCallerFilepath(), Version: ver });
+            }).not.toThrowError();
+            expect(result.Val).instanceOf(EvaluationChain);
+            expect(result.Val2).instanceOf(EvaluationChain);
+            expect(result.Val3).instanceOf(EvaluationChain);
+            expect(result.Val4).instanceOf(EvaluationChain);
+            expect(result.Val5).instanceOf(EvaluationChain);
+            expect(result.Val6).instanceOf(EvaluationChain);
+            expect(result.Val7).instanceOf(EvaluationChain);
+            expect(result.Val8).instanceOf(EvaluationChain);
+            expect(result.Val9).instanceOf(EvaluationChain);
+            expect(result.Val10).instanceOf(EvaluationChain);
+            expect(result.Val11).instanceOf(EvaluationChain);
+            expect(result.Val13).toContainAtLeast([[1, 2]]);
+        });
+        test("Should return true if property values contain correct expressons", () => {
+            let result = Definitions.PrePrepareData(TestRepl, JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotInnerExpression)), { SourceFile: BikPath.getCallerFilepath(), Version: ver });
+            expect(result.Val).instanceOf(EvaluationChain);
+            expect(result.Val2).instanceOf(EvaluationChain);
+            expect(result.Val3).toBeInstanceOf(Object);
+            expect(result.Val3.hello).instanceOf(EvaluationChain);
+            expect(result.Val4).toBeInstanceOf(Object);
+            expect(result.Val4[1]).instanceOf(EvaluationChain);
+            expect(result.Val5).toBeInstanceOf(Array);
+            expect(result.Val5[0]).instanceOf(EvaluationChain);
+            expect(result.Val5[1]).instanceOf(EvaluationChain);
+            expect(result.Val6).toBeInstanceOf(Array);
+            expect(result.Val6[0]).toBeInstanceOf(Array);
+            expect(result.Val6[0][0]).instanceOf(EvaluationChain);
+            expect(result.Val6[0][1]).instanceOf(EvaluationChain);
+            expect(result.Val7).toBeInstanceOf(Object);
+            expect(result.Val7.Val).instanceOf(EvaluationChain);
+            expect(result.Val8).instanceOf(EvaluationChain);
+            expect(result.Val9).toBeInstanceOf(Object);
+            expect(result.Val9.Val).instanceOf(EvaluationChain);
+            expect(result.Val10).toBeInstanceOf(Object);
+            expect(result.Val10.Val).instanceOf(EvaluationChain);
+            expect(result.Val11).instanceOf(EvaluationChain);
+            expect(result.Val13).toContainAtLeast([[1, 2]]);
+        });
+    });
+    describe.sequential("10. IsLoadableDataForRepl", () => {
+        test("Should return true if the data is correct", () => {
+            let errors = new ErrorStack(SourceFile);
+            let result = Definitions.IsLoadableDataForRepl(TestRepl, TestPropertyDecorators.TransformersTheLotData, ver, errors);
+            expect(result).toBe(true);
+        });
+        test("Should return true if data is valid child data", () => {
+            let errors = new ErrorStack(SourceFile);
+            let result = Definitions.IsLoadableDataForRepl(TestRepl, TestPropertyDecorators.TransformersBasicChildData, ver, errors);
+            expect(result).toBe(true);
+        });
+        test("Should return true if the data contains correct expressions", () => {
+            let errors = new ErrorStack(SourceFile);
+            let expressionData = Definitions.PrePrepareData(TestRepl, JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotExpression)), { SourceFile: BikPath.getCallerFilepath(), Version: ver });
+            let result = Definitions.IsLoadableDataForRepl(TestRepl, expressionData, ver, errors);
+            expect(result).toBe(true);
+        });
+        test("Should return true if the data contains correct values that contain expressions", () => {
+            let errors = new ErrorStack(SourceFile);
+            let expressionData = Definitions.PrePrepareData(TestRepl, JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotInnerExpression)), { SourceFile: BikPath.getCallerFilepath(), Version: ver });
+            let result = Definitions.IsLoadableDataForRepl(TestRepl, expressionData, ver, errors);
+            expect(result).toBe(true);
+        });
+        test("Check that errors are formed sensibly", () => {
+            let errors = new ErrorStack(SourceFile);
+            let expressionData = JSON.parse(JSON.stringify(TestPropertyDecorators.InvalidTransformersTheLotData));
+            let result = Definitions.IsLoadableDataForRepl(TestRepl, expressionData, ver, errors);
+            expect(result).toBe(false);
+            //TODO: Don't forget to check that val14 shouldn't be present.
+            let errorStr = errors.toString("TEST_REP_TD017");
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val is missing and is not optional.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val2 expects Number but got a String.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val3 expects Map<string, Number> but got a String.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val4 expects {[key: string]: String } but got a Number.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val5 expects String[] but got a String[][].`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val6 expects Number[][] but got a Number[].`);
+            expect(errorStr).includesString(`			Data claims to be of type TransformersBasicClass which is not assignable to TransformersBasicStruct.
+		Error parsing data. Data (<TransformersBasicStruct>{"Class":"TransformersBasicClass","Val":"hi"}) is not`
+                + ` assignable to class TransformersBasicStruct, see above errors for details.
+	TransformersTheLotClass.Val7 expects TransformersBasicStruct but got a {"Class":"TransformersBasicClass","Val":"hi"}.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val8 expects (null | Number | String) but got a Number[][].`);
+            expect(errorStr).includesString(`			TransformersBasicClass.Val expects String but got a Number.
+		Failed to parse (<TransformersBasicClass>{"Class":"TransformersBasicClass","Val":2}) for class TransformersBasicClass, see above errors for details.
+	TransformersTheLotClass.Val9 expects TransformersBasicClass but got a {"Class":"TransformersBasicClass","Val":2}.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val10 expects TransformersBasicClass but got a Number[].`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val11 expects String but got a {[key: string]: String }.`);
+            // TODO: Re-add deprecation warning?
+            // expect(errorStr).includesString(
+            // 	`	Warning: TransformersTheLotClass.Val12 has been removed and cannot be loaded.`);
+            expect(errorStr).includesString(`	TransformersTheLotClass.Val13 does not allow for expressions.`);
+            expect(errorStr).includesString(` for class TransformersTheLotClass, see above errors for details.`.trim());
+        });
+    });
+});

package/Transformers/__tests__/Replicable.Transformers.Loader.test.d.ts

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