public static Task VoidWithEightParametersAsync(
ComplexParameter parameter1,
byte parameter2,
DotNetObjectReference <TestDTO> parameter3,
int parameter4,
long parameter5,
float parameter6,
List <double> parameter7,
Segment parameter8)
{
Invocations[nameof(VoidWithEightParametersAsync)] = new object[] { parameter1, parameter2, parameter3.Value.GetNonSerializedValue(), parameter4, parameter5, parameter6, parameter7, parameter8 };
return(Task.CompletedTask);
}
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);
}
}
public static object[] EchoTwoParameters(
ComplexParameter parameter1,
byte parameter2)
{
return(new object[] { parameter1, parameter2 });
}
public static object[] EchoOneParameter(ComplexParameter parameter1)
{
return(new object[] { parameter1 });
}
public void ShallSetValuesForProperties(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);
var complexParameter = new ComplexParameter
{
A = 2,
B = false,
D = 234.234,
S = "asd"
};
hostedObject.ComplexValue = complexParameter;
Assert.AreEqual(0, hostedObject.Value);
AssertComplexParameter(complexParameter, hostedObject.ComplexValue);
//Act
remoteObject.Set = 5;
//Assert
Assert.AreEqual(5, hostedObject.Value);
//Act
remoteObject.OneWaySet = 7;
hostedObject.WaitSet();
//Assert
Assert.AreEqual(7, hostedObject.Value);
//Act
remoteObject.OneWayGetSet = 9;
hostedObject.WaitSet();
//Assert
Assert.AreEqual(9, hostedObject.Value);
//Act
remoteObject.GetSet = 11;
//Assert
Assert.AreEqual(11, hostedObject.Value);
//Act
var complexParameter2 = new ComplexParameter
{
A = 1,
B = true,
D = 123.123,
S = "qwerty"
};
remoteObject.ComplexGetSet = complexParameter2;
//Assert
AssertComplexParameter(complexParameter2, hostedObject.ComplexValue);
}
}
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 static void VoidWithOneParameter(ComplexParameter parameter1)
{
Invocations[nameof(VoidWithOneParameter)] = new object[] { parameter1 };
}
public static Task <object[]> EchoOneParameterAsync(ComplexParameter parameter1)
{
return(Task.FromResult(new object[] { parameter1 }));
}
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 EntryPoint(IContext context, ComplexParameter arg1)
{
}
public void Run(IContext context, ComplexParameter complexParameter)
{
Console.WriteLine(complexParameter.Message);
Console.WriteLine(complexParameter.HostProcessId);
}
public void RedisStorageStoresAndRetrievesComplexObjects()
{
var objectToStore = new ComplexParameter()
{
SomeProperty = "this is string",
AnotherProperty = 47
};
var objectName = Guid.NewGuid().ToString();
using (var storage = new RedisStorage(RedisStorageTests.Host))
{
storage.Store(objectName, objectToStore);
var retrievedObject = storage.Retrieve<ComplexParameter>(objectName);
retrievedObject.SomeProperty.ShouldBe(objectToStore.SomeProperty);
retrievedObject.AnotherProperty.ShouldBe(objectToStore.AnotherProperty);
}
}
public void RedisStorageStoresAndRetrievesComplexObjectsInBulks()
{
var objectToStore = new ComplexParameter()
{
SomeProperty = "this is string",
AnotherProperty = 47
};
KeyValuePair<string, ComplexParameter>[] objectsToStore = new KeyValuePair<string, ComplexParameter>[100];
for (int i = 0; i < objectsToStore.Length; i++)
{
objectsToStore[i] = new KeyValuePair<string, ComplexParameter>(Guid.NewGuid().ToString(), objectToStore);
}
using (var storage = new RedisStorage(RedisStorageTests.Host))
{
storage.BulkStore(objectsToStore);
var retrievedObjects = storage.BulkRetrieve<ComplexParameter>(objectsToStore.Select(o => o.Key).ToArray());
foreach (var retrievedObject in retrievedObjects)
{
retrievedObject.SomeProperty.ShouldBe(objectToStore.SomeProperty);
retrievedObject.AnotherProperty.ShouldBe(objectToStore.AnotherProperty);
}
}
}
public void CallOneWayWithParameters(int a, bool b, string s, double d, ComplexParameter p, int[] iArr, bool[] bArr, string[] sArr, double[] dArr, ComplexParameter[] pArr)
{
OneWayWithParameterCalled = true;
Parameters = new object[] { a, b, s, d, p, iArr, bArr, sArr, dArr, pArr };
_autoResetEvent.Set();
}
public static Task VoidWithOneParameterAsync(ComplexParameter parameter1)
{
Invocations[nameof(VoidWithOneParameterAsync)] = new object[] { parameter1 };
return(Task.CompletedTask);
}
public void SendRegularEvent(ComplexParameter complexParameter)
{
RegularEvent?.Invoke(this, complexParameter);
}
public void SendEventWithParameters(int a, bool b, string s, double d, ComplexParameter p, int[] iArr, bool[] bArr, string[] sArr, double[] dArr, ComplexParameter[] pArr)
{
EventWithParameters?.Invoke(a, b, s, d, p, iArr, bArr, sArr, dArr, pArr);
}
public static Task <object[]> EchoTwoParametersAsync(
ComplexParameter parameter1,
byte parameter2)
{
return(Task.FromResult(new object[] { parameter1, parameter2 }));
}
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);
}
}
public static void VoidWithTwoParameters(
ComplexParameter parameter1,
byte parameter2)
{
Invocations[nameof(VoidWithTwoParameters)] = new object[] { parameter1, parameter2 };
}
public void CallTwoWayWithParameters(int a, bool b, string s, double d, ComplexParameter p, int[] iArr,
bool[] bArr, string[] sArr, double[] dArr, ComplexParameter[] pArr)
{
TwoWayWithParameterCalled = true;
Parameters = new object[] { a, b, s, d, p, iArr, bArr, sArr, dArr, pArr };
}
