public static void Run() { UDelegateFunction unrealFunction = UFunction.GetDelegateSignature <Test_SimpleDelegate>(); Tests.Assert(unrealFunction != null, "Test_SimpleDelegate"); Tests.AssertProperty <USoftClassProperty>(unrealFunction, UFunction.ReturnValuePropName, EPropertyFlags.Parm | EPropertyFlags.OutParm | EPropertyFlags.ReturnParm); Tests.AssertProperty <UIntProperty>(unrealFunction, "param1", EPropertyFlags.Parm); Tests.AssertProperty <UStrProperty>(unrealFunction, "param2", EPropertyFlags.Parm); Tests.AssertProperty <UDoubleProperty>(unrealFunction, "param3", EPropertyFlags.Parm | EPropertyFlags.OutParm | EPropertyFlags.ReferenceParm); Tests.AssertProperty <UStrProperty>(unrealFunction, "param4", EPropertyFlags.Parm | EPropertyFlags.OutParm); }
public static void Run() { UClass unrealClass = UClass.GetClass <Test_CollectionsFuncs>(); Tests.Assert(unrealClass != null, "Test_CollectionsFuncs"); Test_CollectionsFuncs obj = UObject.NewObject <Test_CollectionsFuncs>(); RunArrayTests(obj, unrealClass); RunSetTests(obj, unrealClass); RunMapTest(obj, unrealClass); }
public static void Run() { UClass unrealClass = UClass.GetClass <Test_SimpleFuncs>(); Tests.Assert(unrealClass != null, "Test_SimpleFuncs"); Test_SimpleFuncs obj = UObject.NewObject <Test_SimpleFuncs>(); TestFuncX(obj, unrealClass, 1); TestFuncX(obj, unrealClass, 2); TestFuncX(obj, unrealClass, 3); TestResultFunctions(obj, unrealClass); }
public static void Run() { UClass class1 = UClass.GetClass <Test_SimpleClass1>(); UClass class2 = UClass.GetClass <Test_SimpleClass2>(); UClass class3 = UClass.GetClass <Test_SimpleClass3>(); Tests.Assert(class1 != null, "Test_SimpleClass1"); Tests.Assert(class1 != null, "Test_SimpleClass2"); Tests.Assert(class1 != null, "Test_SimpleClass3"); Test_SimpleClass1 obj1 = UObject.NewObject <Test_SimpleClass1>(); Test_SimpleClass2 obj2 = UObject.NewObject <Test_SimpleClass2>(); Test_SimpleClass3 obj3 = UObject.NewObject <Test_SimpleClass3>(); TestVirtualFunc1(obj1, 0); TestVirtualFunc1(obj2, 1); TestVirtualFunc1(obj3, 2); }
//public HashSet<FText> Val23; public static void Run() { UScriptStruct unrealStruct = UScriptStruct.GetStruct <Test_SimpleStructTSet>(); Tests.Assert(unrealStruct != null, "Test_SimpleStructTSet"); Tests.AssertTSetProperty <UInt8Property>(unrealStruct, "Val1"); Tests.AssertTSetProperty <UByteProperty>(unrealStruct, "Val2"); Tests.AssertTSetProperty <UInt16Property>(unrealStruct, "Val3"); Tests.AssertTSetProperty <UUInt16Property>(unrealStruct, "Val4"); Tests.AssertTSetProperty <UIntProperty>(unrealStruct, "Val5"); Tests.AssertTSetProperty <UUInt32Property>(unrealStruct, "Val6"); Tests.AssertTSetProperty <UInt64Property>(unrealStruct, "Val7"); Tests.AssertTSetProperty <UUInt64Property>(unrealStruct, "Val8"); Tests.AssertTSetProperty <UFloatProperty>(unrealStruct, "Val9"); Tests.AssertTSetProperty <UDoubleProperty>(unrealStruct, "Val10"); //Tests.AssertTSetProperty<UDelegateProperty>(unrealStruct, "Val11"); //Tests.AssertTSetProperty<UMulticastDelegateProperty>(unrealStruct, "Val12"); Tests.AssertTSetProperty <UObjectProperty>(unrealStruct, "Val13"); Tests.AssertTSetProperty <UEnumProperty>(unrealStruct, "Val14"); Tests.AssertTSetProperty <UStructProperty>(unrealStruct, "Val15"); Tests.AssertTSetProperty <UClassProperty>(unrealStruct, "Val16"); Tests.AssertTSetProperty <ULazyObjectProperty>(unrealStruct, "Val17"); //Tests.AssertTSetProperty<UWeakObjectProperty>(unrealStruct, "Val18"); Tests.AssertTSetProperty <USoftClassProperty>(unrealStruct, "Val19"); Tests.AssertTSetProperty <USoftObjectProperty>(unrealStruct, "Val20"); Tests.AssertTSetProperty <UStrProperty>(unrealStruct, "Val21"); Tests.AssertTSetProperty <UNameProperty>(unrealStruct, "Val22"); //Tests.AssertTSetProperty<UTextProperty>(unrealStruct, "Val23"); Test_SimpleStructTSet defaultValue = StructDefault <Test_SimpleStructTSet> .Value; // Check all lists default to empty (they will be constructed by the marshaler) foreach (FieldInfo field in defaultValue.GetType().GetFields()) { // HashSet doesn't have a Count we can easily get, obtain it using reflection object collection = field.GetValue(defaultValue); int count = (int)collection.GetType().GetProperty("Count").GetValue(collection); Tests.AssertEqual(count, 0, unrealStruct, field.Name); } }
private static void TestResultFunctions(Test_SimpleFuncs obj, UClass unrealClass) { UClass actorClass = GetActorClass(); TestResultFuncXEquals <sbyte>(4, obj, 1); TestResultFuncXEquals <byte>(5, obj, 2); TestResultFuncXEquals <short>(6, obj, 3); TestResultFuncXEquals <ushort>(7, obj, 4); TestResultFuncXEquals <int>(8, obj, 5); TestResultFuncXEquals <uint>(9, obj, 6); TestResultFuncXEquals <long>(10, obj, 7); TestResultFuncXEquals <ulong>(11, obj, 8); TestResultFuncXEquals <float>(12.3f, obj, 9); TestResultFuncXEquals <double>(13.4, obj, 10); Tests.Assert(TestResultFuncX <Test_SimpleDelegate>(obj, 11, false).IsBound, unrealClass, "ResultFunc11"); Tests.AssertEqual(TestResultFuncX <Test_SimpleMulticastDelegate>(obj, 12, false).Count, 3, unrealClass, "ResultFunc12"); TestResultFuncXEquals <UObject>(actorClass, obj, 13); TestResultFuncXEquals <UObject>(null, obj, 13, true); TestResultFuncXEquals <Test_SimpleEnum>(Test_SimpleEnum.Val3, obj, 14); var fixedArrayStruct = obj.ResultFunc15(); Tests.AssertEqual(fixedArrayStruct.Array1[0], 2, unrealClass, "ResultFunc15"); Tests.AssertEqual(fixedArrayStruct.Array1[1], 5, unrealClass, "ResultFunc15"); Tests.AssertEqual(fixedArrayStruct.Array1[2], 111, unrealClass, "ResultFunc15"); Tests.AssertEqual(TestResultFuncX <TSubclassOf <UObject> >(obj, 16, false).Value, actorClass, unrealClass, "ResultFunc16"); Tests.AssertEqual(TestResultFuncX <TSubclassOf <UObject> >(obj, 16, true), TSubclassOf <UObject> .Null, unrealClass, "ResultFunc16"); Tests.AssertEqual(TestResultFuncX <TLazyObject <UObject> >(obj, 17, false).Value, actorClass, unrealClass, "ResultFunc17"); Tests.AssertEqual(TestResultFuncX <TLazyObject <UObject> >(obj, 17, true), TLazyObject <UObject> .Null, unrealClass, "ResultFunc17_Null"); Tests.AssertEqual(TestResultFuncX <TWeakObject <UObject> >(obj, 18, false).Value, actorClass, unrealClass, "ResultFunc18"); Tests.AssertEqual(TestResultFuncX <TWeakObject <UObject> >(obj, 18, true), TWeakObject <UObject> .Null, unrealClass, "ResultFunc18_Null"); Tests.AssertEqual(TestResultFuncX <TSoftClass <UObject> >(obj, 19, false).Value, actorClass, unrealClass, "ResultFunc19"); Tests.AssertEqual(TestResultFuncX <TSoftClass <UObject> >(obj, 19, true), TSoftClass <UObject> .Null, unrealClass, "ResultFunc19_Null"); Tests.AssertEqual(TestResultFuncX <TSoftObject <UObject> >(obj, 20, false).Value, actorClass, unrealClass, "ResultFunc20"); Tests.AssertEqual(TestResultFuncX <TSoftObject <UObject> >(obj, 20, true), TSoftObject <UObject> .Null, unrealClass, "ResultFunc20_Null"); Tests.AssertEqual(TestResultFuncX <string>(obj, 21, false), "result", unrealClass, "ResultFunc21"); Tests.AssertEqual(TestResultFuncX <string>(obj, 21, true), string.Empty, unrealClass, "ResultFunc21_Null"); Tests.AssertEqual(TestResultFuncX <FName>(obj, 22, false), new FName("result"), unrealClass, "ResultFunc22"); }
//public List<FText> Val23; public static void Run() { UScriptStruct unrealStruct = UScriptStruct.GetStruct <Test_SimpleStructTArray>(); Tests.Assert(unrealStruct != null, "Test_SimpleStructTArray"); Tests.AssertTArrayProperty <UInt8Property>(unrealStruct, "Val1"); Tests.AssertTArrayProperty <UByteProperty>(unrealStruct, "Val2"); Tests.AssertTArrayProperty <UInt16Property>(unrealStruct, "Val3"); Tests.AssertTArrayProperty <UUInt16Property>(unrealStruct, "Val4"); Tests.AssertTArrayProperty <UIntProperty>(unrealStruct, "Val5"); Tests.AssertTArrayProperty <UUInt32Property>(unrealStruct, "Val6"); Tests.AssertTArrayProperty <UInt64Property>(unrealStruct, "Val7"); Tests.AssertTArrayProperty <UUInt64Property>(unrealStruct, "Val8"); Tests.AssertTArrayProperty <UFloatProperty>(unrealStruct, "Val9"); Tests.AssertTArrayProperty <UDoubleProperty>(unrealStruct, "Val10"); Tests.AssertTArrayProperty <UDelegateProperty>(unrealStruct, "Val11"); Tests.AssertTArrayProperty <UMulticastDelegateProperty>(unrealStruct, "Val12"); Tests.AssertTArrayProperty <UObjectProperty>(unrealStruct, "Val13"); Tests.AssertTArrayProperty <UEnumProperty>(unrealStruct, "Val14"); Tests.AssertTArrayProperty <UStructProperty>(unrealStruct, "Val15"); Tests.AssertTArrayProperty <UClassProperty>(unrealStruct, "Val16"); Tests.AssertTArrayProperty <ULazyObjectProperty>(unrealStruct, "Val17"); Tests.AssertTArrayProperty <UWeakObjectProperty>(unrealStruct, "Val18"); Tests.AssertTArrayProperty <USoftClassProperty>(unrealStruct, "Val19"); Tests.AssertTArrayProperty <USoftObjectProperty>(unrealStruct, "Val20"); Tests.AssertTArrayProperty <UStrProperty>(unrealStruct, "Val21"); Tests.AssertTArrayProperty <UNameProperty>(unrealStruct, "Val22"); //Tests.AssertTArrayProperty<UTextProperty>(unrealStruct, "Val23"); Test_SimpleStructTArray defaultValue = StructDefault <Test_SimpleStructTArray> .Value; // Check all lists default to empty (they will be constructed by the marshaler) foreach (FieldInfo field in defaultValue.GetType().GetFields()) { Tests.AssertEqual((field.GetValue(defaultValue) as System.Collections.IList).Count, 0, unrealStruct, field.Name); } }
public static void AssertSetTest(UObject obj, ISet <long> p1, ISet <UObject> p2, ISet <Test_SimpleEnum> p3, ISet <Test_SimpleBlittableStruct> p4, ISet <TSoftClass <UObject> > p5, ISet <string> p6, ISet <FName> p7) { UClass unrealClass = obj.GetClass(); Tests.Assert(p1.Contains(10), unrealClass, "AssertSetTest.p1"); Tests.Assert(p2.Contains(Tests.ActorClass), unrealClass, "AssertSetTest.p2"); Tests.Assert(p3.Contains(Test_SimpleEnum.Val3), unrealClass, "AssertSetTest.p3"); Tests.Assert(p4.Contains(new Test_SimpleBlittableStruct() { Val3 = 99 }), unrealClass, "AssertSetTest.p4"); Tests.Assert(p5.Contains(TSoftClass <UObject> .Null), unrealClass, "AssertSetTest.p5"); Tests.Assert(p5.Contains(new TSoftClass <UObject>(Tests.ActorClass)), unrealClass, "AssertSetTest.p5"); Tests.Assert(p6.Contains("test123"), unrealClass, "AssertSetTest.p6"); Tests.Assert(p7.Contains(new FName("test1234")), unrealClass, "AssertSetTest.p7"); }
public static void Run() { UClass unrealClass = UClass.GetClass <Test_SimpleClassTSet>(); Tests.Assert(unrealClass != null, "Test_SimpleClassTSet"); Tests.AssertTSetProperty <UInt8Property>(unrealClass, "Val1"); Tests.AssertTSetProperty <UByteProperty>(unrealClass, "Val2"); Tests.AssertTSetProperty <UInt16Property>(unrealClass, "Val3"); Tests.AssertTSetProperty <UUInt16Property>(unrealClass, "Val4"); Tests.AssertTSetProperty <UIntProperty>(unrealClass, "Val5"); Tests.AssertTSetProperty <UUInt32Property>(unrealClass, "Val6"); Tests.AssertTSetProperty <UInt64Property>(unrealClass, "Val7"); Tests.AssertTSetProperty <UUInt64Property>(unrealClass, "Val8"); Tests.AssertTSetProperty <UFloatProperty>(unrealClass, "Val9"); Tests.AssertTSetProperty <UDoubleProperty>(unrealClass, "Val10"); //Tests.AssertTSetProperty<UDelegateProperty>(unrealClass, "Val11"); //Tests.AssertTSetProperty<UMulticastDelegateProperty>(unrealClass, "Val12"); Tests.AssertTSetProperty <UObjectProperty>(unrealClass, "Val13"); Tests.AssertTSetProperty <UEnumProperty>(unrealClass, "Val14"); Tests.AssertTSetProperty <UStructProperty>(unrealClass, "Val15"); Tests.AssertTSetProperty <UClassProperty>(unrealClass, "Val16"); Tests.AssertTSetProperty <ULazyObjectProperty>(unrealClass, "Val17"); //Tests.AssertTSetProperty<UWeakObjectProperty>(unrealClass, "Val18"); Tests.AssertTSetProperty <USoftClassProperty>(unrealClass, "Val19"); Tests.AssertTSetProperty <USoftObjectProperty>(unrealClass, "Val20"); Tests.AssertTSetProperty <UStrProperty>(unrealClass, "Val21"); Tests.AssertTSetProperty <UNameProperty>(unrealClass, "Val22"); //Tests.AssertTSetProperty<UTextProperty>(unrealClass, "Val23"); Test_SimpleClassTSet obj = NewObject <Test_SimpleClassTSet>(); obj.Val1.Add(100); Tests.Assert(obj.Val1.Contains(100), unrealClass, "Val1"); obj.Val1.Add(101); Tests.Assert(obj.Val1.Contains(101), unrealClass, "Val1"); Tests.Assert(!obj.Val1.Add(101), unrealClass, "Val1"); Tests.AssertEqual(obj.Val1.Count, 2, unrealClass, "Val1"); obj.Val1.Remove(101); Tests.AssertEqual(obj.Val1.Count, 1, unrealClass, "Val1"); obj.Val1.Clear(); Tests.AssertEqual(obj.Val1.Count, 0, unrealClass, "Val1"); obj.Val2.Add(102); obj.Val2.Add(103); Tests.Assert(obj.Val2.Contains(102), unrealClass, "Val2"); Tests.Assert(obj.Val2.Contains(102), unrealClass, "Val2"); Tests.AssertEqual(obj.Val2.Count, 2, unrealClass, "Val2"); obj.Val3.Add(103); obj.Val3.Add(104); Tests.Assert(obj.Val3.Contains(103), unrealClass, "Val3"); Tests.Assert(obj.Val3.Contains(104), unrealClass, "Val3"); obj.Val4.Add(105); obj.Val4.Add(106); Tests.Assert(obj.Val4.Contains(105), unrealClass, "Val4"); Tests.Assert(obj.Val4.Contains(106), unrealClass, "Val4"); obj.Val5.Add(107); obj.Val5.Add(108); Tests.Assert(obj.Val5.Contains(107), unrealClass, "Val5"); Tests.Assert(obj.Val5.Contains(108), unrealClass, "Val5"); obj.Val6.Add(109); obj.Val6.Add(110); Tests.Assert(obj.Val6.Contains(109), unrealClass, "Val6"); Tests.Assert(obj.Val6.Contains(110), unrealClass, "Val6"); obj.Val7.Add(111); obj.Val7.Add(112); Tests.Assert(obj.Val7.Contains(111), unrealClass, "Val7"); Tests.Assert(obj.Val7.Contains(112), unrealClass, "Val7"); obj.Val8.Add(113); obj.Val8.Add(114); Tests.Assert(obj.Val8.Contains(113), unrealClass, "Val8"); Tests.Assert(obj.Val8.Contains(114), unrealClass, "Val8"); obj.Val9.Add(115.5f); obj.Val9.Add(116.5f); Tests.Assert(obj.Val9.Contains(115.5f), unrealClass, "Val9"); Tests.Assert(obj.Val9.Contains(116.5f), unrealClass, "Val9"); obj.Val10.Add(117.2); obj.Val10.Add(118.2); Tests.Assert(obj.Val10.Contains(117.2), unrealClass, "Val10"); Tests.Assert(obj.Val10.Contains(118.2), unrealClass, "Val10"); Tests.Assert(!obj.Val13.Contains(Tests.ActorClass), unrealClass, "Val13"); Tests.Assert(!obj.Val13.Contains(null), unrealClass, "Val13"); obj.Val13.Add(Tests.ActorClass); obj.Val13.Add(null); Tests.Assert(obj.Val13.Contains(Tests.ActorClass), unrealClass, "Val13"); Tests.Assert(obj.Val13.Contains(null), unrealClass, "Val13"); obj.Val14.Add(Test_SimpleEnum.Val3); obj.Val14.Add(Test_SimpleEnum.Val2); Tests.Assert(obj.Val14.Contains(Test_SimpleEnum.Val3), unrealClass, "Val14"); Tests.Assert(obj.Val14.Contains(Test_SimpleEnum.Val2), unrealClass, "Val14"); Test_SimpleBlittableStruct blitt1 = StructDefault <Test_SimpleBlittableStruct> .Value; blitt1.Val1 = 10; blitt1.Val2 = 11; obj.Val15.Add(blitt1); obj.Val15.Add(default(Test_SimpleBlittableStruct)); Tests.Assert(obj.Val15.Contains(blitt1), unrealClass, "Val15"); Tests.Assert(obj.Val15.Contains(default(Test_SimpleBlittableStruct)), unrealClass, "Val15"); obj.Val16.Add(new TSubclassOf <UObject>(Tests.ActorClass)); obj.Val16.Add(TSubclassOf <UObject> .Null); Tests.Assert(obj.Val16.Contains(new TSubclassOf <UObject>(Tests.ActorClass)), unrealClass, "Val16"); Tests.Assert(obj.Val16.Contains(TSubclassOf <UObject> .Null), unrealClass, "Val16"); obj.Val17.Add(new TLazyObject <UObject>(Tests.ActorClass)); obj.Val17.Add(TLazyObject <UObject> .Null); Tests.Assert(obj.Val17.Contains(new TLazyObject <UObject>(Tests.ActorClass)), unrealClass, "Val17"); Tests.Assert(obj.Val17.Contains(TLazyObject <UObject> .Null), unrealClass, "Val17"); obj.Val19.Add(new TSoftClass <UObject>(Tests.ActorClass)); obj.Val19.Add(TSoftClass <UObject> .Null); Tests.Assert(obj.Val19.Contains(new TSoftClass <UObject>(Tests.ActorClass)), unrealClass, "Val19"); Tests.Assert(obj.Val19.Contains(TSoftClass <UObject> .Null), unrealClass, "Val19"); obj.Val20.Add(new TSoftObject <UObject>(Tests.ActorClass)); obj.Val20.Add(TSoftObject <UObject> .Null); Tests.Assert(obj.Val20.Contains(new TSoftObject <UObject>(Tests.ActorClass)), unrealClass, "Val20"); Tests.Assert(obj.Val20.Contains(TSoftObject <UObject> .Null), unrealClass, "Val20"); obj.Val21.Add("test1"); obj.Val21.Add("test2"); Tests.Assert(obj.Val21.Contains("test1"), unrealClass, "Val21"); Tests.Assert(obj.Val21.Contains("test2"), unrealClass, "Val21"); obj.Val22.Add(new FName("test3")); obj.Val22.Add(new FName("test4")); Tests.Assert(obj.Val22.Contains(new FName("test3")), unrealClass, "Val22"); Tests.Assert(obj.Val22.Contains(new FName("test4")), unrealClass, "Val22"); }
public static void Run() { Test_SimpleStructOnClass obj = UObject.NewObject <Test_SimpleStructOnClass>(); Tests.Assert(obj != null, "Test_SimpleStructOnClass NewObject"); UClass uclass = obj.GetClass(); Tests.AssertEqual(uclass, UClass.GetClass(obj.GetType()), "Test_SimpleStructOnClass GetClass/Type"); // Create another obj of the same type for comparisons of Test_SimpleStructOnClass other = UObject.NewObject <Test_SimpleStructOnClass>(); // Test BlittableStruct default state string msg = "BlittableStruct default state"; Tests.AssertDefault(obj.BlittableStruct.Val1, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val2, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val3, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val4, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val5, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val6, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val7, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val8, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val9, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val10, uclass, msg); Tests.AssertDefault(obj.BlittableStruct.Val11, uclass, msg); // Test Struct default state msg = "Struct default state"; Tests.AssertDefault(obj.Struct.Val0, uclass, msg); Tests.AssertDefault(obj.Struct.Val1, uclass, msg); Tests.AssertDefault(obj.Struct.Val2, uclass, msg); Tests.AssertDefault(obj.Struct.Val3, uclass, msg); Tests.AssertDefault(obj.Struct.Val4, uclass, msg); Tests.AssertDefault(obj.Struct.Val5, uclass, msg); Tests.AssertDefault(obj.Struct.Val6, uclass, msg); Tests.AssertDefault(obj.Struct.Val7, uclass, msg); Tests.AssertDefault(obj.Struct.Val8, uclass, msg); Tests.AssertDefault(obj.Struct.Val9, uclass, msg); Tests.AssertDefault(obj.Struct.Val10, uclass, msg); //Tests.AssertDefault(obj.Struct.Val11, uclass, msg);// delegate will be non-null from struct marshaler //Tests.AssertDefault(obj.Struct.Val12, uclass, msg);// delegate will be non-null from struct marshaler Tests.AssertDefault(obj.Struct.Val13, uclass, msg); Tests.AssertDefault(obj.Struct.Val14, uclass, msg); Tests.AssertDefault(obj.Struct.Val15, uclass, msg); Tests.AssertDefault(obj.Struct.Val16, uclass, msg); Tests.AssertDefault(obj.Struct.Val17, uclass, msg); Tests.AssertDefault(obj.Struct.Val18, uclass, msg); Tests.AssertDefault(obj.Struct.Val19, uclass, msg); Tests.AssertDefault(obj.Struct.Val20, uclass, msg); //Tests.AssertDefault(obj.Struct.Val21, uclass, msg);// string will be non null from struct marshaler Tests.AssertDefault(obj.Struct.Val22, uclass, msg); Test_SimpleBlittableStruct blittableStructVal = obj.BlittableStruct; blittableStructVal.Val1 = 1; blittableStructVal.Val2 = 2; blittableStructVal.Val3 = 3; blittableStructVal.Val4 = 4; blittableStructVal.Val5 = 5; blittableStructVal.Val6 = 6; blittableStructVal.Val7 = 7; blittableStructVal.Val8 = 8; blittableStructVal.Val9 = 9; blittableStructVal.Val10 = 10; blittableStructVal.Val11 = new FName("Hello world"); obj.BlittableStruct = blittableStructVal; Tests.AssertEqual(obj.BlittableStruct, blittableStructVal, uclass, "modify BlittableStruct"); Test_SimpleStruct structVal = obj.Struct; structVal.Val0 = true; structVal.Val1 = 1; structVal.Val2 = 2; structVal.Val3 = 3; structVal.Val4 = 4; structVal.Val5 = 5; structVal.Val6 = 6; structVal.Val7 = 7; structVal.Val8 = 8; structVal.Val9 = 9; structVal.Val10 = 10; structVal.Val11.Bind(obj.BindToStructDelegate); structVal.Val12.Bind(obj.BindToStructMulticastDelegate1); structVal.Val12.Bind(obj.BindToStructMulticastDelegate2); structVal.Val12.Bind(obj.BindToStructMulticastDelegate3); structVal.Val13 = other; structVal.Val14 = Test_SimpleEnum.Val3; structVal.Val15 = new Test_SimpleBlittableStruct() { Val1 = 1, Val2 = 2, Val3 = 3, Val4 = 4, Val5 = 5, Val6 = 6, Val7 = 7, Val8 = 8, Val9 = 9, Val10 = 10, Val11 = new FName("Hello world") }; structVal.Val16.SetClass <Test_SimpleStructOnClass>(); structVal.Val17.Set(other); structVal.Val18.Set(obj); structVal.Val19.SetClass <Test_SimpleStructOnClass>(); structVal.Val20.Value = UClass.GetClass <Test_SimpleStructOnClass>(); structVal.Val21 = "Hello!"; structVal.Val22 = new FName("Hello FName"); Tests.Assert(structVal.Val11.IsBound, uclass, ".Val11.IsBound"); Tests.Assert(structVal.Val12.IsBound, uclass, ".Val12.IsBound"); obj.Struct = structVal; //Tests.AssertEqual(obj.Struct, structVal, uclass, "modify Struct"); // We can't test equals of struct value due to new instances of delegates created on each struct marshal // TODO: Replace delegates with structs so they dont require allocation of new managed classes on marshaling Test_SimpleStruct newStructVal = obj.Struct; Tests.AssertEqual(newStructVal.Val0, true, uclass, ".Val0"); Tests.AssertEqual(newStructVal.Val1, 1, uclass, ".Val1"); Tests.AssertEqual(newStructVal.Val2, 2, uclass, ".Val2"); Tests.AssertEqual(newStructVal.Val3, 3, uclass, ".Val3"); Tests.AssertEqual(newStructVal.Val4, 4, uclass, ".Val4"); Tests.AssertEqual(newStructVal.Val5, 5, uclass, ".Val5"); Tests.AssertEqual(newStructVal.Val6, 6u, uclass, ".Val6"); Tests.AssertEqual(newStructVal.Val7, 7, uclass, ".Val7"); Tests.AssertEqual(newStructVal.Val8, 8u, uclass, ".Val8"); Tests.AssertEqual(newStructVal.Val9, 9.0f, uclass, ".Val9"); Tests.AssertEqual(newStructVal.Val10, 10.0, uclass, ".Val10"); //Tests.AssertEqual(newStructVal.Val11, , uclass, ".Val11"); //Tests.AssertEqual(newStructVal.Val12, , uclass, ".Val12"); Tests.AssertEqual(newStructVal.Val13, other, uclass, ".Val13"); Tests.AssertEqual(newStructVal.Val14, Test_SimpleEnum.Val3, uclass, ".Val14"); Tests.AssertEqual(newStructVal.Val15, structVal.Val15, uclass, ".Val15"); Tests.AssertEqual(obj.Struct.Val16.Value, UClass.GetClass <Test_SimpleStructOnClass>(), uclass, ".Val16"); Tests.AssertEqual(obj.Struct.Val17.Get(), other, uclass, ".Val17"); Tests.AssertEqual(obj.Struct.Val18.Get(), obj, uclass, ".Val18"); Tests.AssertEqual(obj.Struct.Val19.Value, UClass.GetClass <Test_SimpleStructOnClass>(), uclass, ".Val19"); Tests.AssertEqual(obj.Struct.Val20.Value, UClass.GetClass <Test_SimpleStructOnClass>(), uclass, ".Val20"); // Test the delegates double param3 = 44.3; string param4; TSoftClass <UObject> someClass = structVal.Val11.Invoke(13, "inParam2", ref param3, out param4); Tests.AssertEqual(param3, 99.88, uclass, ".BindToStructDelegate.param3"); Tests.AssertEqual(param4, "outParam4", uclass, ".BindToStructDelegate.param4"); Tests.AssertEqual(someClass.Value, UClass.GetClass <Test_SimpleStructOnClass>(), uclass, ".BindToStructDelegate." + UFunction.ReturnValuePropName); // Test the multicast delegate int param3Multicast = 1; structVal.Val12.Invoke(3u, "param2", ref param3Multicast); Tests.AssertEqual(param3Multicast, 4, ".BindToStructMulticastDelegate.param3"); }
private static void RunSetTests(Test_CollectionsFuncs obj, UClass unrealClass) { var p1 = new HashSet <long>(); var p2 = new HashSet <UObject>(); var p3 = new HashSet <Test_SimpleEnum>(); var p4 = new HashSet <Test_SimpleBlittableStruct>(); var p5 = new HashSet <TSoftClass <UObject> >(); var p6 = new HashSet <string>(); var p7 = new HashSet <FName>(); Test_CollectionsFuncs.MakeSetTest(p1, p2, p3, p4, p5, p6, p7); // Normal { object[] parameters = { p1, p2, p3, p4, p5, p6, p7 }; UObject.DynamicInvoke(obj, "SetFunc1", parameters); } // Ref { object[] parameters = { p1, p2, p3, p4, p5, p6, p7 }; UObject.DynamicInvoke(obj, "SetFunc2", parameters); } // Ref (starting empty) { p1.Clear(); p2.Clear(); p3.Clear(); p4.Clear(); p5.Clear(); p6.Clear(); p7.Clear(); object[] parameters = { p1, p2, p3, p4, p5, p6, p7 }; UObject.DynamicInvoke(obj, "SetFunc3", parameters); p1 = (HashSet <long>)parameters[0]; p2 = (HashSet <UObject>)parameters[1]; p3 = (HashSet <Test_SimpleEnum>)parameters[2]; p4 = (HashSet <Test_SimpleBlittableStruct>)parameters[3]; p5 = (HashSet <TSoftClass <UObject> >)parameters[4]; p6 = (HashSet <string>)parameters[5]; p7 = (HashSet <FName>)parameters[6]; Test_CollectionsFuncs.AssertSetTest(obj, p1, p2, p3, p4, p5, p6, p7); } // Out { object[] parameters = { null, null, null, null, null, null, null }; UObject.DynamicInvoke(obj, "SetFunc4", parameters); p1 = (HashSet <long>)parameters[0]; p2 = (HashSet <UObject>)parameters[1]; p3 = (HashSet <Test_SimpleEnum>)parameters[2]; p4 = (HashSet <Test_SimpleBlittableStruct>)parameters[3]; p5 = (HashSet <TSoftClass <UObject> >)parameters[4]; p6 = (HashSet <string>)parameters[5]; p7 = (HashSet <FName>)parameters[6]; Test_CollectionsFuncs.AssertSetTest(obj, p1, p2, p3, p4, p5, p6, p7); } // Result { object[] parameters = { "inStr" }; var setResult = (HashSet <TSoftClass <UObject> >)UObject.DynamicInvoke(obj, "SetFunc5", parameters); Tests.Assert(setResult.Contains(TSoftClass <UObject> .Null), unrealClass, "SetFunc5"); Tests.Assert(setResult.Contains(new TSoftClass <UObject>(Tests.ActorClass)), unrealClass, "SetFunc5"); Tests.AssertEqual((string)parameters[0], "outStr", unrealClass, "SetFunc5.param1"); } }
public void BindMeMulti2(ulong param1, string param2, ref int param3) { Tests.Assert(param3 > 1, GetClass(), "BindMeMulti1.param3"); param3 += 3; }
public long Func2( ref sbyte p1, ref byte p2, ref short p3, ref ushort p4, ref int p5, ref uint p6, ref long p7, ref ulong p8, ref float p9, ref double p10, ref Test_SimpleDelegate p11, ref Test_SimpleMulticastDelegate p12, ref UObject p13, ref Test_SimpleEnum p14, ref Test_FixedArrayInStruct p15, ref TSubclassOf <UObject> p16, ref TLazyObject <UObject> p17, ref TWeakObject <UObject> p18, ref TSoftClass <UObject> p19, ref TSoftObject <UObject> p20, ref string p21, ref FName p22) { UClass unrealClass = GetClass(); Tests.AssertEqual(p1, 2, unrealClass, "Func2.p1"); Tests.AssertEqual(p2, 3, unrealClass, "Func2.p2"); Tests.AssertEqual(p3, 4, unrealClass, "Func2.p3"); Tests.AssertEqual(p4, 5, unrealClass, "Func2.p4"); Tests.AssertEqual(p5, 6, unrealClass, "Func2.p5"); Tests.AssertEqual(p6, 7u, unrealClass, "Func2.p6"); Tests.AssertEqual(p7, 8, unrealClass, "Func2.p7"); Tests.AssertEqual(p8, 9u, unrealClass, "Func2.p8"); Tests.AssertEqual(p9, 10.2f, unrealClass, "Func2.p9"); Tests.AssertEqual(p10, 11.5, unrealClass, "Func2.p10"); Tests.Assert(p11.IsBound, unrealClass, "Func2.p11"); Tests.Assert(p12.IsBound, unrealClass, "Func2.p12"); Tests.AssertEqual(p12.Count, 2, unrealClass, "Func2.p12"); Tests.AssertEqual(p13, this, unrealClass, "Func2.p13"); Tests.AssertEqual(p14, Test_SimpleEnum.Val3, unrealClass, "Func2.p14"); Tests.AssertEqual(p15.Array1[0], 2, unrealClass, "Func2.p15"); Tests.AssertEqual(p15.Array1[1], 5, unrealClass, "Func2.p15"); Tests.AssertEqual(p16.Value, unrealClass, unrealClass, "Func2.p16"); Tests.AssertEqual(p17.Value, this, unrealClass, "Func2.p17"); Tests.AssertEqual(p18, TWeakObject <UObject> .Null, unrealClass, "Func2.p18"); Tests.AssertEqual(p19.Value, unrealClass, unrealClass, "Func2.p19"); Tests.AssertEqual(p20.Value, this, unrealClass, "Func2.p20"); Tests.AssertEqual(p21, "Test123", unrealClass, "Func2.p21"); Tests.AssertEqual(p22, new FName("321Test"), unrealClass, "Func2.p22"); double param3 = 4.5; string param4; p11.Invoke(3, "param2", ref param3, out param4); Tests.AssertEqual(param3, 5, unrealClass, "BindMe.param3"); Tests.AssertEqual(param4, "out", unrealClass, "BindMe.param4"); int multiParam3 = 2; p12.Invoke(1, "two", ref multiParam3); Tests.AssertEqual(multiParam3, 7, unrealClass, "BindMeMulti.param3"); UClass actorClass = GetActorClass(); p1++; p2++; p3++; p4++; p5++; p6++; p7++; p8++; p9++; p10++; p11.Clear(); p12.Bind(BindMeMulti3); p13 = actorClass; p14 = Test_SimpleEnum.Val2; p15.Array1[2] = 100; p16.SetClass(actorClass); p17.Value = actorClass; p18.Value = actorClass; p19.Value = actorClass; p20.Value = actorClass; p21 = "changed123"; p22 = new FName("321changed"); return(13232); }
public long Func1( sbyte p1, byte p2, short p3, ushort p4, int p5, uint p6, long p7, ulong p8, float p9, double p10, Test_SimpleDelegate p11, Test_SimpleMulticastDelegate p12, UObject p13, Test_SimpleEnum p14, Test_FixedArrayInStruct p15, TSubclassOf <UObject> p16, TLazyObject <UObject> p17, TWeakObject <UObject> p18, TSoftClass <UObject> p19, TSoftObject <UObject> p20, string p21, FName p22) { UClass unrealClass = GetClass(); Tests.AssertEqual(p1, 2, unrealClass, "Func1.p1"); Tests.AssertEqual(p2, 3, unrealClass, "Func1.p2"); Tests.AssertEqual(p3, 4, unrealClass, "Func1.p3"); Tests.AssertEqual(p4, 5, unrealClass, "Func1.p4"); Tests.AssertEqual(p5, 6, unrealClass, "Func1.p5"); Tests.AssertEqual(p6, 7u, unrealClass, "Func1.p6"); Tests.AssertEqual(p7, 8, unrealClass, "Func1.p7"); Tests.AssertEqual(p8, 9u, unrealClass, "Func1.p8"); Tests.AssertEqual(p9, 10.2f, unrealClass, "Func1.p9"); Tests.AssertEqual(p10, 11.5, unrealClass, "Func1.p10"); Tests.Assert(p11.IsBound, unrealClass, "Func1.p11"); Tests.Assert(p12.IsBound, unrealClass, "Func1.p12"); Tests.AssertEqual(p12.Count, 2, unrealClass, "Func1.p12"); Tests.AssertEqual(p13, this, unrealClass, "Func1.p13"); Tests.AssertEqual(p14, Test_SimpleEnum.Val3, unrealClass, "Func1.p14"); Tests.AssertEqual(p15.Array1[0], 2, unrealClass, "Func1.p15"); Tests.AssertEqual(p15.Array1[1], 5, unrealClass, "Func1.p15"); Tests.AssertEqual(p16.Value, unrealClass, unrealClass, "Func1.p16"); Tests.AssertEqual(p17.Value, this, unrealClass, "Func1.p17"); Tests.AssertEqual(p18, TWeakObject <UObject> .Null, unrealClass, "Func1.p18"); Tests.AssertEqual(p19.Value, unrealClass, unrealClass, "Func1.p19"); Tests.AssertEqual(p20.Value, this, unrealClass, "Func1.p20"); Tests.AssertEqual(p21, "Test123", unrealClass, "Func1.p21"); Tests.AssertEqual(p22, new FName("321Test"), unrealClass, "Func1.p22"); double param3 = 4.5; string param4; p11.Invoke(3, "param2", ref param3, out param4); Tests.AssertEqual(param3, 5, unrealClass, "BindMe.param3"); Tests.AssertEqual(param4, "out", unrealClass, "BindMe.param4"); int multiParam3 = 2; p12.Invoke(1, "two", ref multiParam3); Tests.AssertEqual(multiParam3, 7, unrealClass, "BindMeMulti.param3"); return(13232); }
public static void Run() { UClass unrealClass = UClass.GetClass <Test_SimpleClassTMap>(); Tests.Assert(unrealClass != null, "Test_SimpleClassTMap"); Tests.AssertTMapProperty <UInt8Property, UNameProperty>(unrealClass, "Val1"); Tests.AssertTMapProperty <UByteProperty, UStrProperty>(unrealClass, "Val2"); Tests.AssertTMapProperty <UInt16Property, USoftObjectProperty>(unrealClass, "Val3"); Tests.AssertTMapProperty <UUInt16Property, USoftClassProperty>(unrealClass, "Val4"); Tests.AssertTMapProperty <UIntProperty, USoftClassProperty>(unrealClass, "Val5"); Tests.AssertTMapProperty <UUInt32Property, UWeakObjectProperty>(unrealClass, "Val6"); Tests.AssertTMapProperty <UInt64Property, ULazyObjectProperty>(unrealClass, "Val7"); Tests.AssertTMapProperty <UUInt64Property, UClassProperty>(unrealClass, "Val8"); Tests.AssertTMapProperty <UFloatProperty, UStructProperty>(unrealClass, "Val9"); Tests.AssertTMapProperty <UDoubleProperty, UEnumProperty>(unrealClass, "Val10"); //Tests.AssertTMapProperty<UDelegateProperty, UObjectProperty>(unrealClass, "Val11"); //Tests.AssertTMapProperty<UMulticastDelegateProperty, UMulticastDelegateProperty>(unrealClass, "Val12"); Tests.AssertTMapProperty <UObjectProperty, UDelegateProperty>(unrealClass, "Val13"); Tests.AssertTMapProperty <UEnumProperty, UDoubleProperty>(unrealClass, "Val14"); Tests.AssertTMapProperty <UStructProperty, UFloatProperty>(unrealClass, "Val15"); Tests.AssertTMapProperty <UClassProperty, UUInt64Property>(unrealClass, "Val16"); Tests.AssertTMapProperty <ULazyObjectProperty, UInt64Property>(unrealClass, "Val17"); //Tests.AssertTMapProperty<UWeakObjectProperty, UUInt32Property>(unrealClass, "Val18"); Tests.AssertTMapProperty <USoftClassProperty, UIntProperty>(unrealClass, "Val19"); Tests.AssertTMapProperty <USoftObjectProperty, UUInt16Property>(unrealClass, "Val20"); Tests.AssertTMapProperty <UStrProperty, UInt16Property>(unrealClass, "Val21"); Tests.AssertTMapProperty <UNameProperty, UByteProperty>(unrealClass, "Val22"); //Tests.AssertTSetProperty<UTextProperty>(unrealClass, "Val23"); Test_SimpleClassTMap obj = NewObject <Test_SimpleClassTMap>(); obj.Val1.Add(100, new FName("test1")); Tests.AssertEqual(obj.Val1[100], new FName("test1"), unrealClass, "Val1"); obj.Val1.Add(101, new FName("test2")); Tests.AssertEqual(obj.Val1[101], new FName("test2"), unrealClass, "Val1"); obj.Val1.Add(101, new FName("test3")); IDictionary <sbyte, FName> test = obj.Val1; Tests.AssertEqual(obj.Val1[101], new FName("test3"), unrealClass, "Val1"); Tests.AssertEqual(obj.Val1.Count, 2, unrealClass, "Val1"); obj.Val1.Remove(101); Tests.AssertEqual(obj.Val1.Count, 1, unrealClass, "Val1"); obj.Val1.Clear(); Tests.AssertEqual(obj.Val1.Count, 0, unrealClass, "Val1"); obj.Val2.Add(102, "test4"); obj.Val2.Add(103, "test5"); Tests.AssertEqual(obj.Val2[102], "test4", unrealClass, "Val2"); Tests.AssertEqual(obj.Val2[103], "test5", unrealClass, "Val2"); Tests.AssertEqual(obj.Val2.Count, 2, unrealClass, "Val2"); obj.Val3.Add(103, new TSoftObject <UObject>(Tests.ActorClass)); obj.Val3.Add(104, TSoftObject <UObject> .Null); Tests.AssertEqual(obj.Val3[103], new TSoftObject <UObject>(Tests.ActorClass), unrealClass, "Val3"); Tests.AssertEqual(obj.Val3[104], TSoftObject <UObject> .Null, unrealClass, "Val3"); obj.Val3[103] = TSoftObject <UObject> .Null; obj.Val3[104] = new TSoftObject <UObject>(Tests.ActorClass); Tests.AssertEqual(obj.Val3[103], TSoftObject <UObject> .Null, unrealClass, "Val3"); Tests.AssertEqual(obj.Val3[104], new TSoftObject <UObject>(Tests.ActorClass), unrealClass, "Val3"); obj.Val4.Add(105, new TSoftClass <UObject>(Tests.ActorClass)); obj.Val4.Add(106, TSoftClass <UObject> .Null); Tests.AssertEqual(obj.Val4[105], new TSoftClass <UObject>(Tests.ActorClass), unrealClass, "Val4"); Tests.AssertEqual(obj.Val4[106], TSoftClass <UObject> .Null, unrealClass, "Val4"); obj.Val5.Add(107, new TSoftClass <UObject>(Tests.ActorClass)); obj.Val5.Add(108, TSoftClass <UObject> .Null); Tests.AssertEqual(obj.Val5[107], new TSoftClass <UObject>(Tests.ActorClass), unrealClass, "Val5"); Tests.AssertEqual(obj.Val5[108], TSoftClass <UObject> .Null, unrealClass, "Val5"); obj.Val6.Add(109, new TWeakObject <UObject>(Tests.ActorClass)); obj.Val6.Add(110, TWeakObject <UObject> .Null); Tests.AssertEqual(obj.Val6[109], new TWeakObject <UObject>(Tests.ActorClass), unrealClass, "Val6"); Tests.AssertEqual(obj.Val6[110], TWeakObject <UObject> .Null, unrealClass, "Val6"); obj.Val7.Add(111, new TLazyObject <UObject>(Tests.ActorClass)); obj.Val7.Add(112, TLazyObject <UObject> .Null); Tests.AssertEqual(obj.Val7[111], new TLazyObject <UObject>(Tests.ActorClass), unrealClass, "Val7"); Tests.AssertEqual(obj.Val7[112], TLazyObject <UObject> .Null, unrealClass, "Val7"); obj.Val8.Add(113, new TSubclassOf <UObject>(Tests.ActorClass)); obj.Val8.Add(114, TSubclassOf <UObject> .Null); Tests.AssertEqual(obj.Val8[113], new TSubclassOf <UObject>(Tests.ActorClass), unrealClass, "Val8"); Tests.AssertEqual(obj.Val8[114], TSubclassOf <UObject> .Null, unrealClass, "Val8"); Test_SimpleBlittableStruct blitt1 = StructDefault <Test_SimpleBlittableStruct> .Value; blitt1.Val1 = 10; blitt1.Val2 = 11; obj.Val9.Add(115.5f, blitt1); obj.Val9.Add(116.5f, default(Test_SimpleBlittableStruct)); Tests.AssertEqual(obj.Val9[115.5f], blitt1, unrealClass, "Val9"); Tests.AssertEqual(obj.Val9[116.5f], default(Test_SimpleBlittableStruct), unrealClass, "Val9"); obj.Val10.Add(117.2, Test_SimpleEnum.Val2); obj.Val10.Add(118.2, Test_SimpleEnum.Val3); Tests.AssertEqual(obj.Val10[117.2], Test_SimpleEnum.Val2, unrealClass, "Val10"); Tests.AssertEqual(obj.Val10[118.2], Test_SimpleEnum.Val3, unrealClass, "Val10"); Test_SimpleDelegate simpleDelegate = new Test_SimpleDelegate(); simpleDelegate.Bind(obj.BindSimpleDelegate); obj.Val13.Add(Tests.ActorClass, simpleDelegate); obj.Val13.Add(null, null); Tests.Assert(obj.Val13[Tests.ActorClass].IsTargetBound(obj, new FName("BindSimpleDelegate")), unrealClass, "Val13"); Tests.Assert(!obj.Val13[null].IsBound, unrealClass, "Val13"); obj.Val14.Add(Test_SimpleEnum.Val3, 0.3); obj.Val14.Add(Test_SimpleEnum.Val2, 0.6); Tests.AssertEqual(obj.Val14[Test_SimpleEnum.Val3], 0.3, unrealClass, "Val14"); Tests.AssertEqual(obj.Val14[Test_SimpleEnum.Val2], 0.6, unrealClass, "Val14"); obj.Val15.Add(blitt1, 0.4f); obj.Val15.Add(default(Test_SimpleBlittableStruct), 0.8f); Tests.AssertEqual(obj.Val15[blitt1], 0.4f, unrealClass, "Val15"); Tests.AssertEqual(obj.Val15[default(Test_SimpleBlittableStruct)], 0.8f, unrealClass, "Val15"); obj.Val16.Add(new TSubclassOf <UObject>(Tests.ActorClass), 22u); obj.Val16.Add(TSubclassOf <UObject> .Null, 24u); Tests.AssertEqual(obj.Val16[new TSubclassOf <UObject>(Tests.ActorClass)], 22u, unrealClass, "Val16"); Tests.AssertEqual(obj.Val16[TSubclassOf <UObject> .Null], 24u, unrealClass, "Val16"); obj.Val17.Add(new TLazyObject <UObject>(Tests.ActorClass), 25); obj.Val17.Add(TLazyObject <UObject> .Null, 26); Tests.AssertEqual(obj.Val17[new TLazyObject <UObject>(Tests.ActorClass)], 25, unrealClass, "Val17"); Tests.AssertEqual(obj.Val17[TLazyObject <UObject> .Null], 26, unrealClass, "Val17"); obj.Val19.Add(new TSoftClass <UObject>(Tests.ActorClass), 29); obj.Val19.Add(TSoftClass <UObject> .Null, 30); Tests.AssertEqual(obj.Val19[new TSoftClass <UObject>(Tests.ActorClass)], 29, unrealClass, "Val19"); Tests.AssertEqual(obj.Val19[TSoftClass <UObject> .Null], 30, unrealClass, "Val19"); obj.Val20.Add(new TSoftObject <UObject>(Tests.ActorClass), 31); obj.Val20.Add(TSoftObject <UObject> .Null, 32); Tests.AssertEqual(obj.Val20[new TSoftObject <UObject>(Tests.ActorClass)], 31, unrealClass, "Val20"); Tests.AssertEqual(obj.Val20[TSoftObject <UObject> .Null], 32, unrealClass, "Val20"); obj.Val21.Add("test1", 33); obj.Val21.Add("test2", 34); Tests.AssertEqual(obj.Val21["test1"], 33, unrealClass, "Val21"); Tests.AssertEqual(obj.Val21["test2"], 34, unrealClass, "Val21"); obj.Val22.Add(new FName("test3"), 35); obj.Val22.Add(new FName("test4"), 36); Tests.AssertEqual(obj.Val22[new FName("test3")], 35, unrealClass, "Val22"); Tests.AssertEqual(obj.Val22[new FName("test4")], 36, unrealClass, "Val22"); }
public static void Run() { // Another object for testing Test_SimpleClass1 otherObj = UObject.NewObject <Test_SimpleClass1>(); UClass unrealClass = UClass.GetClass <Test_FixedArrayInClass>(); Tests.Assert(unrealClass != null, "Test_FixedArrayInClass"); Tests.AssertFixedArrayProperty <UInt8Property>(unrealClass, "Array1", 3); Tests.AssertFixedArrayProperty <UByteProperty>(unrealClass, "Array2", 4); Tests.AssertFixedArrayProperty <UInt16Property>(unrealClass, "Array3", 5); Tests.AssertFixedArrayProperty <UUInt16Property>(unrealClass, "Array4", 6); Tests.AssertFixedArrayProperty <UIntProperty>(unrealClass, "Array5", 7); Tests.AssertFixedArrayProperty <UUInt32Property>(unrealClass, "Array6", 8); Tests.AssertFixedArrayProperty <UInt64Property>(unrealClass, "Array7", 9); Tests.AssertFixedArrayProperty <UUInt64Property>(unrealClass, "Array8", 10); Tests.AssertFixedArrayProperty <UFloatProperty>(unrealClass, "Array9", 11); Tests.AssertFixedArrayProperty <UDoubleProperty>(unrealClass, "Array10", 12); Tests.AssertFixedArrayProperty <UDelegateProperty>(unrealClass, "Array11", 13); Tests.AssertFixedArrayProperty <UMulticastDelegateProperty>(unrealClass, "Array12", 14); Tests.AssertFixedArrayProperty <UObjectProperty>(unrealClass, "Array13", 15); Tests.AssertFixedArrayProperty <UEnumProperty>(unrealClass, "Array14", 16); Tests.AssertFixedArrayProperty <UStructProperty>(unrealClass, "Array15", 17); Tests.AssertFixedArrayProperty <UClassProperty>(unrealClass, "Array16", 18); Tests.AssertFixedArrayProperty <ULazyObjectProperty>(unrealClass, "Array17", 19); Tests.AssertFixedArrayProperty <UWeakObjectProperty>(unrealClass, "Array18", 20); Tests.AssertFixedArrayProperty <USoftClassProperty>(unrealClass, "Array19", 21); Tests.AssertFixedArrayProperty <USoftObjectProperty>(unrealClass, "Array20", 22); Tests.AssertFixedArrayProperty <UStrProperty>(unrealClass, "Array21", 23); Tests.AssertFixedArrayProperty <UNameProperty>(unrealClass, "Array22", 24); //Tests.AssertFixedArrayProperty<UTextProperty>(unrealClass, "Array23", 25); Test_FixedArrayInClass obj = UObject.NewObject <Test_FixedArrayInClass>(); Tests.AssertEqual(obj.Array1.Length, 3, unrealClass, ".Array1"); Tests.AssertEqual(obj.Array2.Length, 4, unrealClass, ".Array2"); Tests.AssertEqual(obj.Array3.Length, 5, unrealClass, ".Array3"); Tests.AssertEqual(obj.Array4.Length, 6, unrealClass, ".Array4"); Tests.AssertEqual(obj.Array5.Length, 7, unrealClass, ".Array5"); Tests.AssertEqual(obj.Array6.Length, 8, unrealClass, ".Array6"); Tests.AssertEqual(obj.Array7.Length, 9, unrealClass, ".Array7"); Tests.AssertEqual(obj.Array8.Length, 10, unrealClass, ".Array8"); Tests.AssertEqual(obj.Array9.Length, 11, unrealClass, ".Array9"); Tests.AssertEqual(obj.Array10.Length, 12, unrealClass, ".Array10"); Tests.AssertEqual(obj.Array11.Length, 13, unrealClass, ".Array11"); Tests.AssertEqual(obj.Array12.Length, 14, unrealClass, ".Array12"); Tests.AssertEqual(obj.Array13.Length, 15, unrealClass, ".Array13"); Tests.AssertEqual(obj.Array14.Length, 16, unrealClass, ".Array14"); Tests.AssertEqual(obj.Array15.Length, 17, unrealClass, ".Array15"); Tests.AssertEqual(obj.Array16.Length, 18, unrealClass, ".Array16"); Tests.AssertEqual(obj.Array17.Length, 19, unrealClass, ".Array17"); Tests.AssertEqual(obj.Array18.Length, 20, unrealClass, ".Array18"); Tests.AssertEqual(obj.Array19.Length, 21, unrealClass, ".Array19"); Tests.AssertEqual(obj.Array20.Length, 22, unrealClass, ".Array20"); Tests.AssertEqual(obj.Array21.Length, 23, unrealClass, ".Array21"); Tests.AssertEqual(obj.Array22.Length, 24, unrealClass, ".Array22"); BeginMember("Array1"); for (int i = 0; i < obj.Array1.Length; i++) { Tests.AssertEqual(obj.Array1[i], 0, unrealClass, currentMemberName); obj.Array1[i] += 5; Tests.AssertEqual(obj.Array1[i], 5, unrealClass, currentMemberName); obj.Array1[i] += 10; Tests.AssertEqual(obj.Array1[i], 15, unrealClass, currentMemberName); } BeginMember("Array2"); for (int i = 0; i < obj.Array2.Length; i++) { Tests.AssertEqual(obj.Array2[i], 0, unrealClass, currentMemberName); obj.Array2[i] += 8; Tests.AssertEqual(obj.Array2[i], 8, unrealClass, currentMemberName); obj.Array2[i] += 3; Tests.AssertEqual(obj.Array2[i], 11, unrealClass, currentMemberName); } BeginMember("Array3"); for (int i = 0; i < obj.Array2.Length; i++) { Tests.AssertEqual(obj.Array3[i], 0, unrealClass, currentMemberName); obj.Array3[i] += 4; Tests.AssertEqual(obj.Array3[i], 4, unrealClass, currentMemberName); obj.Array3[i] += 5; Tests.AssertEqual(obj.Array3[i], 9, unrealClass, currentMemberName); } BeginMember("Array4"); for (int i = 0; i < obj.Array4.Length; i++) { Tests.AssertEqual(obj.Array4[i], 0, unrealClass, currentMemberName); obj.Array4[i] += 7; Tests.AssertEqual(obj.Array4[i], 7, unrealClass, currentMemberName); obj.Array4[i] += 3; Tests.AssertEqual(obj.Array4[i], 10, unrealClass, currentMemberName); } BeginMember("Array5"); for (int i = 0; i < obj.Array5.Length; i++) { Tests.AssertEqual(obj.Array5[i], 0, unrealClass, currentMemberName); obj.Array5[i] += 2; Tests.AssertEqual(obj.Array5[i], 2, unrealClass, currentMemberName); obj.Array5[i] += 6; Tests.AssertEqual(obj.Array5[i], 8, unrealClass, currentMemberName); } BeginMember("Array6"); for (int i = 0; i < obj.Array6.Length; i++) { Tests.AssertEqual(obj.Array6[i], 0u, unrealClass, currentMemberName); obj.Array6[i] += 3; Tests.AssertEqual(obj.Array6[i], 3u, unrealClass, currentMemberName); obj.Array6[i] += 7; Tests.AssertEqual(obj.Array6[i], 10u, unrealClass, currentMemberName); } BeginMember("Array7"); for (int i = 0; i < obj.Array7.Length; i++) { Tests.AssertEqual(obj.Array7[i], 0, unrealClass, currentMemberName); obj.Array7[i] += 1; Tests.AssertEqual(obj.Array7[i], 1, unrealClass, currentMemberName); obj.Array7[i] += 1; Tests.AssertEqual(obj.Array7[i], 2, unrealClass, currentMemberName); } BeginMember("Array8"); for (int i = 0; i < obj.Array8.Length; i++) { Tests.AssertEqual(obj.Array8[i], 0u, unrealClass, currentMemberName); obj.Array8[i] += 3; Tests.AssertEqual(obj.Array8[i], 3u, unrealClass, currentMemberName); obj.Array8[i] += 6; Tests.AssertEqual(obj.Array8[i], 9u, unrealClass, currentMemberName); } BeginMember("Array9"); for (int i = 0; i < obj.Array9.Length; i++) { Tests.AssertEqual(obj.Array9[i], 0, unrealClass, currentMemberName); obj.Array9[i] += 1.5f; Tests.AssertEqual(obj.Array9[i], 1.5f, unrealClass, currentMemberName); obj.Array9[i] += 2.3f; Tests.AssertEqual(obj.Array9[i], 3.8f, unrealClass, currentMemberName); } BeginMember("Array10"); for (int i = 0; i < obj.Array10.Length; i++) { Tests.AssertEqual(obj.Array10[i], 0, unrealClass, currentMemberName); obj.Array10[i] += 3.1; Tests.AssertEqual(obj.Array10[i], 3.1, unrealClass, currentMemberName); obj.Array10[i] += 1.1; Tests.AssertEqual(obj.Array10[i], 4.2, unrealClass, currentMemberName); } BeginMember("Array11"); for (int i = 0; i < obj.Array11.Length; i++) { // Need to read the delegate, modify the state and write it back (can't modify directly // since each access to the array index will return a new delegate) - (this is because if the // delegate held onto the collection index address there is no guarantee it still sits at that address // as the collection changes) - (for fixed arrays this is valid but fixed arrays are going to be // rarely used anyway so it isn't really worth working in any improvement for it) var del = obj.Array11[i]; Tests.Assert(!del.IsBound, unrealClass, currentMemberName); del.Bind(obj.SimpleFunc); Tests.Assert(del.IsBound, unrealClass, currentMemberName); obj.Array11[i] = del; int arg = 3; obj.Array11[i].Invoke(ref arg); Tests.AssertEqual(arg, 4, unrealClass, currentMemberName); } BeginMember("Array12"); for (int i = 0; i < obj.Array12.Length; i++) { var del = obj.Array12[i]; Tests.Assert(!del.IsBound, unrealClass, currentMemberName); del.Bind(obj.SimpleFunc1); del.Bind(obj.SimpleFunc2); Tests.Assert(del.IsBound, unrealClass, currentMemberName); Tests.Assert(del.Count == 2, unrealClass, currentMemberName); obj.Array12[i] = del; double arg = 0.5; obj.Array12[i].Invoke(ref arg); Tests.AssertEqual(arg, 2.6, unrealClass, currentMemberName); } BeginMember("Array13"); for (int i = 0; i < obj.Array13.Length; i++) { Tests.AssertEqual(obj.Array13[i], null, unrealClass, currentMemberName); } obj.Array13[0] = obj; obj.Array13[3] = otherObj; Tests.AssertEqual(obj.Array13[0], obj, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array13[3], otherObj, unrealClass, currentMemberName); for (int i = 0; i < obj.Array13.Length; i++) { if (i != 0 && i != 3) { Tests.AssertEqual(obj.Array13[i], null, unrealClass, currentMemberName); } } obj.Array13[0] = null; obj.Array13[3] = null; for (int i = 0; i < obj.Array13.Length; i++) { Tests.AssertEqual(obj.Array13[i], null, unrealClass, currentMemberName); } BeginMember("Array14"); for (int i = 0; i < obj.Array14.Length; i++) { Tests.AssertEqual(obj.Array14[i], default(Test_SimpleEnum), unrealClass, currentMemberName); } obj.Array14[1] = Test_SimpleEnum.Val3; obj.Array14[4] = Test_SimpleEnum.Val2; Tests.AssertEqual(obj.Array14[1], Test_SimpleEnum.Val3, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array14[4], Test_SimpleEnum.Val2, unrealClass, currentMemberName); for (int i = 0; i < obj.Array13.Length; i++) { if (i != 1 && i != 4) { Tests.AssertEqual(obj.Array14[i], default(Test_SimpleEnum), unrealClass, currentMemberName); } } // This is going to be slow, it has do an entire copy of the struct (which has many arrays which // need to be fully copied) BeginMember("Array15"); // Read the struct at index 0, modify state, write it back, then validate var v1 = obj.Array15[0]; v1.Array5[3] = 1; v1.Array5[4] = 2; v1.Array7[5] = 3; v1.Array7[6] = 4; obj.Array15[0] = v1; v1 = obj.Array15[0]; Tests.AssertEqual(v1.Array5[1], 0, unrealClass, currentMemberName); Tests.AssertEqual(v1.Array5[3], 1, unrealClass, currentMemberName); Tests.AssertEqual(v1.Array5[4], 2, unrealClass, currentMemberName); Tests.AssertEqual(v1.Array7[1], 0, unrealClass, currentMemberName); Tests.AssertEqual(v1.Array7[5], 3, unrealClass, currentMemberName); Tests.AssertEqual(v1.Array7[6], 4, unrealClass, currentMemberName); BeginMember("Array16"); for (int i = 0; i < obj.Array16.Length; i++) { Tests.AssertEqual(obj.Array16[i].Value, null, unrealClass, currentMemberName); } // same test but two different ways of doing the assignment var subclassOf = obj.Array16[1]; subclassOf.Value = UClass.GetClass <Test_FixedArrayInClass>(); obj.Array16[1] = subclassOf; Tests.AssertEqual(obj.Array16[1].Value, UClass.GetClass <Test_FixedArrayInClass>(), unrealClass, currentMemberName); obj.Array16[2] = new TSubclassOf <UObject>(UClass.GetClass <Test_SimpleClass1>()); Tests.AssertEqual(obj.Array16[2].Value, UClass.GetClass <Test_SimpleClass1>(), unrealClass, currentMemberName); obj.Array16[1] = TSubclassOf <UObject> .Null; obj.Array16[2] = TSubclassOf <UObject> .Null; Tests.AssertEqual(obj.Array16[1].Value, null, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array16[2].Value, null, unrealClass, currentMemberName); BeginMember("Array17"); for (int i = 0; i < obj.Array17.Length; i++) { Tests.AssertEqual(obj.Array17[i].Value, null, unrealClass, currentMemberName); } // same test but two different ways of doing the assignment var lazyObject = obj.Array17[3]; lazyObject.Value = obj; obj.Array17[3] = lazyObject; Tests.AssertEqual(obj.Array17[3].Value, obj, unrealClass, currentMemberName); obj.Array17[4] = new TLazyObject <UObject>(otherObj); Tests.AssertEqual(obj.Array17[4].Value, otherObj, unrealClass, currentMemberName); obj.Array17[3] = TLazyObject <UObject> .Null; obj.Array17[4] = TLazyObject <UObject> .Null; Tests.AssertEqual(obj.Array17[3].Value, null, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array17[4].Value, null, unrealClass, currentMemberName); BeginMember("Array18"); for (int i = 0; i < obj.Array18.Length; i++) { Tests.AssertEqual(obj.Array18[i].Value, null, unrealClass, currentMemberName); } var weakObject = obj.Array18[5]; weakObject.Value = otherObj; obj.Array18[5] = weakObject; Tests.AssertEqual(obj.Array18[5].Value, otherObj, unrealClass, currentMemberName); obj.Array18[6] = new TWeakObject <UObject>(obj); Tests.AssertEqual(obj.Array18[6].Value, obj, unrealClass, currentMemberName); obj.Array18[5] = TWeakObject <UObject> .Null; obj.Array18[6] = TWeakObject <UObject> .Null; Tests.AssertEqual(obj.Array18[5].Value, null, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array18[6].Value, null, unrealClass, currentMemberName); BeginMember("Array19"); for (int i = 0; i < obj.Array19.Length; i++) { Tests.AssertEqual(obj.Array19[i].Value, null, unrealClass, currentMemberName); } var softclassOf = obj.Array19[7]; softclassOf.Value = UClass.GetClass <Test_FixedArrayInClass>(); obj.Array19[7] = softclassOf; Tests.AssertEqual(obj.Array19[7].Value, UClass.GetClass <Test_FixedArrayInClass>(), unrealClass, currentMemberName); obj.Array19[8] = new TSoftClass <UObject>(UClass.GetClass <Test_SimpleClass1>()); Tests.AssertEqual(obj.Array19[8].Value, UClass.GetClass <Test_SimpleClass1>(), unrealClass, currentMemberName); obj.Array19[7] = TSoftClass <UObject> .Null; obj.Array19[8] = TSoftClass <UObject> .Null; Tests.AssertEqual(obj.Array19[7].Value, null, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array19[8].Value, null, unrealClass, currentMemberName); BeginMember("Array20"); for (int i = 0; i < obj.Array20.Length; i++) { Tests.AssertEqual(obj.Array20[i].Value, null, unrealClass, currentMemberName); } var softObject = obj.Array20[9]; softObject.Value = UClass.GetClass <Test_FixedArrayInClass>(); obj.Array20[9] = softObject; Tests.AssertEqual(obj.Array20[9].Value, UClass.GetClass <Test_FixedArrayInClass>(), unrealClass, currentMemberName); obj.Array20[10] = new TSoftObject <UObject>(UClass.GetClass <Test_SimpleClass1>()); Tests.AssertEqual(obj.Array20[10].Value, UClass.GetClass <Test_SimpleClass1>(), unrealClass, currentMemberName); obj.Array20[9] = TSoftObject <UObject> .Null; obj.Array20[10] = TSoftObject <UObject> .Null; Tests.AssertEqual(obj.Array20[9].Value, null, unrealClass, currentMemberName); Tests.AssertEqual(obj.Array20[10].Value, null, unrealClass, currentMemberName); BeginMember("Array21"); for (int i = 0; i < obj.Array21.Length; i++) { Tests.AssertEqual(obj.Array21[i], string.Empty, unrealClass, currentMemberName); } obj.Array21[2] = "Str1"; Tests.AssertEqual(obj.Array21[2], "Str1", unrealClass, currentMemberName); obj.Array21[2] = null;// null will be "" when read back Tests.AssertEqual(obj.Array21[2], string.Empty, unrealClass, currentMemberName); obj.Array21[3] = "Str2"; Tests.AssertEqual(obj.Array21[3], "Str2", unrealClass, currentMemberName); obj.Array21[3] = ""; Tests.AssertEqual(obj.Array21[3], "", unrealClass, currentMemberName); BeginMember("Array22"); for (int i = 0; i < obj.Array22.Length; i++) { Tests.AssertEqual(obj.Array22[i], FName.None, unrealClass, currentMemberName); } obj.Array22[4] = new FName("Name1"); Tests.AssertEqual(obj.Array22[4], new FName("Name1"), unrealClass, currentMemberName); obj.Array22[4] = default(FName);// Same as FName.None Tests.AssertEqual(obj.Array22[4], FName.None, unrealClass, currentMemberName); obj.Array22[5] = new FName("Name2"); Tests.AssertEqual(obj.Array22[5], new FName("Name2"), unrealClass, currentMemberName); obj.Array22[5] = new FName("Name2Changed"); Tests.AssertEqual(obj.Array22[5], new FName("Name2Changed"), unrealClass, currentMemberName); RunParamTests(obj); }
private static void TestFuncX(Test_SimpleFuncs obj, UClass unrealClass, int func) { string funcName = "Func" + func; UFunction func1 = unrealClass.FindFunctionByName(new FName(funcName)); Tests.AssertNotNull(func1, unrealClass, funcName); Test_SimpleDelegate simpleDelegate = new Test_SimpleDelegate(); simpleDelegate.Bind(obj.BindMe); Test_SimpleMulticastDelegate multicastDelegate = new Test_SimpleMulticastDelegate(); multicastDelegate.Bind(obj.BindMeMulti1); multicastDelegate.Bind(obj.BindMeMulti2); // Use dynamic invoke so that all parameters go through a full marshal between C#/native code object[] parameters = { (sbyte)2, //sbyte (byte)3, //byte, (short)4, //short (ushort)5, //ushort (int)6, //int (uint)7, //uint (long)8, //long (ulong)9, //ulong (float)10.2f, //float (double)11.5, //double simpleDelegate, //delegate multicastDelegate, //multicast delegate obj, Test_SimpleEnum.Val3, new Test_FixedArrayInStruct() { Array1 = new sbyte[2] { 2, 5 } }, new TSubclassOf <UObject>(obj.GetClass()), new TLazyObject <UObject>(obj), TWeakObject <UObject> .Null, new TSoftClass <UObject>(obj.GetClass()), new TSoftObject <UObject>(obj), "Test123", new FName("321Test") }; long result = (long)UObject.DynamicInvoke(obj, funcName, parameters); Tests.AssertEqual(result, 13232, unrealClass, funcName + " result"); if (func > 1) { sbyte p1 = (sbyte)parameters[0]; byte p2 = (byte)parameters[1]; short p3 = (short)parameters[2]; ushort p4 = (ushort)parameters[3]; int p5 = (int)parameters[4]; uint p6 = (uint)parameters[5]; long p7 = (long)parameters[6]; ulong p8 = (ulong)parameters[7]; float p9 = (float)parameters[8]; double p10 = (double)parameters[9]; Test_SimpleDelegate p11 = (Test_SimpleDelegate)parameters[10]; Test_SimpleMulticastDelegate p12 = (Test_SimpleMulticastDelegate)parameters[11]; UObject p13 = (UObject)parameters[12]; Test_SimpleEnum p14 = (Test_SimpleEnum)parameters[13]; Test_FixedArrayInStruct p15 = (Test_FixedArrayInStruct)parameters[14]; TSubclassOf <UObject> p16 = (TSubclassOf <UObject>)parameters[15]; TLazyObject <UObject> p17 = (TLazyObject <UObject>)parameters[16]; TWeakObject <UObject> p18 = (TWeakObject <UObject>)parameters[17]; TSoftClass <UObject> p19 = (TSoftClass <UObject>)parameters[18]; TSoftObject <UObject> p20 = (TSoftObject <UObject>)parameters[19]; string p21 = (string)parameters[20]; FName p22 = (FName)parameters[21]; UClass actorClass = GetActorClass(); Tests.AssertEqual(p1, 3, unrealClass, funcName + ".p1"); Tests.AssertEqual(p2, 4, unrealClass, funcName + ".p2"); Tests.AssertEqual(p3, 5, unrealClass, funcName + ".p3"); Tests.AssertEqual(p4, 6, unrealClass, funcName + ".p4"); Tests.AssertEqual(p5, 7, unrealClass, funcName + ".p5"); Tests.AssertEqual(p6, 8u, unrealClass, funcName + ".p6"); Tests.AssertEqual(p7, 9, unrealClass, funcName + ".p7"); Tests.AssertEqual(p8, 10u, unrealClass, funcName + ".p8"); Tests.AssertEqual(p9, 11.2f, unrealClass, funcName + ".p9"); Tests.AssertEqual(p10, 12.5, unrealClass, funcName + ".p10"); Tests.Assert(!p11.IsBound, unrealClass, funcName + ".p11"); Tests.Assert(p12.IsBound, unrealClass, funcName + ".p12"); Tests.AssertEqual(p12.Count, 3, unrealClass, funcName + ".p12"); Tests.AssertEqual(p13, actorClass, unrealClass, funcName + ".p13"); Tests.AssertEqual(p14, Test_SimpleEnum.Val2, unrealClass, funcName + ".p14"); Tests.AssertEqual(p15.Array1[0], 2, unrealClass, funcName + ".p15"); Tests.AssertEqual(p15.Array1[1], 5, unrealClass, funcName + ".p15"); Tests.AssertEqual(p15.Array1[2], 100, unrealClass, funcName + ".p15"); Tests.AssertEqual(p16.Value, actorClass, unrealClass, funcName + ".p16"); Tests.AssertEqual(p17.Value, actorClass, unrealClass, funcName + ".p17"); Tests.AssertEqual(p18.Value, actorClass, unrealClass, funcName + ".p18"); Tests.AssertEqual(p19.Value, actorClass, unrealClass, funcName + ".p19"); Tests.AssertEqual(p20.Value, actorClass, unrealClass, funcName + ".p20"); Tests.AssertEqual(p21, "changed123", unrealClass, funcName + ".p21"); Tests.AssertEqual(p22, new FName("321changed"), unrealClass, funcName + ".p22"); } }