772 lines
23 KiB
C#
772 lines
23 KiB
C#
//
|
|
// System.Runtime.Serialization.SerializationTest.cs
|
|
//
|
|
// Author: Lluis Sanchez Gual (lluis@ximian.com)
|
|
//
|
|
// (C) Ximian, Inc.
|
|
//
|
|
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Formatters.Soap;
|
|
using System.Reflection;
|
|
using System.Runtime.Remoting;
|
|
using System.Runtime.Remoting.Channels;
|
|
using System.Runtime.Remoting.Proxies;
|
|
using System.Runtime.Remoting.Messaging;
|
|
using System.Collections;
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.Runtime.Serialization.Formatters.Soap
|
|
{
|
|
[TestFixture]
|
|
public class SerializationTest
|
|
{
|
|
MemoryStream ms;
|
|
|
|
[Test]
|
|
public void TestSerialization ()
|
|
{
|
|
MethodTester mt = new MethodTester();
|
|
RemotingServices.Marshal (mt, "myuri");
|
|
|
|
WriteData();
|
|
ReadData();
|
|
|
|
RemotingServices.Disconnect (mt);
|
|
}
|
|
|
|
public static void Main()
|
|
{
|
|
SerializationTest test = new SerializationTest();
|
|
test.TestSerialization();
|
|
}
|
|
|
|
void WriteData ()
|
|
{
|
|
StreamingContext context = new StreamingContext (StreamingContextStates.Other);
|
|
SurrogateSelector sel = new SurrogateSelector();
|
|
sel.AddSurrogate (typeof (Point), context, new PointSurrogate());
|
|
|
|
List list = CreateTestData();
|
|
BinderTester_A bta = CreateBinderTestData();
|
|
|
|
ms = new MemoryStream();
|
|
SoapFormatter f = new SoapFormatter (sel, new StreamingContext(StreamingContextStates.Other));
|
|
f.Serialize (ms, list);
|
|
// ProcessMessages (ms, null);
|
|
// f.Serialize (ms, bta);
|
|
ms.Flush ();
|
|
ms.Position = 0;
|
|
StreamReader reader = new StreamReader(ms);
|
|
Console.WriteLine(reader.ReadToEnd());
|
|
ms.Position = 0;
|
|
}
|
|
|
|
void ReadData()
|
|
{
|
|
StreamingContext context = new StreamingContext (StreamingContextStates.Other);
|
|
SurrogateSelector sel = new SurrogateSelector();
|
|
sel.AddSurrogate (typeof (Point), context, new PointSurrogate());
|
|
|
|
SoapFormatter f = new SoapFormatter (sel, context);
|
|
|
|
object list = f.Deserialize (ms);
|
|
|
|
object[][] originalMsgData = null;
|
|
IMessage[] calls = null;
|
|
IMessage[] resps = null;
|
|
|
|
// originalMsgData = ProcessMessages (null, null);
|
|
|
|
// calls = new IMessage[originalMsgData.Length];
|
|
// resps = new IMessage[originalMsgData.Length];
|
|
|
|
|
|
// for (int n=0; n<originalMsgData.Length; n++)
|
|
// {
|
|
// calls[n] = (IMessage) f.Deserialize (ms);
|
|
// resps[n] = (IMessage) f.DeserializeMethodResponse (ms, null, (IMethodCallMessage)calls[n]);
|
|
// }
|
|
//
|
|
// f.Binder = new TestBinder ();
|
|
// object btbob = f.Deserialize (ms);
|
|
|
|
ms.Close();
|
|
|
|
((List)list).CheckEquals(CreateTestData());
|
|
//
|
|
// BinderTester_A bta = CreateBinderTestData();
|
|
// Assertion.AssertEquals ("BinderTest.class", btbob.GetType(), typeof (BinderTester_B));
|
|
// BinderTester_B btb = btbob as BinderTester_B;
|
|
// if (btb != null)
|
|
// {
|
|
// Assertion.AssertEquals ("BinderTest.x", btb.x, bta.x);
|
|
// Assertion.AssertEquals ("BinderTest.y", btb.y, bta.y);
|
|
// }
|
|
//
|
|
// CheckMessages ("MethodCall", originalMsgData, ProcessMessages (null, calls));
|
|
// CheckMessages ("MethodResponse", originalMsgData, ProcessMessages (null, resps));
|
|
}
|
|
|
|
BinderTester_A CreateBinderTestData ()
|
|
{
|
|
BinderTester_A bta = new BinderTester_A();
|
|
bta.x = 11;
|
|
bta.y = "binder tester";
|
|
return bta;
|
|
}
|
|
|
|
List CreateTestData()
|
|
{
|
|
List list = new List();
|
|
list.name = "my list";
|
|
list.values = new SomeValues();
|
|
list.values.Init();
|
|
|
|
ListItem item1 = new ListItem();
|
|
ListItem item2 = new ListItem();
|
|
ListItem item3 = new ListItem();
|
|
|
|
item1.label = "value label 1";
|
|
item1.next = item2;
|
|
item1.value.color = 111;
|
|
item1.value.point = new Point();
|
|
item1.value.point.x = 11;
|
|
item1.value.point.y = 22;
|
|
|
|
item2.label = "value label 2";
|
|
item2.next = item3;
|
|
item2.value.color = 222;
|
|
|
|
item2.value.point = new Point();
|
|
item2.value.point.x = 33;
|
|
item2.value.point.y = 44;
|
|
|
|
item3.label = "value label 3";
|
|
item3.value.color = 333;
|
|
item3.value.point = new Point();
|
|
item3.value.point.x = 55;
|
|
item3.value.point.y = 66;
|
|
|
|
list.children = new ListItem[3];
|
|
|
|
list.children[0] = item1;
|
|
list.children[1] = item2;
|
|
list.children[2] = item3;
|
|
|
|
return list;
|
|
}
|
|
|
|
|
|
object[][] ProcessMessages (Stream stream, IMessage[] messages)
|
|
{
|
|
object[][] results = new object[9][];
|
|
|
|
AuxProxy prx = new AuxProxy (stream, "myuri");
|
|
MethodTester mt = (MethodTester)prx.GetTransparentProxy();
|
|
object res;
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[0]);
|
|
res = mt.OverloadedMethod();
|
|
results[0] = new object[] {res};
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[1]);
|
|
res = mt.OverloadedMethod(22);
|
|
results[1] = new object[] {res};
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[2]);
|
|
int[] par1 = new int[] {1,2,3};
|
|
res = mt.OverloadedMethod(par1);
|
|
results[2] = new object[] { res, par1 };
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[3]);
|
|
mt.NoReturn();
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[4]);
|
|
res = mt.Simple ("hello",44);
|
|
results[4] = new object[] { res };
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[5]);
|
|
res = mt.Simple2 ('F');
|
|
results[5] = new object[] { res };
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[6]);
|
|
char[] par2 = new char[] { 'G' };
|
|
res = mt.Simple3 (par2);
|
|
results[6] = new object[] { res, par2 };
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[7]);
|
|
res = mt.Simple3 (null);
|
|
results[7] = new object[] { res };
|
|
|
|
if (messages != null) prx.SetTestMessage (messages[8]);
|
|
|
|
SimpleClass b = new SimpleClass ('H');
|
|
res = mt.SomeMethod (123456, b);
|
|
results[8] = new object[] { res, b };
|
|
|
|
return results;
|
|
}
|
|
|
|
void CheckMessages (string label, object[][] original, object[][] serialized)
|
|
{
|
|
for (int n=0; n<original.Length; n++)
|
|
EqualsArray (label + " " + n, original[n], serialized[n]);
|
|
}
|
|
|
|
public static void AssertEquals(string message, Object expected, Object actual)
|
|
{
|
|
if (expected != null && expected.GetType().IsArray)
|
|
EqualsArray (message, (Array)expected, (Array)actual);
|
|
else
|
|
Assert.AreEqual (expected, actual, message);
|
|
|
|
}
|
|
|
|
public static void EqualsArray (string message, object oar1, object oar2)
|
|
{
|
|
if (oar1 == null || oar2 == null || !(oar1 is Array) || !(oar2 is Array))
|
|
{
|
|
SerializationTest.AssertEquals (message, oar1, oar2);
|
|
return;
|
|
}
|
|
|
|
Array ar1 = (Array) oar1;
|
|
Array ar2 = (Array) oar2;
|
|
|
|
SerializationTest.AssertEquals(message + ".Length", ar1.Length,ar2.Length);
|
|
|
|
for (int n=0; n<ar1.Length; n++)
|
|
{
|
|
object av1 = ar1.GetValue(n);
|
|
object av2 = ar2.GetValue(n);
|
|
SerializationTest.AssertEquals (message + "[" + n + "]", av1, av2);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
class PointSurrogate: ISerializationSurrogate
|
|
{
|
|
public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
|
|
{
|
|
Point p = (Point)obj;
|
|
info.AddValue ("xv",p.x);
|
|
info.AddValue ("yv",p.y);
|
|
}
|
|
|
|
public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
|
|
{
|
|
typeof (Point).GetField ("x").SetValue (obj, info.GetInt32 ("xv"));
|
|
typeof (Point).GetField ("y").SetValue (obj, info.GetInt32 ("yv"));
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class List
|
|
{
|
|
public string name = null;
|
|
public ListItem[] children = null;
|
|
public SomeValues values;
|
|
|
|
public void CheckEquals(List val)
|
|
{
|
|
SerializationTest.AssertEquals ("List.children.Length", children.Length, val.children.Length);
|
|
|
|
for (int n=0; n<children.Length; n++)
|
|
children[n].CheckEquals (val.children[n]);
|
|
|
|
SerializationTest.AssertEquals ("List.name", name, val.name);
|
|
values.CheckEquals (val.values);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class ListItem: ISerializable
|
|
{
|
|
public ListItem()
|
|
{
|
|
}
|
|
|
|
ListItem (SerializationInfo info, StreamingContext ctx)
|
|
{
|
|
next = (ListItem)info.GetValue ("next", typeof (ListItem));
|
|
value = (ListValue)info.GetValue ("value", typeof (ListValue));
|
|
label = info.GetString ("label");
|
|
}
|
|
|
|
public void GetObjectData (SerializationInfo info, StreamingContext ctx)
|
|
{
|
|
info.AddValue ("next", next);
|
|
info.AddValue ("value", value);
|
|
info.AddValue ("label", label);
|
|
}
|
|
|
|
public void CheckEquals(ListItem val)
|
|
{
|
|
SerializationTest.AssertEquals ("ListItem.next", next, val.next);
|
|
SerializationTest.AssertEquals ("ListItem.label", label, val.label);
|
|
value.CheckEquals (val.value);
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
ListItem val = (ListItem)obj;
|
|
if ((next == null || val.next == null) && (next != val.next)) return false;
|
|
if (next == null) return true;
|
|
if (!next.Equals(val.next)) return false;
|
|
return value.Equals (val.value) && label == val.label;
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return base.GetHashCode ();
|
|
}
|
|
|
|
public ListItem next;
|
|
public ListValue value;
|
|
public string label;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct ListValue
|
|
{
|
|
public int color;
|
|
public Point point;
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
ListValue val = (ListValue)obj;
|
|
return (color == val.color && point.Equals(val.point));
|
|
}
|
|
|
|
public void CheckEquals(ListValue val)
|
|
{
|
|
SerializationTest.AssertEquals ("ListValue.color", color, val.color);
|
|
point.CheckEquals (val.point);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return base.GetHashCode ();
|
|
}
|
|
}
|
|
|
|
// [Serializable]
|
|
public struct Point
|
|
{
|
|
public int x;
|
|
public int y;
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
Point p = (Point)obj;
|
|
return (x == p.x && y == p.y);
|
|
}
|
|
|
|
public void CheckEquals(Point p)
|
|
{
|
|
SerializationTest.AssertEquals ("Point.x", x, p.x);
|
|
SerializationTest.AssertEquals ("Point.y", y, p.y);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return base.GetHashCode ();
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class SimpleClass
|
|
{
|
|
public SimpleClass (char v) { val = v; }
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj == null) return false;
|
|
return val == ((SimpleClass)obj).val;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return val.GetHashCode();
|
|
}
|
|
|
|
public int SampleCall (string str, SomeValues sv, ref int acum)
|
|
{
|
|
acum += (int)val;
|
|
return (int)val;
|
|
}
|
|
|
|
public char val;
|
|
}
|
|
|
|
enum IntEnum { aaa, bbb, ccc }
|
|
enum ByteEnum: byte { aaa=221, bbb=3, ccc=44 }
|
|
|
|
delegate int SampleDelegate (string str, SomeValues sv, ref int acum);
|
|
|
|
[Serializable]
|
|
public class SomeValues
|
|
{
|
|
Type _type;
|
|
Type _type2;
|
|
DBNull _dbnull;
|
|
Assembly _assembly;
|
|
IntEnum _intEnum;
|
|
ByteEnum _byteEnum;
|
|
|
|
bool _bool;
|
|
bool _bool2;
|
|
byte _byte;
|
|
char _char;
|
|
// DateTime _dateTime;
|
|
decimal _decimal;
|
|
double _double;
|
|
short _short;
|
|
int _int;
|
|
long _long;
|
|
sbyte _sbyte;
|
|
float _float;
|
|
ushort _ushort;
|
|
uint _uint;
|
|
ulong _ulong;
|
|
|
|
object[] _objects;
|
|
string[] _strings;
|
|
int[] _ints;
|
|
public int[,,] _intsMulti;
|
|
int[][] _intsJagged;
|
|
SimpleClass[] _simples;
|
|
SimpleClass[,] _simplesMulti;
|
|
SimpleClass[][] _simplesJagged;
|
|
double[] _doubles;
|
|
object[] _almostEmpty;
|
|
|
|
object[] _emptyObjectArray;
|
|
Type[] _emptyTypeArray;
|
|
SimpleClass[] _emptySimpleArray;
|
|
int[] _emptyIntArray;
|
|
string[] _emptyStringArray;
|
|
|
|
|
|
SampleDelegate _sampleDelegate;
|
|
SampleDelegate _sampleDelegate2;
|
|
SampleDelegate _sampleDelegate3;
|
|
SampleDelegate _sampleDelegateStatic;
|
|
SampleDelegate _sampleDelegateCombined;
|
|
|
|
SimpleClass _shared1;
|
|
SimpleClass _shared2;
|
|
SimpleClass _shared3;
|
|
|
|
public void Init()
|
|
{
|
|
_type = typeof (string);
|
|
_type2 = typeof (SomeValues);
|
|
_dbnull = DBNull.Value;
|
|
_assembly = typeof (SomeValues).Assembly;
|
|
_intEnum = IntEnum.bbb;
|
|
_byteEnum = ByteEnum.ccc;
|
|
_bool = true;
|
|
_bool2 = false;
|
|
_byte = 254;
|
|
_char = 'A';
|
|
// _dateTime = new DateTime (1972,7,13,1,20,59);
|
|
_decimal = (decimal)101010.10101;
|
|
_double = 123456.6789;
|
|
_short = -19191;
|
|
_int = -28282828;
|
|
_long = 37373737373;
|
|
_sbyte = -123;
|
|
_float = (float)654321.321;
|
|
_ushort = 61616;
|
|
_uint = 464646464;
|
|
_ulong = 55555555;
|
|
|
|
Point p = new Point();
|
|
p.x = 56; p.y = 67;
|
|
object boxedPoint = p;
|
|
|
|
long i = 22;
|
|
object boxedLong = i;
|
|
|
|
_objects = new object[] { "string", (int)1234, null , /*boxedPoint, boxedPoint,*/ boxedLong, boxedLong};
|
|
_strings = new string[] { "an", "array", "of", "strings","I","repeat","an", "array", "of", "strings" };
|
|
_ints = new int[] { 4,5,6,7,8 };
|
|
_intsMulti = new int[2,3,4] { { {1,2,3,4},{5,6,7,8},{9,10,11,12}}, { {13,14,15,16},{17,18,19,20},{21,22,23,24} } };
|
|
_intsJagged = new int[2][] { new int[3] {1,2,3}, new int[2] {4,5} };
|
|
_simples = new SimpleClass[] { new SimpleClass('a'),new SimpleClass('b'),new SimpleClass('c') };
|
|
_simplesMulti = new SimpleClass[2,3] {{new SimpleClass('d'),new SimpleClass('e'),new SimpleClass('f')}, {new SimpleClass('g'),new SimpleClass('j'),new SimpleClass('h')}};
|
|
_simplesJagged = new SimpleClass[2][] { new SimpleClass[1] { new SimpleClass('i') }, new SimpleClass[2] {null, new SimpleClass('k')}};
|
|
_almostEmpty = new object[2000];
|
|
_almostEmpty[1000] = 4;
|
|
|
|
_emptyObjectArray = new object[0];
|
|
_emptyTypeArray = new Type[0];
|
|
_emptySimpleArray = new SimpleClass[0];
|
|
_emptyIntArray = new int[0];
|
|
_emptyStringArray = new string[0];
|
|
|
|
// FIXME: Once double.ToString("G17") is implemented
|
|
// we'll be able to serialize double.MaxValue and double.MinValue.
|
|
// Currently, it throws a System.OverflowException.
|
|
//_doubles = new double[] { 1010101.101010, 292929.29292, 3838383.38383, 4747474.474, 56565.5656565, 0, Double.NaN, Double.MaxValue, Double.MinValue, Double.NegativeInfinity, Double.PositiveInfinity };
|
|
_doubles = new double[] { 1010101.101010, 292929.29292, 3838383.38383, 4747474.474, 56565.5656565, 0, Double.NaN, Double.NegativeInfinity, Double.PositiveInfinity };
|
|
|
|
_sampleDelegate = new SampleDelegate(SampleCall);
|
|
_sampleDelegate2 = new SampleDelegate(_simples[0].SampleCall);
|
|
_sampleDelegate3 = new SampleDelegate(new SimpleClass('x').SampleCall);
|
|
_sampleDelegateStatic = new SampleDelegate(SampleStaticCall);
|
|
_sampleDelegateCombined = (SampleDelegate)Delegate.Combine (new Delegate[] {_sampleDelegate, _sampleDelegate2, _sampleDelegate3, _sampleDelegateStatic });
|
|
|
|
// This is to test that references are correctly solved
|
|
_shared1 = new SimpleClass('A');
|
|
_shared2 = new SimpleClass('A');
|
|
_shared3 = _shared1;
|
|
}
|
|
|
|
public int SampleCall (string str, SomeValues sv, ref int acum)
|
|
{
|
|
acum += _int;
|
|
return _int;
|
|
}
|
|
|
|
public static int SampleStaticCall (string str, SomeValues sv, ref int acum)
|
|
{
|
|
acum += 99;
|
|
return 99;
|
|
}
|
|
|
|
public void CheckEquals(SomeValues obj)
|
|
{
|
|
SerializationTest.AssertEquals ("SomeValues._type", _type, obj._type);
|
|
SerializationTest.AssertEquals ("SomeValues._type2", _type2, obj._type2);
|
|
SerializationTest.AssertEquals ("SomeValues._dbnull", _dbnull, obj._dbnull);
|
|
SerializationTest.AssertEquals ("SomeValues._assembly", _assembly, obj._assembly);
|
|
|
|
SerializationTest.AssertEquals ("SomeValues._intEnum", _intEnum, obj._intEnum);
|
|
SerializationTest.AssertEquals ("SomeValues._byteEnum", _byteEnum, obj._byteEnum);
|
|
SerializationTest.AssertEquals ("SomeValues._bool", _bool, obj._bool);
|
|
SerializationTest.AssertEquals ("SomeValues._bool2", _bool2, obj._bool2);
|
|
SerializationTest.AssertEquals ("SomeValues._byte", _byte, obj._byte);
|
|
SerializationTest.AssertEquals ("SomeValues._char", _char, obj._char);
|
|
// SerializationTest.AssertEquals ("SomeValues._dateTime", _dateTime, obj._dateTime);
|
|
SerializationTest.AssertEquals ("SomeValues._decimal", _decimal, obj._decimal);
|
|
SerializationTest.AssertEquals ("SomeValues._int", _int, obj._int);
|
|
SerializationTest.AssertEquals ("SomeValues._long", _long, obj._long);
|
|
SerializationTest.AssertEquals ("SomeValues._sbyte", _sbyte, obj._sbyte);
|
|
SerializationTest.AssertEquals ("SomeValues._float", _float, obj._float);
|
|
SerializationTest.AssertEquals ("SomeValues._ushort", _ushort, obj._ushort);
|
|
SerializationTest.AssertEquals ("SomeValues._uint", _uint, obj._uint);
|
|
SerializationTest.AssertEquals ("SomeValues._ulong", _ulong, obj._ulong);
|
|
|
|
SerializationTest.EqualsArray ("SomeValues._objects", _objects, obj._objects);
|
|
SerializationTest.EqualsArray ("SomeValues._strings", _strings, obj._strings);
|
|
SerializationTest.EqualsArray ("SomeValues._doubles", _doubles, obj._doubles);
|
|
SerializationTest.EqualsArray ("SomeValues._ints", _ints, obj._ints);
|
|
SerializationTest.EqualsArray ("SomeValues._simples", _simples, obj._simples);
|
|
SerializationTest.EqualsArray ("SomeValues._almostEmpty", _almostEmpty, obj._almostEmpty);
|
|
|
|
SerializationTest.EqualsArray ("SomeValues._emptyObjectArray", _emptyObjectArray, obj._emptyObjectArray);
|
|
SerializationTest.EqualsArray ("SomeValues._emptyTypeArray", _emptyTypeArray, obj._emptyTypeArray);
|
|
SerializationTest.EqualsArray ("SomeValues._emptySimpleArray", _emptySimpleArray, obj._emptySimpleArray);
|
|
SerializationTest.EqualsArray ("SomeValues._emptyIntArray", _emptyIntArray, obj._emptyIntArray);
|
|
SerializationTest.EqualsArray ("SomeValues._emptyStringArray", _emptyStringArray, obj._emptyStringArray);
|
|
|
|
for (int i=0; i<2; i++)
|
|
for (int j=0; j<3; j++)
|
|
for (int k=0; k<4; k++)
|
|
SerializationTest.AssertEquals("SomeValues._intsMulti[" + i + "," + j + "," + k + "]", _intsMulti[i,j,k], obj._intsMulti[i,j,k]);
|
|
|
|
for (int i=0; i<_intsJagged.Length; i++)
|
|
for (int j=0; j<_intsJagged[i].Length; j++)
|
|
SerializationTest.AssertEquals ("SomeValues._intsJagged[" + i + "][" + j + "]", _intsJagged[i][j], obj._intsJagged[i][j]);
|
|
|
|
for (int i=0; i<2; i++)
|
|
for (int j=0; j<3; j++)
|
|
SerializationTest.AssertEquals ("SomeValues._simplesMulti[" + i + "," + j + "]", _simplesMulti[i,j], obj._simplesMulti[i,j]);
|
|
|
|
for (int i=0; i<_simplesJagged.Length; i++)
|
|
SerializationTest.EqualsArray ("SomeValues._simplesJagged", _simplesJagged[i], obj._simplesJagged[i]);
|
|
|
|
int acum = 0;
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate", _sampleDelegate ("hi", this, ref acum), _int);
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate_bis", _sampleDelegate ("hi", this, ref acum), obj._sampleDelegate ("hi", this, ref acum));
|
|
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate2", _sampleDelegate2 ("hi", this, ref acum), (int)_simples[0].val);
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate2_bis", _sampleDelegate2 ("hi", this, ref acum), obj._sampleDelegate2 ("hi", this, ref acum));
|
|
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate3", _sampleDelegate3 ("hi", this, ref acum), (int)'x');
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegate3_bis", _sampleDelegate3 ("hi", this, ref acum), obj._sampleDelegate3 ("hi", this, ref acum));
|
|
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegateStatic", _sampleDelegateStatic ("hi", this, ref acum), 99);
|
|
SerializationTest.AssertEquals ("SomeValues._sampleDelegateStatic_bis", _sampleDelegateStatic ("hi", this, ref acum), obj._sampleDelegateStatic ("hi", this, ref acum));
|
|
|
|
int acum1 = 0;
|
|
int acum2 = 0;
|
|
_sampleDelegateCombined ("hi", this, ref acum1);
|
|
obj._sampleDelegateCombined ("hi", this, ref acum2);
|
|
|
|
SerializationTest.AssertEquals ("_sampleDelegateCombined", acum1, _int + (int)_simples[0].val + (int)'x' + 99);
|
|
SerializationTest.AssertEquals ("_sampleDelegateCombined_bis", acum1, acum2);
|
|
|
|
SerializationTest.AssertEquals ("SomeValues._shared1", _shared1, _shared2);
|
|
SerializationTest.AssertEquals ("SomeValues._shared1_bis", _shared1, _shared3);
|
|
|
|
_shared1.val = 'B';
|
|
SerializationTest.AssertEquals ("SomeValues._shared2", _shared2.val, 'A');
|
|
SerializationTest.AssertEquals ("SomeValues._shared3", _shared3.val, 'B');
|
|
}
|
|
}
|
|
|
|
class MethodTester : MarshalByRefObject
|
|
{
|
|
public int OverloadedMethod ()
|
|
{
|
|
return 123456789;
|
|
}
|
|
|
|
public int OverloadedMethod (int a)
|
|
{
|
|
return a+2;
|
|
}
|
|
|
|
public int OverloadedMethod (int[] a)
|
|
{
|
|
return a.Length;
|
|
}
|
|
|
|
public void NoReturn ()
|
|
{}
|
|
|
|
public string Simple (string a, int b)
|
|
{
|
|
return a + b;
|
|
}
|
|
|
|
public SimpleClass Simple2 (char c)
|
|
{
|
|
return new SimpleClass(c);
|
|
}
|
|
|
|
public SimpleClass Simple3 (char[] c)
|
|
{
|
|
if (c != null) return new SimpleClass(c[0]);
|
|
else return null;
|
|
}
|
|
|
|
public int SomeMethod (int a, SimpleClass b)
|
|
{
|
|
object[] d;
|
|
string c = "hi";
|
|
int r = a + c.Length;
|
|
c = "bye";
|
|
d = new object[3];
|
|
d[1] = b;
|
|
return r;
|
|
}
|
|
}
|
|
|
|
class AuxProxy: RealProxy
|
|
{
|
|
public static bool useHeaders = false;
|
|
Stream _stream;
|
|
string _uri;
|
|
IMethodMessage _testMsg;
|
|
|
|
public AuxProxy(Stream stream, string uri): base(typeof(MethodTester))
|
|
{
|
|
_stream = stream;
|
|
_uri = uri;
|
|
}
|
|
|
|
public void SetTestMessage (IMessage msg)
|
|
{
|
|
_testMsg = (IMethodMessage)msg;
|
|
_testMsg.Properties["__Uri"] = _uri;
|
|
}
|
|
|
|
public override IMessage Invoke(IMessage msg)
|
|
{
|
|
IMethodCallMessage call = (IMethodCallMessage)msg;
|
|
if (call.MethodName.StartsWith ("Initialize")) return new ReturnMessage(null,null,0,null,(IMethodCallMessage)msg);
|
|
|
|
call.Properties["__Uri"] = _uri;
|
|
|
|
if (_stream != null)
|
|
{
|
|
SerializeCall (call);
|
|
IMessage response = ChannelServices.SyncDispatchMessage (call);
|
|
SerializeResponse (response);
|
|
return response;
|
|
}
|
|
else if (_testMsg != null)
|
|
{
|
|
if (_testMsg is IMethodCallMessage)
|
|
return ChannelServices.SyncDispatchMessage (_testMsg);
|
|
else
|
|
return _testMsg;
|
|
}
|
|
else
|
|
return ChannelServices.SyncDispatchMessage (call);
|
|
}
|
|
|
|
void SerializeCall (IMessage call)
|
|
{
|
|
RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
|
|
IRemotingFormatter fmt = new SoapFormatter (rss, new StreamingContext(StreamingContextStates.Remoting));
|
|
fmt.Serialize (_stream, call, GetHeaders());
|
|
}
|
|
|
|
void SerializeResponse (IMessage resp)
|
|
{
|
|
RemotingSurrogateSelector rss = new RemotingSurrogateSelector();
|
|
IRemotingFormatter fmt = new SoapFormatter (rss, new StreamingContext(StreamingContextStates.Remoting));
|
|
fmt.Serialize (_stream, resp, GetHeaders());
|
|
}
|
|
|
|
Header[] GetHeaders()
|
|
{
|
|
Header[] hs = null;
|
|
if (useHeaders)
|
|
{
|
|
hs = new Header[1];
|
|
hs[0] = new Header("unom",new SimpleClass('R'));
|
|
}
|
|
return hs;
|
|
}
|
|
}
|
|
|
|
public class TestBinder : SerializationBinder
|
|
{
|
|
public override Type BindToType (string assemblyName, string typeName)
|
|
{
|
|
if (typeName.IndexOf("BinderTester_A") != -1)
|
|
typeName = typeName.Replace ("BinderTester_A", "BinderTester_B");
|
|
|
|
return Assembly.Load (assemblyName).GetType (typeName);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class BinderTester_A
|
|
{
|
|
public int x;
|
|
public string y;
|
|
}
|
|
|
|
[Serializable]
|
|
public class BinderTester_B
|
|
{
|
|
public string y;
|
|
public int x;
|
|
}
|
|
|
|
|
|
}
|