public Test_SimpleDelegate ResultFunc11()
{
Test_SimpleDelegate simpleDelegate = new Test_SimpleDelegate();
simpleDelegate.Bind(BindMe);
return(simpleDelegate);
}
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");
}
private long Func3(
out sbyte p1,
out byte p2,
out short p3,
out ushort p4,
out int p5,
out uint p6,
out long p7,
out ulong p8,
out float p9,
out double p10,
out Test_SimpleDelegate p11,
out Test_SimpleMulticastDelegate p12,
out UObject p13,
out Test_SimpleEnum p14,
out Test_FixedArrayInStruct p15,
out TSubclassOf <UObject> p16,
out TLazyObject <UObject> p17,
out TWeakObject <UObject> p18,
out TSoftClass <UObject> p19,
out TSoftObject <UObject> p20,
out string p21,
out FName p22)
{
Test_SimpleDelegate simpleDelegate = new Test_SimpleDelegate();
simpleDelegate.Bind(BindMe);
Test_SimpleMulticastDelegate multicastDelegate = new Test_SimpleMulticastDelegate();
multicastDelegate.Bind(BindMeMulti1);
multicastDelegate.Bind(BindMeMulti2);
multicastDelegate.Bind(BindMeMulti3);
UClass actorClass = GetActorClass();
p1 = 3;
p2 = 4;
p3 = 5;
p4 = 6;
p5 = 7;
p6 = 8;
p7 = 9;
p8 = 10;
p9 = 11.2f;
p10 = 12.5f;
p11 = null;
p12 = multicastDelegate;
p13 = actorClass;
p14 = Test_SimpleEnum.Val2;
p15 = new Test_FixedArrayInStruct()
{
Array1 = new sbyte[3] {
2, 5, 100
}
};
p16 = new TSubclassOf <UObject>(actorClass);
p17 = new TLazyObject <UObject>(actorClass);
p18 = new TWeakObject <UObject>(actorClass);
p19 = new TSoftClass <UObject>(actorClass);
p20 = new TSoftObject <UObject>(actorClass);
p21 = "changed123";
p22 = new FName("321changed");
return(13232);
}
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");
}
}
