// 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()));
}
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 T[] GetAllActorsOfClass <T>(UObject worldContextObject) where T : AActor
{
using (TArrayUnsafe <T> actorsUnsafe = new TArrayUnsafe <T>())
{
UClass unrealClass = UClass.GetClass <T>();
if (unrealClass != null)
{
Native_UGameplayStatics.GetAllActorsOfClass(worldContextObject.Address, unrealClass.Address, actorsUnsafe.Address);
}
return(actorsUnsafe.ToArray());
}
}
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 T[] GetComponentsByTag <T>(FName tag) where T : UActorComponent
{
UClass unrealClass = UClass.GetClass <T>();
if (unrealClass == null)
{
return(null);
}
using (TArrayUnsafe <T> resultUnsafe = new TArrayUnsafe <T>())
{
Native_AActor.GetComponentsByTag(Address, unrealClass.Address, ref tag, resultUnsafe.Address);
return(resultUnsafe.ToArray());
}
}
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);
}
internal static void OnNativeFunctionsRegistered()
{
if (Debugger.IsAttached && ManagedUnrealModuleInfo.AssemblyHasSerializedModuleInfo(
System.Reflection.Assembly.GetExecutingAssembly()))
{
ActorClass = UClass.GetClass("/Script/Engine.Actor");
// Run the tests a few times. If there is corrupt memory it might not show itself on the first run.
for (int i = 0; i < 5; i++)
{
DelegateTests.Run();
EnumTests.Run();
FixedSizeArrayTests.Run();
StructTests.Run();
ClassTests.Run();
CollectionsTests.Run();
SimpleFunctionParamTests.Run();
CollectionFunctionParamTests.Run();
}
}
}
public T GetComponentByClass <T>() where T : UActorComponent
{
return((T)GetComponentByClass(new TSubclassOf <UActorComponent>(UClass.GetClass <T>())));
}
public T SpawnActor <T>(ref FVector location, ref FRotator rotation) where T : AActor
{
return(SpawnActor(UClass.GetClass <T>(), ref location, ref rotation) as T);
}
public T SpawnActor <T>(ref FVector location, ref FRotator rotation, ref FActorSpawnParametersInterop parameters) where T : AActor
{
return(SpawnActor(UClass.GetClass <T>(), ref location, ref rotation, ref parameters) as T);
}
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 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 UClass GetActorClass()
{
return(UClass.GetClass("/Script/Engine.Actor"));
}
