public void ShallCallReturnValue(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.TwoWayCalled);
//Act
var result = remoteObject.CallTwoWayWithReturnValue(1, true, "qwerty", 123.123);
//Assert
Assert.IsTrue(hostedObject.TwoWayWithReturnValueCalled);
AssertComplexParameter(new ComplexParameter
{
A = 1,
B = true,
S = "qwerty",
D = 123.123
}, result);
}
}
public void ShallHideExceptionForOneWaySetters(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
hostedObject.Value = 0;
hostedObject.Action = () => throw new InvalidOperationException("qwerty");
//Act
remoteObject.OneWaySet = 5;
//Assert
Assert.AreEqual(0, hostedObject.Value);
//Act
remoteObject.OneWayGetSet = 5;
//Assert
Assert.AreEqual(0, hostedObject.Value);
}
}
public void ShallKeepReferenceIfSubscribed(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
{
server.Add <IContract>(objectId, hostedObject);
WeakReference weakRef;
using (var client = new EloquentClient(serverAddress, clientAddress))
{
var remoteObject = client.Connect <IContract>(objectId);
remoteObject.ValueChanged += RemoteObjectOnValueChanged;
weakRef = new WeakReference(remoteObject);
Assert.IsTrue(weakRef.IsAlive);
//Act
remoteObject = null;
GC.Collect();
Assert.IsNull(remoteObject);
Assert.IsTrue(weakRef.IsAlive);
}
GC.Collect();
Assert.IsFalse(weakRef.IsAlive);
}
}
public void ShallReleaseIfNotUsed(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
{
server.Add <IContract>(objectId, hostedObject);
using (var client = new EloquentClient(serverAddress, clientAddress))
{
var remoteObject = client.Connect <IContract>(objectId);
remoteObject.Value = 5;
Assert.AreEqual(5, remoteObject.Value);
var weakRef = new WeakReference(remoteObject);
Assert.IsTrue(weakRef.IsAlive);
//Act
remoteObject = null;
GC.Collect();
//Assert
Assert.IsNull(remoteObject);
Assert.IsFalse(weakRef.IsAlive);
}
}
}
public void ShallUseDefaultParametersIfAny(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.TwoWayCalled);
//Act
remoteObject.CallTwoWayWithDefaultParameter();
//Assert
Assert.AreEqual(new[] { 5 }, hostedObject.Parameters);
//Act
remoteObject.CallTwoWayWithDefaultParameter(6);
//Assert
Assert.AreEqual(new[] { 6 }, hostedObject.Parameters);
}
}
public void ShallRethrowExceptionWhenCalledRemoteMethodsTwoWay(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.TwoWayWithExceptionCalled);
//Act
var e = Assert.Catch <FaultException>(() => { remoteObject.CallTwoWayWithException("qwerty"); });
//Assert
Assert.IsTrue(hostedObject.TwoWayWithExceptionCalled);
Assert.IsInstanceOf <FaultException>(e);
Assert.AreEqual("qwerty", e.Message);
Assert.AreEqual(typeof(InvalidOperationException).FullName, e.ExceptionType);
}
}
public void ShallGetValuesForProperties(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
//Act
hostedObject.Value = 5;
hostedObject.ComplexValue = new ComplexParameter
{
A = 1,
B = true,
D = 123.123,
S = "qwerty"
};
//Assert
Assert.AreEqual(5, remoteObject.Get);
Assert.AreEqual(5, remoteObject.GetSet);
Assert.AreEqual(5, remoteObject.OneWayGetSet);
AssertComplexParameter(new ComplexParameter
{
A = 1,
B = true,
D = 123.123,
S = "qwerty"
}, remoteObject.ComplexGetSet);
//Act
hostedObject.Value = 7;
hostedObject.ComplexValue = new ComplexParameter
{
A = 2,
B = false,
D = 234.234,
S = "asd"
};
//Assert
Assert.AreEqual(7, remoteObject.Get);
Assert.AreEqual(7, remoteObject.GetSet);
Assert.AreEqual(7, remoteObject.OneWayGetSet);
AssertComplexParameter(new ComplexParameter
{
A = 2,
B = false,
D = 234.234,
S = "asd"
}, remoteObject.ComplexGetSet);
}
}
public void ShallRaiseExceptionForTwoWaySetters(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
hostedObject.Value = 0;
hostedObject.Action = () => throw new InvalidOperationException("qwerty");
//Act
var exception = Assert.Catch <FaultException>(() => { remoteObject.Set = 5; });
//Assert
Assert.AreEqual(0, hostedObject.Value);
Assert.AreEqual("qwerty", exception.Message);
Assert.AreEqual(typeof(InvalidOperationException).FullName, exception.ExceptionType);
//Act
exception = Assert.Catch <FaultException>(() => { remoteObject.GetSet = 5; });
//Assert
Assert.AreEqual(0, hostedObject.Value);
Assert.AreEqual("qwerty", exception.Message);
Assert.AreEqual(typeof(InvalidOperationException).FullName, exception.ExceptionType);
//Act
exception = Assert.Catch <FaultException>(() =>
{
remoteObject.ComplexGetSet = new ComplexParameter {
A = 5
};
});
//Assert
Assert.AreEqual(0, hostedObject.Value);
Assert.AreEqual("qwerty", exception.Message);
Assert.AreEqual(typeof(InvalidOperationException).FullName, exception.ExceptionType);
//Act
ComplexParameter complex = null;
exception = Assert.Catch <FaultException>(() => { complex = remoteObject.ComplexGetSet; });
//Assert
Assert.AreEqual(null, complex);
Assert.AreEqual("qwerty", exception.Message);
Assert.AreEqual(typeof(InvalidOperationException).FullName, exception.ExceptionType);
}
}
internal static ASBinCode.rtData.rtObjectBase createPureHostdOrLinkObject(Player player,Class cls)
{
if (cls.isLink_System)
{
ASBinCode.rtData.rtObjectBase rb; ASBinCode.rtData.rtObjectBase lr; string err;
ASBinCode.rtti.Object obj = createObject(player.swc,cls,null,out rb,out lr,out err);
ASBinCode.rtData.rtObjectBase rtObj;
if (lr != null)
{
rtObj = lr;
}
else
{
rtObj = new ASBinCode.rtData.rtObject(obj,null);
}
RunTimeScope scope = new RunTimeScope(
null
//player.genHeapFromCodeBlock(player.swc.blocks[cls.blockid])
,cls.blockid,null,rtObj,
RunTimeScopeType.objectinstance);
rtObj.objScope = scope;
return(rtObj);
}
else if (cls.isUnmanaged)
{
ASBinCode.rtti.Object obj;
if (cls.dynamic)
{
obj = new HostedDynamicObject(cls);
}
else
{
obj = new HostedObject(cls);
}
ASBinCode.rtData.rtObject rtObj = new ASBinCode.rtData.rtObject(obj,null);
RunTimeScope scope = new RunTimeScope(
player.genHeapFromCodeBlock(player.swc.blocks[cls.blockid]),
cls.blockid,null,rtObj,RunTimeScopeType.objectinstance);
rtObj.objScope = scope;
return(rtObj);
}
else
{
throw new EngineException();
}
}
public void ShallReleaseParentIfNotUsed(string serverAddress, string clientAddress)
{
//Arrange
var parentObjectId = "1";
var childObjectId = "2";
var parent = new HostedObject();
parent.Child = new HostedObject();
using (var server = new EloquentServer(serverAddress))
{
server.Add <IContract>(parentObjectId, parent);
server.Add(childObjectId, parent.Child);
using (var client = new EloquentClient(serverAddress, clientAddress))
{
var parentRemoteObject = client.Connect <IContract>(parentObjectId);
var childRemoteObject = parentRemoteObject.Child;
childRemoteObject.Value = 5;
Assert.AreEqual(5, childRemoteObject.Value);
var parentWeakRef = new WeakReference(parentRemoteObject);
var childWeakRef = new WeakReference(childRemoteObject);
Assert.IsTrue(parentWeakRef.IsAlive);
Assert.IsTrue(childWeakRef.IsAlive);
//Act
parentRemoteObject = null;
GC.Collect();
//Assert
Assert.AreEqual(5, childRemoteObject.Value);
Assert.IsNull(parentRemoteObject);
Assert.IsFalse(parentWeakRef.IsAlive);
Assert.IsTrue(childWeakRef.IsAlive);
//Act
childRemoteObject = null;
GC.Collect();
//Assert
Assert.IsNull(childRemoteObject);
Assert.IsFalse(parentWeakRef.IsAlive);
Assert.IsFalse(childWeakRef.IsAlive);
}
}
}
public void ShallRaiseEventWithoutParameters(string serverAddress, string client1Address, string client2Address)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client1 = new EloquentClient(serverAddress, client1Address))
using (var client2 = new EloquentClient(serverAddress, client2Address))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject1 = client1.Connect <IContract>(objectId);
var remoteObject2 = client2.Connect <IContract>(objectId);
var noParameterEvent1Called = false;
var noParameterEvent2Called = false;
var autoResetEvent1 = new AutoResetEvent(false);
var autoResetEvent2 = new AutoResetEvent(false);
remoteObject1.NoParameterEvent += () =>
{
noParameterEvent1Called = true;
autoResetEvent1.Set();
};
remoteObject2.NoParameterEvent += () =>
{
noParameterEvent2Called = true;
autoResetEvent2.Set();
};
//Act
Assert.IsFalse(noParameterEvent1Called);
Assert.IsFalse(noParameterEvent2Called);
hostedObject.SendNoParametersEvent();
autoResetEvent1.WaitOne(2000);
autoResetEvent2.WaitOne(2000);
//Assert
Assert.IsTrue(noParameterEvent1Called);
//TODO: Failed during long run
Assert.IsTrue(noParameterEvent2Called);
}
}
public void ShallHostAgain(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
{
server.Add <IContract>(objectId, hostedObject);
using (var client = new EloquentClient(serverAddress, clientAddress))
{
var remoteObject = client.Connect <IContract>(objectId);
//Act
remoteObject.Value = 5;
//Assert
Assert.AreEqual(5, remoteObject.Value);
}
}
using (var server = new EloquentServer(serverAddress))
{
server.Add <IContract>(objectId, hostedObject);
using (var client = new EloquentClient(serverAddress, clientAddress))
{
var remoteObject = client.Connect <IContract>(objectId);
//Assert
Assert.AreEqual(5, remoteObject.Value);
//Act
remoteObject.Value = 6;
//Assert
Assert.AreEqual(6, remoteObject.Value);
}
}
}
public void ShallCallRemoteMethodsTwoWay(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.TwoWayCalled);
//Act
remoteObject.CallTwoWay();
//Assert
Assert.IsTrue(hostedObject.TwoWayCalled);
}
}
public void ShallHideExceptionWhenCalledRemoteMethodsOneWay(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.OneWayWithExceptionCalled);
//Act
remoteObject.CallOneWayWithException();
hostedObject.WaitCallCompleted();
//Assert
Assert.IsTrue(hostedObject.OneWayWithExceptionCalled);
}
}
private static ASBinCode.rtti.Object createObject(CSWC swc,Class cls,InstanceCreator creator,
out ASBinCode.rtData.rtObjectBase rtObjectBase,
out ASBinCode.rtData.rtObjectBase linkrtobj,
out string errinfo
)
{
ASBinCode.rtti.Object obj = null;// = new ASBinCode.rtti.Object(cls);
rtObjectBase = null; linkrtobj = null; errinfo = null;
if (cls.isLink_System)
{
if (creator != null)
{
StackSlot stackSlot = creator.objectStoreToSlot as StackSlot;
if (stackSlot != null)
{
rtObjectBase = stackSlot.getStackCacheObject(cls);
return(rtObjectBase.value);
}
}
var func = (NativeFunctionBase)swc.class_Creator[cls];
string err; int no;
ASBinCode.rtData.rtObjectBase rtObj =
func.execute(null,null,cls,out err,out no) as ASBinCode.rtData.rtObjectBase;
linkrtobj = rtObj;
if (rtObj == null)
{
errinfo = cls.ToString() + " create linksystem object failed";
return(null);
}
else
{
return(rtObj.value);
}
}
else if (cls.isCrossExtend)
{
var scls = cls.super;
while (!scls.isLink_System)
{
scls = scls.super;
}
var cextend = scls.staticClass.linkObjCreator;
var func = swc.getNativeFunction(((ClassMethodGetter)cextend.bindField).functionId);
if (func == null)
{
errinfo = cls.ToString() + " create crossextend object failed, creator function not found";
return(null);
}
string err; int no;
ASBinCode.rtData.rtObjectBase rtObj =
func.execute(null,null,cls,out err,out no) as ASBinCode.rtData.rtObjectBase;
linkrtobj = rtObj;
if (rtObj == null)
{
errinfo = cls.ToString() + " create crossextend object failed";
return(null);
}
else
{
LinkSystemObject lo = (LinkSystemObject)rtObj.value;
return(lo);
}
}
else if (
swc.DictionaryClass != null
&&
ClassMemberFinder.isInherits(cls,swc.DictionaryClass))
{
obj = new DictionaryObject(cls);
}
else if (cls.dynamic)
{
if (cls.isUnmanaged)
{
obj = new HostedDynamicObject(cls);
}
else
{
obj = new DynamicObject(cls);
}
}
else if (cls.isUnmanaged)
{
obj = new HostedObject(cls);
}
else
{
obj = new ASBinCode.rtti.Object(cls);
}
return(obj);
}
public void ShallCallRemoteMethodsOneWayWithParameters(string serverAddress, string clientAddress)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client = new EloquentClient(serverAddress, clientAddress))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject = client.Connect <IContract>(objectId);
Assert.IsFalse(hostedObject.OneWayWithParameterCalled);
//Act
var complexParameter1 = new ComplexParameter
{
A = 5,
B = true,
D = 543.543,
S = "asd"
};
var complexParameter2 = new ComplexParameter
{
A = 6,
B = false,
D = 345.345,
S = "zxc"
};
var complexParameter3 = new ComplexParameter
{
A = 5,
B = true,
D = 543.543,
S = "123"
};
remoteObject.CallOneWayWithParameters(
1,
false,
"qwerty",
123.123,
complexParameter1,
new[] { 1, 2, 3 },
new[] { false, true, false },
new[] { "123", "qwe", "zxc" },
new[] { 1.123, 2.234, 3.345 },
new[]
{
complexParameter2,
complexParameter3,
});
hostedObject.WaitCallCompleted();
//Assert
Assert.IsTrue(hostedObject.OneWayWithParameterCalled);
Assert.AreEqual(1, hostedObject.Parameters[0]);
Assert.AreEqual(false, hostedObject.Parameters[1]);
Assert.AreEqual("qwerty", hostedObject.Parameters[2]);
Assert.AreEqual(123.123, hostedObject.Parameters[3]);
AssertComplexParameter(complexParameter1, (ComplexParameter)hostedObject.Parameters[4]);
Assert.AreEqual(new[] { 1, 2, 3 }, hostedObject.Parameters[5]);
Assert.AreEqual(new[] { false, true, false }, hostedObject.Parameters[6]);
Assert.AreEqual(new[] { "123", "qwe", "zxc" }, hostedObject.Parameters[7]);
Assert.AreEqual(new[] { 1.123, 2.234, 3.345 }, hostedObject.Parameters[8]);
Assert.AreEqual(2, ((ComplexParameter[])hostedObject.Parameters[9]).Length);
AssertComplexParameter(complexParameter2, ((ComplexParameter[])hostedObject.Parameters[9])[0]);
AssertComplexParameter(complexParameter3, ((ComplexParameter[])hostedObject.Parameters[9])[1]);
//Act
hostedObject.OneWayWithParameterCalled = false;
hostedObject.Parameters = null;
Assert.IsFalse(hostedObject.OneWayWithParameterCalled);
remoteObject.CallOneWayWithParameters(
2,
true,
null,
234.234,
null,
null,
null,
null,
null,
null);
hostedObject.WaitCallCompleted();
//Assert
Assert.IsTrue(hostedObject.OneWayWithParameterCalled);
Assert.AreEqual(2, hostedObject.Parameters[0]);
Assert.AreEqual(true, hostedObject.Parameters[1]);
Assert.AreEqual(null, hostedObject.Parameters[2]);
Assert.AreEqual(234.234, hostedObject.Parameters[3]);
Assert.AreEqual(null, hostedObject.Parameters[4]);
Assert.AreEqual(null, hostedObject.Parameters[5]);
Assert.AreEqual(null, hostedObject.Parameters[6]);
Assert.AreEqual(null, hostedObject.Parameters[7]);
}
}
public override void execute3(RunTimeValueBase thisObj, FunctionDefine functionDefine, SLOT returnSlot,SourceToken token,StackFrame stackframe,out bool success)
{
//
//((rtObject)thisObj).value.memberData[0].directSet(newvalue);
string pattern = TypeConverter.ConvertToString(argements[0],stackframe,token);
string options = TypeConverter.ConvertToString(argements[1],stackframe,token);
string pv = "/";
if (pattern != null)
{
pv = pv + pattern;
}
pv = pv + "/";
var Options = System.Text.RegularExpressions.RegexOptions.None;
if (options != null)
{
pv = pv + options;
if (options.IndexOf('s') >= 0)
{
((rtObjectBase)thisObj).value.memberData[1].directSet(rtBoolean.True);
Options |= System.Text.RegularExpressions.RegexOptions.Singleline;
}
if (options.IndexOf('x') >= 0)
{
((rtObjectBase)thisObj).value.memberData[2].directSet(rtBoolean.True);
Options |= System.Text.RegularExpressions.RegexOptions.IgnorePatternWhitespace;
}
if (options.IndexOf('g') >= 0)
{
((rtObjectBase)thisObj).value.memberData[3].directSet(rtBoolean.True);
}
if (options.IndexOf('i') >= 0)
{
((rtObjectBase)thisObj).value.memberData[4].directSet(rtBoolean.True);
Options |= System.Text.RegularExpressions.RegexOptions.IgnoreCase;
}
if (options.IndexOf('m') >= 0)
{
((rtObjectBase)thisObj).value.memberData[5].directSet(rtBoolean.True);
Options |= System.Text.RegularExpressions.RegexOptions.Multiline;
}
}
((rtObjectBase)thisObj).value.memberData[0].directSet(new rtString(pv));
if (pattern != null)
{
((rtObjectBase)thisObj).value.memberData[6].directSet(new rtString(pattern));
}
else
{
((rtObjectBase)thisObj).value.memberData[6].directSet(rtNull.nullptr);
}
((rtObjectBase)thisObj).value.memberData[7].directSet(new rtNumber(0));
try
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(pattern, Options);
HostedObject hobj = new HostedObject(stackframe.player.swc.ObjectClass);
hobj.hosted_object = regex;
rtObject rtobj = new rtObject(hobj, null);
((rtObjectBase)thisObj).value.memberData[8].directSet(rtobj);
success = true;
returnSlot.directSet(rtUndefined.undefined);
}
catch (ArgumentException ex)
{
success = false;
stackframe.throwArgementException(token, ex.Message);
}
//((HostedObject)((rtObject)thisObj).value).hosted_object = regex;
}
public void ShallRaiseEventWithParameters(string serverAddress, string client1Address, string client2Address)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client1 = new EloquentClient(serverAddress, client1Address))
using (var client2 = new EloquentClient(serverAddress, client2Address))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject1 = client1.Connect <IContract>(objectId);
var remoteObject2 = client2.Connect <IContract>(objectId);
object[] parameters1 = null;
object[] parameters2 = null;
var autoResetEvent1 = new AutoResetEvent(false);
var autoResetEvent2 = new AutoResetEvent(false);
remoteObject1.EventWithParameters += (i, b, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) =>
{
parameters1 = new object[]
{
i, b, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10
};
autoResetEvent1.Set();
};
remoteObject2.EventWithParameters += (i, b, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) =>
{
parameters2 = new object[]
{
i, b, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10
};
autoResetEvent2.Set();
};
//Act
Assert.IsNull(parameters1);
Assert.IsNull(parameters2);
//Act
var complexParameter1 = new ComplexParameter
{
A = 5,
B = true,
D = 543.543,
S = "asd"
};
var complexParameter2 = new ComplexParameter
{
A = 6,
B = false,
D = 345.345,
S = "zxc"
};
var complexParameter3 = new ComplexParameter
{
A = 5,
B = true,
D = 543.543,
S = "123"
};
hostedObject.SendEventWithParameters(
1,
false,
"qwerty",
123.123,
complexParameter1,
new[] { 1, 2, 3 },
new[] { false, true, false },
new[] { "123", "qwe", "zxc" },
new[] { 1.123, 2.234, 3.345 },
new[]
{
complexParameter2,
complexParameter3,
});
autoResetEvent1.WaitOne(2000);
autoResetEvent2.WaitOne(2000);
Assert.NotNull(parameters1);
Assert.NotNull(parameters2);
Assert.AreEqual(1, parameters1[0]);
Assert.AreEqual(false, parameters1[1]);
Assert.AreEqual("qwerty", parameters1[2]);
Assert.AreEqual(123.123, parameters1[3]);
AssertComplexParameter(complexParameter1, (ComplexParameter)parameters1[4]);
Assert.AreEqual(new[] { 1, 2, 3 }, parameters1[5]);
Assert.AreEqual(new[] { false, true, false }, parameters1[6]);
Assert.AreEqual(new[] { "123", "qwe", "zxc" }, parameters1[7]);
Assert.AreEqual(new[] { 1.123, 2.234, 3.345 }, parameters1[8]);
Assert.AreEqual(2, ((ComplexParameter[])parameters1[9]).Length);
AssertComplexParameter(complexParameter2, ((ComplexParameter[])parameters1[9])[0]);
AssertComplexParameter(complexParameter3, ((ComplexParameter[])parameters1[9])[1]);
Assert.AreEqual(1, parameters2[0]);
Assert.AreEqual(false, parameters2[1]);
Assert.AreEqual("qwerty", parameters2[2]);
Assert.AreEqual(123.123, parameters2[3]);
AssertComplexParameter(complexParameter1, (ComplexParameter)parameters2[4]);
Assert.AreEqual(new[] { 1, 2, 3 }, parameters2[5]);
Assert.AreEqual(new[] { false, true, false }, parameters2[6]);
Assert.AreEqual(new[] { "123", "qwe", "zxc" }, parameters2[7]);
Assert.AreEqual(new[] { 1.123, 2.234, 3.345 }, parameters2[8]);
Assert.AreEqual(2, ((ComplexParameter[])parameters2[9]).Length);
AssertComplexParameter(complexParameter2, ((ComplexParameter[])parameters2[9])[0]);
AssertComplexParameter(complexParameter3, ((ComplexParameter[])parameters2[9])[1]);
}
}
public void ShallRaiseRegularEventWithClientAsSender(string serverAddress, string client1Address,
string client2Address)
{
//Arrange
var objectId = "obj";
var hostedObject = new HostedObject();
using (var server = new EloquentServer(serverAddress))
using (var client1 = new EloquentClient(serverAddress, client1Address))
using (var client2 = new EloquentClient(serverAddress, client2Address))
{
server.Add <IContract>(objectId, hostedObject);
var remoteObject1 = client1.Connect <IContract>(objectId);
var remoteObject2 = client2.Connect <IContract>(objectId);
var remoteObject3 = client2.Connect <IContract>(objectId);
Assert.AreNotSame(remoteObject1, remoteObject2);
Assert.AreNotSame(remoteObject2, remoteObject3);
object sender1 = null;
object sender2 = null;
object sender3 = null;
object sender4 = null;
ComplexParameter args1 = null;
ComplexParameter args2 = null;
ComplexParameter args3 = null;
ComplexParameter args4 = null;
var autoResetEvent1 = new AutoResetEvent(false);
var autoResetEvent2 = new AutoResetEvent(false);
var autoResetEvent3 = new AutoResetEvent(false);
var autoResetEvent4 = new AutoResetEvent(false);
remoteObject1.RegularEvent += (s, args) =>
{
sender1 = s;
args1 = args;
autoResetEvent1.Set();
};
remoteObject2.RegularEvent += (s, args) =>
{
sender2 = s;
args2 = args;
autoResetEvent2.Set();
};
remoteObject3.RegularEvent += (s, args) =>
{
sender3 = s;
args3 = args;
autoResetEvent3.Set();
};
remoteObject3.RegularEvent += (s, args) =>
{
sender4 = s;
args4 = args;
autoResetEvent4.Set();
};
var complexParameter1 = new ComplexParameter
{
A = 5,
B = true,
D = 543.543,
S = "asd"
};
Assert.IsNull(sender1);
Assert.IsNull(sender2);
Assert.IsNull(sender3);
Assert.IsNull(sender4);
Assert.IsNull(args1);
Assert.IsNull(args2);
Assert.IsNull(args3);
Assert.IsNull(args4);
//Act
hostedObject.SendRegularEvent(complexParameter1);
autoResetEvent1.WaitOne(2000);
autoResetEvent2.WaitOne(2000);
autoResetEvent3.WaitOne(2000);
autoResetEvent4.WaitOne(2000);
//Assert
Assert.AreSame(remoteObject1, sender1);
Assert.AreSame(remoteObject2, sender2);
Assert.AreSame(remoteObject3, sender3);
Assert.AreSame(remoteObject3, sender4);
AssertComplexParameter(complexParameter1, args1);
AssertComplexParameter(complexParameter1, args2);
AssertComplexParameter(complexParameter1, args3);
AssertComplexParameter(complexParameter1, args4);
}
}
