// Could add another POD struct nested in here but it seems to not be blittable when
// adding a POD struct into another POD struct.
public static void Run()
{
UScriptStruct unrealStruct = UScriptStruct.GetStruct <Test_SimpleBlittableStruct>();
Tests.Assert(unrealStruct != null, "Test_SimpleBlittableStruct");
Tests.AssertProperty <UInt8Property>(unrealStruct, "Val1");
Tests.AssertProperty <UByteProperty>(unrealStruct, "Val2");
Tests.AssertProperty <UInt16Property>(unrealStruct, "Val3");
Tests.AssertProperty <UUInt16Property>(unrealStruct, "Val4");
Tests.AssertProperty <UIntProperty>(unrealStruct, "Val5");
Tests.AssertProperty <UUInt32Property>(unrealStruct, "Val6");
Tests.AssertProperty <UInt64Property>(unrealStruct, "Val7");
Tests.AssertProperty <UUInt64Property>(unrealStruct, "Val8");
Tests.AssertProperty <UFloatProperty>(unrealStruct, "Val9");
Tests.AssertProperty <UDoubleProperty>(unrealStruct, "Val10");
Tests.AssertProperty <UNameProperty>(unrealStruct, "Val11");
Tests.Assert(StructDefault <Test_SimpleBlittableStruct> .IsBlittableStruct, unrealStruct, "IsBlittableStruct");
Tests.Assert(unrealStruct.StructFlags.HasFlag(EStructFlags.IsPlainOldData), unrealStruct, "IsPlainOldData");
Test_SimpleBlittableStruct defaultValue = StructDefault <Test_SimpleBlittableStruct> .Value;
Tests.AssertEqual(defaultValue, default(Test_SimpleBlittableStruct), unrealStruct, "default state");
}
protected override string VirtualFunc1_Implementation(int param1, ref string param2)
{
Tests.AssertEqual(param1, 1, GetClass(), "VirtualFunc1.param1");
base.VirtualFunc1_Implementation(param1 + 1, ref param2);
param2 = "Test_SimpleClass3_param2_out";
return("Test_SimpleClass3");
}
public override string VirtualFunc1(int param1, ref string param2)
{
Tests.AssertEqual(param1, 0, GetClass(), "VirtualFunc1.param1");
base.VirtualFunc1(param1 + 1, ref param2);
param2 = "Test_SimpleClass3_param2_out";
return("Test_SimpleClass3");
}
private static void RunMiscTests()
{
// A couple of misc tests
// Test FName finding an existing FName which doesn't exist returns FName.None
Tests.AssertEqual(new FName("I don't exist! (C# test 123!)", FName.EFindName.Find), FName.None, "find non existing FName");
}
private static void AssertTestArrayFuncParam(Test_FixedArrayInStruct value, UClass unrealClass, int step)
{
for (int i = 0; i < value.Array1.Length; i++)
{
Tests.AssertEqual(i + 1, value.Array1[i], unrealClass, "StructArrayFuncTestResult-" + step);
}
for (int i = 0; i < value.Array6.Length; i++)
{
Tests.AssertEqual(uint.MaxValue - (i + 1), value.Array6[i], unrealClass, "StructArrayFuncTestResult-" + step);
}
if (step == 4)
{
// check the ref func changed this, otherwise it should be default
for (int i = 0; i < value.Array1.Length; i++)
{
Tests.AssertEqual(i + 2, value.Array2[i], unrealClass, "StructArrayFuncTestResult-" + step);
}
}
else
{
for (int i = 0; i < value.Array1.Length; i++)
{
Tests.AssertEqual(0, value.Array2[i], unrealClass, "StructArrayFuncTestResult-" + step);
}
}
}
// Make sure this signature matches Test_SimpleMulticastDelegate
private void BindToStructMulticastDelegate3(ulong param1, string param2, ref int param3)
{
Tests.AssertEqual(param1, 3u, "BindToStructMulticastDelegate3");
Tests.AssertEqual(param2, "param2", "BindToStructMulticastDelegate3");
Tests.Assert(param3 >= 1 && param3 <= 4, "BindToStructMulticastDelegate3");
param3++;
}
public TSoftClass <UObject> BindMe(int param1, string param2, ref double param3, out string param4)
{
Tests.AssertEqual(param1, 3, GetClass(), "BindMe.param1");
Tests.AssertEqual(param2, "param2", GetClass(), "BindMe.param2");
Tests.AssertEqual(param3, 4.5, GetClass(), "BindMe.param3");
param3 += 0.5;
param4 = "out";
return(new TSoftClass <UObject>("/Script/Engine.Actor"));
}
public static void Run()
{
UScriptStruct unrealStruct = UScriptStruct.GetStruct <Test_FixedArrayInStruct>();
Tests.Assert(unrealStruct != null, "Test_FixedArrayInStruct");
Tests.AssertFixedArrayProperty <UInt8Property>(unrealStruct, "Array1", 3);
Tests.AssertFixedArrayProperty <UByteProperty>(unrealStruct, "Array2", 4);
Tests.AssertFixedArrayProperty <UInt16Property>(unrealStruct, "Array3", 5);
Tests.AssertFixedArrayProperty <UUInt16Property>(unrealStruct, "Array4", 6);
Tests.AssertFixedArrayProperty <UIntProperty>(unrealStruct, "Array5", 7);
Tests.AssertFixedArrayProperty <UUInt32Property>(unrealStruct, "Array6", 8);
Tests.AssertFixedArrayProperty <UInt64Property>(unrealStruct, "Array7", 9);
Tests.AssertFixedArrayProperty <UUInt64Property>(unrealStruct, "Array8", 10);
Tests.AssertFixedArrayProperty <UFloatProperty>(unrealStruct, "Array9", 11);
Tests.AssertFixedArrayProperty <UDoubleProperty>(unrealStruct, "Array10", 12);
Tests.AssertFixedArrayProperty <UDelegateProperty>(unrealStruct, "Array11", 13);
Tests.AssertFixedArrayProperty <UMulticastDelegateProperty>(unrealStruct, "Array12", 14);
Tests.AssertFixedArrayProperty <UObjectProperty>(unrealStruct, "Array13", 15);
Tests.AssertFixedArrayProperty <UEnumProperty>(unrealStruct, "Array14", 16);
Tests.AssertFixedArrayProperty <UStructProperty>(unrealStruct, "Array15", 17);
Tests.AssertFixedArrayProperty <UClassProperty>(unrealStruct, "Array16", 18);
Tests.AssertFixedArrayProperty <ULazyObjectProperty>(unrealStruct, "Array17", 19);
Tests.AssertFixedArrayProperty <UWeakObjectProperty>(unrealStruct, "Array18", 20);
Tests.AssertFixedArrayProperty <USoftClassProperty>(unrealStruct, "Array19", 21);
Tests.AssertFixedArrayProperty <USoftObjectProperty>(unrealStruct, "Array20", 22);
Tests.AssertFixedArrayProperty <UStrProperty>(unrealStruct, "Array21", 23);
Tests.AssertFixedArrayProperty <UNameProperty>(unrealStruct, "Array22", 24);
//Tests.AssertFixedArrayProperty<UTextProperty>(unrealStruct, "Array23", 25);
Test_FixedArrayInStruct defaultValue = StructDefault <Test_FixedArrayInStruct> .Value;
Tests.AssertEqual(defaultValue.Array1.Length, 3, unrealStruct, ".Array1");
Tests.AssertEqual(defaultValue.Array2.Length, 4, unrealStruct, ".Array2");
Tests.AssertEqual(defaultValue.Array3.Length, 5, unrealStruct, ".Array3");
Tests.AssertEqual(defaultValue.Array4.Length, 6, unrealStruct, ".Array4");
Tests.AssertEqual(defaultValue.Array5.Length, 7, unrealStruct, ".Array5");
Tests.AssertEqual(defaultValue.Array6.Length, 8, unrealStruct, ".Array6");
Tests.AssertEqual(defaultValue.Array7.Length, 9, unrealStruct, ".Array7");
Tests.AssertEqual(defaultValue.Array8.Length, 10, unrealStruct, ".Array8");
Tests.AssertEqual(defaultValue.Array9.Length, 11, unrealStruct, ".Array9");
Tests.AssertEqual(defaultValue.Array10.Length, 12, unrealStruct, ".Array10");
Tests.AssertEqual(defaultValue.Array11.Length, 13, unrealStruct, ".Array11");
Tests.AssertEqual(defaultValue.Array12.Length, 14, unrealStruct, ".Array12");
Tests.AssertEqual(defaultValue.Array13.Length, 15, unrealStruct, ".Array13");
Tests.AssertEqual(defaultValue.Array14.Length, 16, unrealStruct, ".Array14");
Tests.AssertEqual(defaultValue.Array15.Length, 17, unrealStruct, ".Array15");
Tests.AssertEqual(defaultValue.Array16.Length, 18, unrealStruct, ".Array16");
Tests.AssertEqual(defaultValue.Array17.Length, 19, unrealStruct, ".Array17");
Tests.AssertEqual(defaultValue.Array18.Length, 20, unrealStruct, ".Array18");
Tests.AssertEqual(defaultValue.Array19.Length, 21, unrealStruct, ".Array19");
Tests.AssertEqual(defaultValue.Array20.Length, 22, unrealStruct, ".Array20");
Tests.AssertEqual(defaultValue.Array21.Length, 23, unrealStruct, ".Array21");
Tests.AssertEqual(defaultValue.Array22.Length, 24, unrealStruct, ".Array22");
}
public Dictionary <TSoftClass <UObject>, TSoftClass <UObject> > MapFunc5(ref string inStr)
{
Tests.AssertEqual(inStr, "inStr", GetClass(), "MapFunc5.inStr");
inStr = "outStr";
Dictionary <TSoftClass <UObject>, TSoftClass <UObject> > result = new Dictionary <TSoftClass <UObject>, TSoftClass <UObject> >();
result[TSoftClass <UObject> .Null] = new TSoftClass <UObject>(Tests.ActorClass);
result[new TSoftClass <UObject>(Tests.ActorClass)] = TSoftClass <UObject> .Null;
return(result);
}
public HashSet <TSoftClass <UObject> > SetFunc5(ref string inStr)
{
Tests.AssertEqual(inStr, "inStr", GetClass(), "SetFunc5.inStr");
inStr = "outStr";
HashSet <TSoftClass <UObject> > result = new HashSet <TSoftClass <UObject> >();
result.Add(TSoftClass <UObject> .Null);
result.Add(new TSoftClass <UObject>(Tests.ActorClass));
return(result);
}
// Make sure this signature matches Test_SimpleDelegate
private TSoftClass <UObject> BindToStructDelegate(int param1, string param2, ref double param3, out string param4)
{
Tests.AssertEqual(param1, 13, "BindToStructDelegate.param1");
Tests.AssertEqual(param2, "inParam2", "BindToStructDelegate.param2");
Tests.AssertEqual(param3, 44.3, "BindToStructDelegate.param3");
param2 = "outParam2";
param3 = 99.88;
param4 = "outParam4";
return(new TSoftClass <UObject>(UClass.GetClass <Test_SimpleStructOnClass>().GetPathName()));
}
protected override string VirtualFunc1_Implementation(int param1, ref string param2)
{
int count = 1;
if (this.IsA <Test_SimpleClass3>())
{
count++;
}
Tests.AssertEqual(param1, count, GetClass(), "VirtualFunc1.param1");
base.VirtualFunc1_Implementation(param1 + 1, ref param2);
param2 = "Test_SimpleClass2_param2_out";
return("Test_SimpleClass2");
}
private static void TestResultFuncXEquals <T>(T value, Test_SimpleFuncs obj, int func, bool isNullResult)
{
UClass unrealClass = obj.GetClass();
string funcName = "ResultFunc" + func;
if (isNullResult)
{
funcName += "_Null";
}
UFunction func1 = unrealClass.FindFunctionByName(new FName(funcName));
Tests.AssertNotNull(func1, unrealClass, funcName);
Tests.AssertEqual((T)UObject.DynamicInvoke(obj, funcName), value, unrealClass, funcName);
}
public virtual string VirtualFunc1(int param1, ref string param2)
{
int count = 1;
if (this.IsA <Test_SimpleClass2>())
{
count++;
}
if (this.IsA <Test_SimpleClass3>())
{
count++;
}
Tests.AssertEqual(param1, count, GetClass(), "VirtualFunc1.param1");
param2 = "Test_SimpleClass1_param2_out";
return("Test_SimpleClass1");
}
private static void TestVirtualFunc1(Test_SimpleClass1 obj, int type)
{
// Go through a full marshal of parameters and resolve the function from the UFunction
object[] parameters = { 1, "inArg" };
UObject.DynamicInvoke(obj, "VirtualFunc1", parameters);
string arg = (string)parameters[1];
string expectedOutArg = "Test_SimpleClass1_param2_out";
switch (type)
{
case 1: expectedOutArg = "Test_SimpleClass2_param2_out"; break;
case 2: expectedOutArg = "Test_SimpleClass3_param2_out"; break;
}
Tests.AssertEqual(arg, expectedOutArg, obj.GetClass(), "VirtualFunc1.parm2");
}
public long SetFunc3(
ref ISet <long> p1,
ref ISet <UObject> p2,
ref ISet <Test_SimpleEnum> p3,
ref ISet <Test_SimpleBlittableStruct> p4,
ref ISet <TSoftClass <UObject> > p5,
ref ISet <string> p6,
ref ISet <FName> p7)
{
Tests.AssertEqual(p1.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p2.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p3.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p4.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p5.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p6.Count, 0, GetClass(), "SetFunc3 ref empty map");
Tests.AssertEqual(p7.Count, 0, GetClass(), "SetFunc3 ref empty map");
MakeSetTest(p1, p2, p3, p4, p5, p6, p7);
AssertSetTest(this, p1, p2, p3, p4, p5, p6, p7);
return(13232);
}
public long MapFunc3(
ref IDictionary <long, string> p1,
ref IDictionary <UObject, string> p2,
ref IDictionary <Test_SimpleEnum, string> p3,
ref IDictionary <Test_SimpleBlittableStruct, UObject> p4,
ref IDictionary <TSoftClass <UObject>, TSoftClass <UObject> > p5,
ref IDictionary <string, string> p6,
ref IDictionary <FName, string> p7)
{
Tests.AssertEqual(p1.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p2.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p3.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p4.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p5.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p6.Count, 0, GetClass(), "MapFunc3 ref empty map");
Tests.AssertEqual(p7.Count, 0, GetClass(), "MapFunc3 ref empty map");
MakeMapTest(p1, p2, p3, p4, p5, p6, p7);
AssertMapTest(this, p1, p2, p3, p4, p5, p6, p7);
return(13232);
}
//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 AssertMapTest(UObject obj,
IDictionary <long, string> p1,
IDictionary <UObject, string> p2,
IDictionary <Test_SimpleEnum, string> p3,
IDictionary <Test_SimpleBlittableStruct, UObject> p4,
IDictionary <TSoftClass <UObject>, TSoftClass <UObject> > p5,
IDictionary <string, string> p6,
IDictionary <FName, string> p7)
{
UClass unrealClass = obj.GetClass();
Tests.AssertEqual(p1[10], "tp1", unrealClass, "AssertMapTest.p1");
Tests.AssertEqual(p2[Tests.ActorClass], "tp2", unrealClass, "AssertMapTest.p2");
Tests.AssertEqual(p3[Test_SimpleEnum.Val3], "tp3", unrealClass, "AssertMapTest.p3");
Tests.AssertEqual(p4[new Test_SimpleBlittableStruct()
{
Val3 = 99
}], Tests.ActorClass, unrealClass, "AssertMapTest.p4");
Tests.AssertEqual(p5[TSoftClass <UObject> .Null], new TSoftClass <UObject>(Tests.ActorClass), unrealClass, "AssertMapTest.p5");
Tests.AssertEqual(p5[new TSoftClass <UObject>(Tests.ActorClass)], TSoftClass <UObject> .Null, unrealClass, "AssertMapTest.p5");
Tests.AssertEqual(p6["test123"], "tp6", unrealClass, "AssertMapTest.p6");
Tests.AssertEqual(p7[new FName("test1234")], "tp7", unrealClass, "AssertMapTest.p7");
}
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);
}
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()
{
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 AssertEnumValue(UEnum unrealEnum, string name, long value)
{
Tests.AssertEqual(unrealEnum.GetValueByNameString(name), value, unrealEnum.GetName() + "." + name);
}
private static void RunMapTest(Test_CollectionsFuncs obj, UClass unrealClass)
{
var p1 = new Dictionary <long, string>();
var p2 = new Dictionary <UObject, string>();
var p3 = new Dictionary <Test_SimpleEnum, string>();
var p4 = new Dictionary <Test_SimpleBlittableStruct, UObject>();
var p5 = new Dictionary <TSoftClass <UObject>, TSoftClass <UObject> >();
var p6 = new Dictionary <string, string>();
var p7 = new Dictionary <FName, string>();
Test_CollectionsFuncs.MakeMapTest(p1, p2, p3, p4, p5, p6, p7);
// Normal
{
object[] parameters = { p1, p2, p3, p4, p5, p6, p7 };
UObject.DynamicInvoke(obj, "MapFunc1", parameters);
}
// Ref
{
object[] parameters = { p1, p2, p3, p4, p5, p6, p7 };
UObject.DynamicInvoke(obj, "MapFunc2", 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, "MapFunc3", parameters);
p1 = (Dictionary <long, string>)parameters[0];
p2 = (Dictionary <UObject, string>)parameters[1];
p3 = (Dictionary <Test_SimpleEnum, string>)parameters[2];
p4 = (Dictionary <Test_SimpleBlittableStruct, UObject>)parameters[3];
p5 = (Dictionary <TSoftClass <UObject>, TSoftClass <UObject> >)parameters[4];
p6 = (Dictionary <string, string>)parameters[5];
p7 = (Dictionary <FName, string>)parameters[6];
Test_CollectionsFuncs.AssertMapTest(obj, p1, p2, p3, p4, p5, p6, p7);
}
// Out
{
object[] parameters = { null, null, null, null, null, null, null };
UObject.DynamicInvoke(obj, "MapFunc4", parameters);
p1 = (Dictionary <long, string>)parameters[0];
p2 = (Dictionary <UObject, string>)parameters[1];
p3 = (Dictionary <Test_SimpleEnum, string>)parameters[2];
p4 = (Dictionary <Test_SimpleBlittableStruct, UObject>)parameters[3];
p5 = (Dictionary <TSoftClass <UObject>, TSoftClass <UObject> >)parameters[4];
p6 = (Dictionary <string, string>)parameters[5];
p7 = (Dictionary <FName, string>)parameters[6];
Test_CollectionsFuncs.AssertMapTest(obj, p1, p2, p3, p4, p5, p6, p7);
}
// Result
{
object[] parameters = { "inStr" };
var mapResult = (Dictionary <TSoftClass <UObject>, TSoftClass <UObject> >)UObject.DynamicInvoke(obj, "MapFunc5", parameters);
Tests.AssertEqual(mapResult[TSoftClass <UObject> .Null], new TSoftClass <UObject>(Tests.ActorClass), unrealClass, "MapFunc5");
Tests.AssertEqual(mapResult[new TSoftClass <UObject>(Tests.ActorClass)], TSoftClass <UObject> .Null, unrealClass, "MapFunc5");
Tests.AssertEqual((string)parameters[0], "outStr", unrealClass, "MapFunc5.param1");
}
}
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 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()
{
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");
}