private void TestEnumForByUnderlyingValue <T>(SerializationContext context, T value, string property)
{
var serializer = context.GetSerializer <T>();
using (var stream = new MemoryStream())
{
serializer.Pack(stream, value);
stream.Position = 0;
var deserialized = serializer.Unpack(stream);
if (property == null)
{
Assert.That(deserialized, Is.EqualTo(value));
stream.Position = 0;
var result = Unpacking.UnpackObject(stream);
Assert.That(
result.ToString().Equals((( IFormattable )value).ToString("D", null)),
result + " == " + (( IFormattable )value).ToString("D", null)
);
}
else
{
var propertyInfo = typeof(T).GetProperty(property);
Assert.That(propertyInfo.GetValue(deserialized, null), Is.EqualTo(propertyInfo.GetValue(value, null)));
stream.Position = 0;
var result = Unpacking.UnpackArray(stream);
// Properties are sorted by lexical order
var index = Array.IndexOf(typeof(T).GetProperties().OrderBy(p => p.Name).ToArray(), propertyInfo);
Assert.That(
result[index].ToString().Equals((( IFormattable )propertyInfo.GetValue(value, null)).ToString("D", null)),
result[index] + " == " + (( IFormattable )propertyInfo.GetValue(value, null)).ToString("D", null)
);
}
}
}
private static void TestEnumForByUnderlyingValueCore <T>(Stream stream, T value, T deserialized, string property)
{
if (property == null)
{
Assert.That(deserialized, Is.EqualTo(value));
stream.Position = 0;
var result = Unpacking.UnpackObject(stream);
Assert.That(
result.ToString().Equals((( IFormattable )value).ToString("D", null)),
result + " == " + (( IFormattable )value).ToString("D", null)
);
}
else
{
var propertyInfo = typeof(T).GetProperty(property);
#if !UNITY
Assert.That(propertyInfo.GetValue(deserialized, null), Is.EqualTo(propertyInfo.GetValue(value, null)));
#else
Assert.That(propertyInfo.GetGetMethod().Invoke(deserialized, null), Is.EqualTo(propertyInfo.GetGetMethod().Invoke(value, null)));
#endif // !UNITY
stream.Position = 0;
var result = Unpacking.UnpackArray(stream);
// Properties are sorted by lexical order
var index = Array.IndexOf(typeof(T).GetProperties().OrderBy(p => p.Name).ToArray(), propertyInfo);
Assert.That(
#if !UNITY
result[index].ToString().Equals((( IFormattable )propertyInfo.GetValue(value, null)).ToString("D", null)),
result[index] + " == " + (( IFormattable )propertyInfo.GetValue(value, null)).ToString("D", null)
#else
result[index].ToString().Equals((( IFormattable )propertyInfo.GetGetMethod().Invoke(value, null)).ToString("D", null)),
result[index] + " == " + (( IFormattable )propertyInfo.GetGetMethod().Invoke(value, null)).ToString("D", null)
#endif // !UNITY
);
}
}
private static void TestSendReceiveRequestCore(IPEndPoint endPoint, int count, CountdownEvent latch)
{
using (var udpClient = new UdpClient(AddressFamily.InterNetwork))
{
udpClient.Connect(endPoint);
for (int i = 0; i < count; i++)
{
if (latch != null)
{
latch.Reset();
}
var ids = Enumerable.Repeat(0, latch == null ? 1 : latch.InitialCount).Select(_ => Guid.NewGuid().ToString()).ToArray();
if (!Task.WaitAll(
ids.Select(
id =>
Task.Factory.StartNew(
_ =>
{
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id);
}
buffer.Position = 0;
if (latch != null)
{
latch.Signal();
if (!latch.Wait(Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds))
{
throw new TimeoutException();
}
}
// send
udpClient.Send(buffer.ToArray(), ( int )buffer.Length);
}
},
id
)
).ToArray(),
Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds
))
{
throw new TimeoutException();
}
// receive
IPEndPoint received = endPoint;
var result = Unpacking.UnpackArray(udpClient.Receive(ref endPoint)).Value;
AssertResponse(result, ids);
}
}
}
private void TestEchoRequestContinuousCore(bool[] serverStatus, CountdownEvent waitHandle, int count, string message)
{
using (var client = new TcpClient())
{
client.Connect(new IPEndPoint(IPAddress.Loopback, CallbackServer.PortNumber));
var now = MessagePackConvert.FromDateTime(DateTime.Now);
bool[] resposeStatus = new bool[count];
using (var stream = client.GetStream())
using (var packer = Packer.Create(stream))
{
for (int i = 0; i < count; i++)
{
this._trace.TraceInformation("---- Client sending request ----");
packer.PackArrayHeader(4);
packer.Pack(0);
packer.Pack(i);
packer.Pack("Echo");
packer.PackArrayHeader(2);
packer.Pack(message);
packer.Pack(now);
this._trace.TraceInformation("---- Client sent request ----");
}
if (Debugger.IsAttached)
{
waitHandle.Wait();
}
else
{
Assert.That(waitHandle.Wait(TimeSpan.FromSeconds(count * 3)));
}
for (int i = 0; i < count; i++)
{
this._trace.TraceInformation("---- Client receiving response ----");
var array = Unpacking.UnpackArray(stream);
Assert.That(array.Count, Is.EqualTo(4));
Assert.That(array[0] == 1, array[0].ToString());
Assert.That(array[1].IsTypeOf <int>().GetValueOrDefault());
resposeStatus[array[1].AsInt32()] = true;
Assert.That(array[2] == MessagePackObject.Nil, array[2].ToString());
Assert.That(array[3].IsArray, array[3].ToString());
var returnValue = array[3].AsList();
Assert.That(returnValue.Count, Is.EqualTo(2));
Assert.That(returnValue[0] == message, returnValue[0].ToString());
Assert.That(returnValue[1] == now, returnValue[1].ToString());
this._trace.TraceInformation("---- Client received response ----");
}
lock ( serverStatus )
{
Assert.That(serverStatus, Is.All.True, String.Join(", ", serverStatus));
}
Assert.That(resposeStatus, Is.All.True);
}
}
}
public void TestClientShutdown_NotAffectOthers()
{
TestSendReceiveRequest(
endPoint =>
{
using (var activeTcpClient = new TcpClient(AddressFamily.InterNetwork))
using (var inactiveTcpClient = new TcpClient(AddressFamily.InterNetwork))
{
activeTcpClient.Connect(endPoint);
inactiveTcpClient.Connect(endPoint);
using (var stream = activeTcpClient.GetStream())
{
var id1 = Guid.NewGuid().ToString();
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id1);
}
buffer.Position = 0;
// send
buffer.CopyTo(stream);
}
// receive
var result1 = Unpacking.UnpackArray(stream);
AssertResponse(result1, id1);
inactiveTcpClient.Client.Shutdown(SocketShutdown.Send);
var id2 = Guid.NewGuid().ToString();
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id2);
}
buffer.Position = 0;
// send
buffer.CopyTo(stream);
}
// receive
var result2 = Unpacking.UnpackArray(stream);
AssertResponse(result2, id2);
}
}
}
);
}
public void TestClientShutdown_NotAffectOthers()
{
TestSendReceiveRequest(
endPoint =>
{
using (var activeUdpClient = new UdpClient(AddressFamily.InterNetwork))
using (var inactiveUdpClient = new UdpClient(AddressFamily.InterNetwork))
{
activeUdpClient.Connect(endPoint);
inactiveUdpClient.Connect(endPoint);
var id1 = Guid.NewGuid().ToString();
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id1);
}
buffer.Position = 0;
// send
activeUdpClient.Send(buffer.ToArray(), ( int )buffer.Length);
}
// receive
IPEndPoint received1 = endPoint;
var result1 = Unpacking.UnpackArray(activeUdpClient.Receive(ref received1)).Value;
AssertResponse(result1, id1);
inactiveUdpClient.Client.Shutdown(SocketShutdown.Send);
var id2 = Guid.NewGuid().ToString();
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id2);
}
buffer.Position = 0;
// send
activeUdpClient.Send(buffer.ToArray(), ( int )buffer.Length);
}
// receive
IPEndPoint received = endPoint;
var result2 = Unpacking.UnpackArray(activeUdpClient.Receive(ref received)).Value;
AssertResponse(result2, id2);
}
}
);
}
public void TestIsGreatorThanQuota_MessagetooLongError()
{
long quota = 16;
ServerTransportTest.TestFiltersCore(
(argumentPacker, currentLength) =>
{
var remaining = quota - currentLength - 2; // header(FixArray) + header(FixRaw) = 2 byte
argumentPacker.PackArrayHeader(1);
argumentPacker.PackRaw(new byte[remaining + 1]);
},
null,
(request, response) =>
{
// Error occurred.
var responseMessage = Unpacking.UnpackArray(response).Value;
Assert.That(responseMessage[2] == RpcError.MessageTooLargeError.Identifier, "{0}:{1}", responseMessage[2], responseMessage[3]);
},
new ServerQuotaMessageFilterProvider(quota)
);
}
public void TestIsEqualToQuota_Ok()
{
long quota = 16;
ServerTransportTest.TestFiltersCore(
(argumentPacker, currentLength) =>
{
var remaining = quota - currentLength - 2; // header(FixArray) + header(FixRaw) = 2 byte
argumentPacker.PackArrayHeader(1);
argumentPacker.PackRaw(new byte[remaining]);
},
null,
(request, response) =>
{
// No error occurred.
var responseMessage = Unpacking.UnpackArray(response).Value;
Assert.That(responseMessage[2].IsNil, "{0}:{1}", responseMessage[2], responseMessage[3]);
},
new ServerQuotaMessageFilterProvider(quota)
);
}
private void TestEnumForByName <T>(SerializationContext context, T value, string property)
{
var serializer = context.GetSerializer <T>();
using (var stream = new MemoryStream())
{
serializer.Pack(stream, value);
stream.Position = 0;
var deserialized = serializer.Unpack(stream);
if (property == null)
{
Assert.That(deserialized, Is.EqualTo(value));
stream.Position = 0;
Assert.That(Unpacking.UnpackString(stream), Is.EqualTo(value.ToString()));
}
else
{
var propertyInfo = typeof(T).GetProperty(property);
#if !UNITY
Assert.That(propertyInfo.GetValue(deserialized, null), Is.EqualTo(propertyInfo.GetValue(value, null)));
#else
Assert.That(propertyInfo.GetGetMethod().Invoke(deserialized, null), Is.EqualTo(propertyInfo.GetGetMethod().Invoke(value, null)));
#endif // !UNITY
stream.Position = 0;
// Properties are sorted by lexical order
var index = Array.IndexOf(typeof(T).GetProperties().OrderBy(p => p.Name).ToArray(), propertyInfo);
var result = Unpacking.UnpackArray(stream);
Assert.That(
#if !UNITY
result[index].Equals(propertyInfo.GetValue(value, null).ToString()),
result[index] + " == " + propertyInfo.GetValue(value, null)
#else
result[index].Equals(propertyInfo.GetGetMethod().Invoke(value, null).ToString()),
result[index] + " == " + propertyInfo.GetGetMethod().Invoke(value, null)
#endif // !UNITY
);
}
}
}
public void TestServerShutdown_Shutdowned()
{
TestSendReceiveRequest(
(endPoint, manager) =>
{
using (var tcpClient = new TcpClient(AddressFamily.InterNetwork))
{
tcpClient.Connect(endPoint);
using (var stream = tcpClient.GetStream())
{
var id = Guid.NewGuid().ToString();
using (var buffer = new MemoryStream())
{
using (var packer = Packer.Create(buffer, false))
{
PackRequest(packer, id);
}
buffer.Position = 0;
// send
buffer.CopyTo(stream);
}
// receive
var result = Unpacking.UnpackArray(stream);
AssertResponse(result, id);
manager.BeginShutdown();
byte[] bytes = new byte[1];
int received = stream.Read(bytes, 0, bytes.Length);
Assert.That(received, Is.EqualTo(0));
}
}
}
);
}
private static void TestSendReceiveRequestCore(IPEndPoint endPoint, int count, int concurrency)
{
_SetUpFixture.EnsureThreadPoolCapacity();
using (var clientTransportManager = new TcpClientTransportManager(new RpcClientConfiguration()))
{
var connectTask = clientTransportManager.ConnectAsync(endPoint);
if (!connectTask.Wait(Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds))
{
throw new TimeoutException();
}
using (var clientTransport = connectTask.Result)
{
for (int i = 0; i < count; i++)
{
using (var latch = new CountdownEvent(concurrency))
{
var ids = Enumerable.Range(i * concurrency, concurrency).ToArray();
var args = Enumerable.Repeat(0, concurrency).Select(_ => Guid.NewGuid().ToString()).ToArray();
var idAndArgs = ids.Zip(args, (id, arg) => new { MessageId = id, Guid = arg.ToString() });
var requestTable = new ConcurrentDictionary <int, string>();
var responseTable = new ConcurrentDictionary <int, string>();
var exceptions = new ConcurrentBag <Exception>();
if (!Task.Factory.ContinueWhenAll(
idAndArgs.Select(
idAndArg =>
Task.Factory.StartNew(
() =>
{
var requestContext = clientTransport.GetClientRequestContext();
requestTable[idAndArg.MessageId] = idAndArg.Guid;
requestContext.SetRequest(
idAndArg.MessageId,
"Dummy",
(responseContext, exception, completedSynchronously) =>
{
try
{
if (exception != null)
{
exceptions.Add(exception);
}
else
{
// Server returns args as array, so store only first element.
responseTable[responseContext.MessageId.Value] = Unpacking.UnpackArray(responseContext.ResultBuffer)[0].AsString();
}
}
finally
{
latch.Signal();
}
}
);
requestContext.ArgumentsPacker.PackArrayHeader(1);
requestContext.ArgumentsPacker.Pack(idAndArg.Guid);
return(requestContext);
}
)
).ToArray(),
previouses =>
{
var contexts = previouses.Select(previous => previous.Result).ToArray();
foreach (var context in contexts)
{
clientTransport.Send(context);
}
}
).ContinueWith(
previous =>
{
if (previous.IsFaulted)
{
throw previous.Exception;
}
// receive
if (!latch.Wait(Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds))
{
throw new TimeoutException("Receive");
}
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
Assert.That(requestTable.Count, Is.EqualTo(concurrency));
Assert.That(requestTable, Is.EquivalentTo(responseTable));
}
).Wait(Debugger.IsAttached ? Timeout.Infinite : TimeoutMilliseconds))
{
throw new TimeoutException();
}
}
}
}
}
}