/*void Method()
* {
* var reff = new RefClass("TestCase");
* refed = new RefClass("TestCase");
*
* string[] TestArray = { "1", "2", "3" };
* Array arr = TestArray;
* var test = (arr as string[])[1];
* string[][] arr_typed = { (string[])arr, (string[])arr };
* }
* float MethodWithConstRet()
* {
* return 5;
* }
* string MethodWithConstStringRet()
* {
* return "RTCLI Test: Const String";
* }*/
public void MethodWithArgsAccess(int argInt, string argStr, RefClass argClass, RefStruct argStruct)
{
var argI = argInt;
var argSt = argStr;
var argS = argStruct;
var argC = argClass;
}
public void MethodWithArgsFieldAccess(int argInt, string argStr, RefClass argClass, RefStruct argStruct)
{
//var arg6Name = arg666.Name;
Single.Parse("1.22");
argClass.CallTest(9);
argClass.CallTestF(9);
argStruct.Name = " Accessed";
}
public static int test_0_stelem_ref_null_opt()
{
object[] arr = new RefClass [1];
arr [0] = new RefClass();
arr [0] = null;
return(arr [0] == null ? 0 : 1);
}
private static void Main(string[] args)
{
var refExample = new RefClass();
refExample.Value = 100;
var refExample2 = refExample;
refExample2.Value = 200;
Console.WriteLine(refExample.Value); // Prints 200
var valExample = new ValStruct();
valExample.Value = 100;
var valExample2 = valExample;
valExample2.Value = 200;
Console.WriteLine(valExample.Value); // Prints 100
}
static void Main(string[] args)
{
var refExample = new RefClass();
refExample.Value = 100;
var refExample2 = refExample;
refExample2.Value = 200;
Console.WriteLine(refExample.Value); // Prints 200
var valExample = new ValStruct();
valExample.Value = 100;
var valExample2 = valExample;
valExample2.Value = 200;
Console.WriteLine(valExample.Value); // Prints 100
}
public void NullSourcePropertyIsNotAChange()
{
var src = new SourceClass
{
A = null,
C = "hello"
};
var reference = new RefClass
{
A = 4,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest);
Assert.False(changes);
}
public void MappingWithNoChangesReturnsFalse()
{
var src = new SourceClass
{
A = 1,
B = true,
C = "hello",
Excluded = 42.0
};
var reference = new RefClass
{
A = 1,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest, "Excluded");
Assert.False(changes);
}
public void MappingWithNoChangesReturnsFalse()
{
var src = new SourceClass
{
A = 1,
B = true,
C = "hello",
Excluded = 42.0
};
var reference = new RefClass
{
A = 1,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest, "Excluded");
Assert.False(changes);
}
public void MappingWithChangeCopiesChangedProperties()
{
var src = new SourceClass
{
A = 1,
B = true,
C = "hello",
Excluded = 42.0
};
var reference = new RefClass
{
A = 4,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest, "Excluded");
Assert.True(changes);
Assert.Equal(1, dest.A);
Assert.Null(dest.C);
}
public void MappingWithChangeCopiesChangedProperties()
{
var src = new SourceClass
{
A = 1,
B = true,
C = "hello",
Excluded = 42.0
};
var reference = new RefClass
{
A = 4,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest, "Excluded");
Assert.True(changes);
Assert.Equal(1, dest.A);
Assert.Null(dest.C);
}
public void NullSourcePropertyIsNotAChange()
{
var src = new SourceClass
{
A = null,
C = "hello"
};
var reference = new RefClass
{
A = 4,
C = "hello"
};
var dest = new DestClass();
bool changes = ObjectDeltaMapper.Map(src, reference, dest);
Assert.False(changes);
}
//private class TestCommandList
//{
// public List<UndoableCommand> stack;
//}
public static void Test()
{
var persistence = new Persistence();
//var commandList = new TestCommandList();
//commandList.stack = new List<UndoableCommand>()
//{
// new UpdateMemberCommand(new Node(), "localAngle", 10),
//};
//persistence.Deserialize<UpdateMemberCommand>(persistence.Serialize(new UpdateMemberCommand(new Node(), "localAngle", 10)));
byte valueByte = 16;
Debug.Assert(persistence.Deserialize <byte>(persistence.Serialize(valueByte)) == valueByte);
char valueChar = 'c';
Debug.Assert(persistence.Deserialize <char>(persistence.Serialize(valueChar)) == valueChar);
short valueShort = 16;
Debug.Assert(persistence.Deserialize <short>(persistence.Serialize(valueShort)) == valueShort);
ushort valueUshort = 16;
Debug.Assert(persistence.Deserialize <ushort>(persistence.Serialize(valueUshort)) == valueUshort);
int valueInt = 16;
Debug.Assert(persistence.Deserialize <int>(persistence.Serialize(valueInt)) == valueInt);
uint valueUint = 16;
Debug.Assert(persistence.Deserialize <uint>(persistence.Serialize(valueUint)) == valueUint);
long valueLong = 16;
Debug.Assert(persistence.Deserialize <long>(persistence.Serialize(valueLong)) == valueLong);
ulong valueUlong = 16;
Debug.Assert(persistence.Deserialize <ulong>(persistence.Serialize(valueUlong)) == valueUlong);
float valueFloat = 16;
Debug.Assert(persistence.Deserialize <float>(persistence.Serialize(valueFloat)) == valueFloat);
double valueDouble = 16;
Debug.Assert(persistence.Deserialize <double>(persistence.Serialize(valueDouble)) == valueDouble);
decimal valueDecimal = 16;
Debug.Assert(persistence.Deserialize <decimal>(persistence.Serialize(valueDecimal)) == valueDecimal);
string refString = "发电房大是大非sdfasdfasdfasdf";
Debug.Assert(persistence.Deserialize <string>(persistence.Serialize(refString)) == refString);
TestEnum enumA = TestEnum.A;
Debug.Assert(persistence.Deserialize <TestEnum>(persistence.Serialize(enumA)) == enumA);
var intArray = new int[4] {
1, 2, 3, 4
};
var intArrayD = persistence.Deserialize <int[]>(persistence.Serialize(intArray));
Debug.Assert(intArrayD.Length == intArray.Length);
for (int i = 0; i < intArrayD.Length; i++)
{
Debug.Assert(intArrayD[i] == intArrayD[i]);
}
var stringArray = new string[] { "dddd", "abc", "eeadf", "cxvbdfasdf" };
var stringArrayD = persistence.Deserialize <string[]>(persistence.Serialize(stringArray));
Debug.Assert(stringArrayD.Length == stringArray.Length);
for (int i = 0; i < stringArrayD.Length; i++)
{
Debug.Assert(stringArrayD[i] == stringArray[i]);
}
TestInterface testInterface = new ImpInterface();
testInterface.a = 1;
(testInterface as ImpInterface).b = 2;
var testInterfaceD = persistence.Deserialize <ImpInterface>(persistence.Serialize(testInterface));
Debug.Assert(testInterfaceD.a == testInterface.a);
Debug.Assert(testInterfaceD.b != (testInterface as ImpInterface).b);
//persistence.Register(typeof(SimpleClass));
var refSimpleClass = new SimpleClass();
SimpleClass.str = "abcdefg";
refSimpleClass.x = 1;
refSimpleClass.y = 2;
refSimpleClass.z = "1";
refSimpleClass.e = TestEnum.B;
refSimpleClass.xx = 3;
refSimpleClass.yy = 4;
refSimpleClass.zz = "2";
var refSimpleClassD = persistence.Deserialize <SimpleClass>(persistence.Serialize(refSimpleClass));
Debug.Assert(refSimpleClass.x == refSimpleClassD.x);
Debug.Assert(refSimpleClass.y == refSimpleClassD.y);
Debug.Assert(refSimpleClass.z == refSimpleClassD.z);
Debug.Assert(refSimpleClass.e == refSimpleClassD.e);
Debug.Assert(refSimpleClass.xx != refSimpleClassD.xx);
Debug.Assert(refSimpleClass.yy != refSimpleClassD.yy);
Debug.Assert(refSimpleClass.zz != refSimpleClassD.zz);
var simpleClassList = new List <SimpleClass>();
simpleClassList.Add(new SimpleClass()
{
x = 1,
y = 2,
z = "abc",
xx = 11,
yy = 22,
zz = "edf",
});
var simpleClassListD = persistence.Deserialize <List <SimpleClass> >(persistence.Serialize(simpleClassList));
Debug.Assert(simpleClassListD.Count == simpleClassList.Count);
Debug.Assert(simpleClassListD[0].x == simpleClassList[0].x);
Debug.Assert(simpleClassListD[0].y == simpleClassList[0].y);
Debug.Assert(simpleClassListD[0].z == simpleClassList[0].z);
Debug.Assert(simpleClassListD[0].xx != simpleClassList[0].xx);
Debug.Assert(simpleClassListD[0].yy != simpleClassList[0].yy);
Debug.Assert(simpleClassListD[0].zz != simpleClassList[0].zz);
//persistence.Register(typeof(SimpleStruct));
var refSimpleStruct = new SimpleStruct();
refSimpleStruct.x = 1;
refSimpleStruct.y = 2;
refSimpleStruct.z = "1";
refSimpleStruct.e = TestEnum.B;
refSimpleStruct.xx = 3;
refSimpleStruct.yy = 4;
refSimpleStruct.zz = "2";
var refSimpleStructD = persistence.Deserialize <SimpleStruct>(persistence.Serialize(refSimpleStruct));
Debug.Assert(refSimpleStruct.x == refSimpleStructD.x);
Debug.Assert(refSimpleStruct.y == refSimpleStructD.y);
Debug.Assert(refSimpleStruct.z == refSimpleStructD.z);
Debug.Assert(refSimpleStruct.e == refSimpleStructD.e);
Debug.Assert(refSimpleStruct.xx != refSimpleStructD.xx);
Debug.Assert(refSimpleStruct.yy != refSimpleStructD.yy);
Debug.Assert(refSimpleStruct.zz != refSimpleStructD.zz);
//persistence.Register(typeof(RefClass));
var refClass = new RefClass();
refClass.simpleClass = refSimpleClass;
refClass.nullSimpleClass = refSimpleClass;
refClass.simpleStruct = refSimpleStruct;
refClass.defaultSimpleStruct = refSimpleStruct;
var refClassD = persistence.Deserialize <RefClass>(persistence.Serialize(refClass));
Debug.Assert(refClass.simpleClass.x == refClassD.simpleClass.x);
Debug.Assert(refClass.simpleClass.y == refClassD.simpleClass.y);
Debug.Assert(refClass.simpleClass.z == refClassD.simpleClass.z);
Debug.Assert(refClass.simpleClass.xx != refClassD.simpleClass.xx);
Debug.Assert(refClass.simpleClass.yy != refClassD.simpleClass.yy);
Debug.Assert(refClass.simpleClass.zz != refClassD.simpleClass.zz);
Debug.Assert(refClassD.nullSimpleClass == null);
Debug.Assert(refClass.simpleStruct.x == refClassD.simpleStruct.x);
Debug.Assert(refClass.simpleStruct.y == refClassD.simpleStruct.y);
Debug.Assert(refClass.simpleStruct.z == refClassD.simpleStruct.z);
Debug.Assert(refClass.simpleStruct.xx != refClassD.simpleStruct.xx);
Debug.Assert(refClass.simpleStruct.yy != refClassD.simpleStruct.yy);
Debug.Assert(refClass.simpleStruct.zz != refClassD.simpleStruct.zz);
Debug.Assert(refClass.defaultSimpleStruct.x != refClassD.defaultSimpleStruct.x);
Debug.Assert(refClass.defaultSimpleStruct.y != refClassD.defaultSimpleStruct.y);
Debug.Assert(refClass.defaultSimpleStruct.z != refClassD.defaultSimpleStruct.z);
Debug.Assert(refClass.defaultSimpleStruct.xx != refClassD.defaultSimpleStruct.xx);
Debug.Assert(refClass.defaultSimpleStruct.yy != refClassD.defaultSimpleStruct.yy);
Debug.Assert(refClass.defaultSimpleStruct.zz != refClassD.defaultSimpleStruct.zz);
//persistence.Register(typeof(RecurRefClass));
var recurRefClass = new RecurRefClass();
recurRefClass.x = 10;
recurRefClass.self = recurRefClass;
var recurRefClassD = persistence.Deserialize <RecurRefClass>(persistence.Serialize(recurRefClass));
Debug.Assert(recurRefClassD.x == recurRefClass.x);
Debug.Assert(recurRefClassD.self == recurRefClassD);
//persistence.Register(typeof(ComplexRecurRefClassA));
//persistence.Register(typeof(ComplexRecurRefClassB));
//persistence.Register(typeof(ComplexRecurRefClassAB));
var complexRecurRefClassA = new ComplexRecurRefClassA();
complexRecurRefClassA.a = 11;
var complexRecurRefClassB = new ComplexRecurRefClassB();
complexRecurRefClassB.b = 12;
var complexRecurRefClassAB = new ComplexRecurRefClassAB();
complexRecurRefClassAB.ab = 13;
complexRecurRefClassA.classAB = complexRecurRefClassAB;
complexRecurRefClassB.classA = complexRecurRefClassA;
complexRecurRefClassAB.classA = complexRecurRefClassA;
complexRecurRefClassAB.classB = complexRecurRefClassB;
var complexRecurRefClassABD = persistence.Deserialize <ComplexRecurRefClassAB>(persistence.Serialize(complexRecurRefClassAB));
Debug.Assert(complexRecurRefClassABD.ab == complexRecurRefClassAB.ab);
Debug.Assert(complexRecurRefClassABD.classA.a == complexRecurRefClassAB.classA.a);
Debug.Assert(complexRecurRefClassABD.classB.b == complexRecurRefClassAB.classB.b);
Debug.Assert(complexRecurRefClassABD.classA == complexRecurRefClassABD.classB.classA);
Debug.Assert(complexRecurRefClassABD == complexRecurRefClassABD.classA.classAB);
//persistence.Register(typeof(BaseClass));
//persistence.Register(typeof(SubClass));
//persistence.Register(typeof(AbstractFieldClass));
var abstractFieldClass = new AbstractFieldClass();
abstractFieldClass.baseClass = new SubClass()
{
x = 1, xx = 2
};
var abstractFieldClassD = persistence.Deserialize <AbstractFieldClass>(persistence.Serialize(abstractFieldClass));
Debug.Assert(abstractFieldClassD.baseClass.x == 1);
Debug.Assert(abstractFieldClassD.baseClass is SubClass);
Debug.Assert((abstractFieldClassD.baseClass as SubClass).xx == 2);
var baseClassList = new List <BaseClass>();
baseClassList.Add(new SubClass()
{
xx = 123,
x = 1,
});
baseClassList.Add(new BaseClass()
{
x = 234,
});
var baseClassListD = persistence.Deserialize <List <BaseClass> >(persistence.Serialize(baseClassList));
Debug.Assert(baseClassListD.Count == baseClassList.Count);
Debug.Assert(baseClassListD[0].x == baseClassList[0].x);
Debug.Assert((baseClassListD[0] as SubClass).xx == (baseClassList[0] as SubClass).xx);
Debug.Assert(baseClassListD[1].x == baseClassList[1].x);
var complexStructure = new Dictionary <List <ComplexRecurRefClassAB>, Dictionary <ComplexRecurRefClassA, ComplexRecurRefClassB> >();
var refAB = new ComplexRecurRefClassAB();
refAB.ab = 13;
var refA = new ComplexRecurRefClassA();
refA.a = 11;
var refB = new ComplexRecurRefClassB();
refB.b = 12;
refAB.classA = refA;
refAB.classB = refB;
refA.classAB = refAB;
refB.classA = refA;
var key1 = new List <ComplexRecurRefClassAB>();
key1.Add(refAB);
key1.Add(refAB);
var val1 = new Dictionary <ComplexRecurRefClassA, ComplexRecurRefClassB>();
val1.Add(refA, refB);
complexStructure.Add(key1, val1);
var complexStructureD = persistence.Deserialize <Dictionary <List <ComplexRecurRefClassAB>, Dictionary <ComplexRecurRefClassA, ComplexRecurRefClassB> > >(persistence.Serialize(complexStructure));
Debug.Assert(complexStructureD.Count == complexStructure.Count);
var arrayKeys = complexStructure.Keys.ToArray();
var arrayKeysD = complexStructureD.Keys.ToArray();
Debug.Assert(arrayKeysD[0].Count == arrayKeys[0].Count);
Debug.Assert(arrayKeysD[0][0] == arrayKeysD[0][1]);
for (int j = 0; j < arrayKeys[0].Count; j++)
{
Debug.Assert(arrayKeysD[0][j].ab == arrayKeys[0][j].ab);
}
var arrayVals = complexStructure.Values.ToArray();
var arrayValsD = complexStructureD.Values.ToArray();
Debug.Assert(arrayValsD[0].Count == arrayVals[0].Count);
Debug.Assert(arrayValsD[0].Keys.ToArray()[0].a == arrayVals[0].Keys.ToArray()[0].a);
Debug.Assert(arrayValsD[0].Values.ToArray()[0].b == arrayVals[0].Values.ToArray()[0].b);
Debug.Assert(arrayValsD[0].Keys.ToArray()[0] == arrayKeysD[0][0].classA);
Debug.Assert(arrayValsD[0].Values.ToArray()[0] == arrayKeysD[0][0].classB);
var vector4 = new Vector4(1, 2, 3, 4);
var vector4D = persistence.Deserialize <Vector4>(persistence.Serialize(vector4));
Debug.Assert(vector4 == vector4D);
var color = new Color(0.1f, 0.2f, 0.3f, 0.4f);
var colorD = persistence.Deserialize <Color>(persistence.Serialize(color));
Debug.Assert(color == colorD);
var quaternion = Quaternion.Euler(100, 200, 300);
var quaternionD = persistence.Deserialize <Quaternion>(persistence.Serialize(quaternion));
Debug.Assert(quaternion == quaternionD);
//var guiStyle = GUI.skin.button;
//var guiStyleD = persistence.Deserialize<GUIStyle>(persistence.Serialize(guiStyle));
//Debug.Assert(guiStyle.clipping == guiStyleD.clipping);
//Debug.Assert(guiStyle.border.left == guiStyleD.border.left);
//Debug.Assert(guiStyle.margin.right == guiStyleD.margin.right);
//Debug.Assert(guiStyle.padding.top == guiStyleD.padding.top);
//Debug.Assert(guiStyle.contentOffset == guiStyleD.contentOffset);
//Debug.Assert(guiStyle.stretchWidth == guiStyleD.stretchWidth);
//Debug.Assert(guiStyle.stretchHeight == guiStyleD.stretchHeight);
//Debug.Assert(guiStyle.normal.background == guiStyleD.normal.background);
//Debug.Assert(guiStyle.normal.textColor == guiStyleD.normal.textColor);
//if (guiStyle.normal.scaledBackgrounds.Length > 0)
// Debug.Assert(guiStyle.normal.scaledBackgrounds[0] == guiStyleD.normal.scaledBackgrounds[0]);
//Debug.Assert(guiStyle.onNormal.background == guiStyleD.onNormal.background);
//Debug.Assert(guiStyle.onNormal.textColor == guiStyleD.onNormal.textColor);
//if (guiStyle.onNormal.scaledBackgrounds.Length > 0)
// Debug.Assert(guiStyle.onNormal.scaledBackgrounds[0] == guiStyleD.onNormal.scaledBackgrounds[0]);
//Debug.Assert(guiStyle.imagePosition == guiStyleD.imagePosition);
//Debug.Assert(guiStyle.font == guiStyleD.font);
//var eguiButton = new Button();
//eguiButton.name = "abc";
//var eguiButtonD = persistence.Deserialize<Button>(persistence.Serialize(eguiButton));
//Debug.Assert(eguiButton.name == eguiButtonD.name);
var subxField = typeof(SubClass).GetField("x", BindingFlags.Instance | BindingFlags.Public);
var subxFieldD = persistence.Deserialize <FieldInfo>(persistence.Serialize(subxField));
Debug.Assert(subxField.FieldType == subxFieldD.FieldType);
Debug.Assert(subxField.ReflectedType == subxFieldD.ReflectedType);
Debug.Assert(subxField.Name == subxFieldD.Name);
var subyProperty = typeof(SubClass).GetProperty("yy", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
var subyPropertyD = persistence.Deserialize <PropertyInfo>(persistence.Serialize(subyProperty));
Debug.Assert(subyProperty.PropertyType == subyPropertyD.PropertyType);
Debug.Assert(subyProperty.ReflectedType == subyPropertyD.ReflectedType);
Debug.Assert(subyProperty.Name == subyPropertyD.Name);
}
public void MethodWithArgsVirtCall(int argInt, string argStr, RefClass argClass, RefStruct argStruct)
{
var argC = argClass;
var argCName = argClass.Name;
}
void Method()
{
refed = new RefClass("TestCase");
}
