private static void TestSerializeCore( int id, object returnValue, bool isVoid, RpcException error )
{
if ( isVoid )
{
Assert.IsNull( returnValue, "Return value should not be specified in void." );
}
if ( error != null )
{
Assert.IsNull( returnValue, "Return value shoud not be specified in error." );
Assert.IsFalse( isVoid, "isVoid should be false in error test." );
}
// TODO: Mock filters
var objectTracingFilter = new SerializingResponseTracingFilterProvider();
var binaryTracingFilter = new SerializedResponseTracingFilterProvider();
var target =
SerializerFactory.CreateResponseMessageSerializerWithTracer(
objectTracingFilter,
binaryTracingFilter,
null,
null
);
try
{
var buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
Assert.IsTrue( target.Serialize( id, returnValue, isVoid, error, buffer ).IsSuccess );
byte[] serialized = buffer.ReadBytes().ToArray();
var mpo =
new MessagePackObject(
new MessagePackObject[]
{
new MessagePackObject( ( int )MessageType.Response ),
new MessagePackObject( ( uint )id ),
error == null ? MessagePackObject.Nil : error.RpcError.Identifier,
returnValue == null
? ( error == null ? MessagePackObject.Nil : error.GetExceptionMessage( false ) )
: MessagePackObject.FromObject( returnValue )
}
);
var stream = new MemoryStream();
Packer.Create( stream ).Pack( mpo );
CollectionAssert.AreEqual(
stream.ToArray(),
serialized,
"Expected:{0}{1}{0}Actual:{0}{2}",
Environment.NewLine,
mpo,
new Unpacker( serialized ).UnpackObject()
);
}
finally
{
Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
}
}
public void TestReadWrite()
{
using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
{
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
stream.Write( Enumerable.Range( 11, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 21, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
using ( var stream = target.OpenWriteStream() ) { }
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 31, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
using ( var stream = target.OpenWriteStream() )
{
stream.Write( new byte[ 0 ], 0, 0 );
}
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 41, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
CollectionAssert.AreEqual(
Enumerable.Range( 1, 50 ).Select( i => ( byte )i ).ToArray(),
target.ReadBytes()
);
}
}
protected override sealed void SendCore( RpcServerSession session, MessageType messageType, int messageId, object returnValue, bool isVoid, Exception exception )
{
RpcException rpcException = exception as RpcException;
if ( rpcException == null && exception != null )
{
rpcException = new RpcException( RpcError.CallError, "Remote method throws exception.", exception.ToString() );
}
// FIXME: Buffer strategy
RpcOutputBuffer buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
var error = this._responseSerializer.Serialize( messageId, returnValue, isVoid, rpcException, buffer );
if ( !error.IsSuccess )
{
this._eventLoop.HandleError( new RpcTransportErrorEventArgs( RpcTransportOperation.Deserialize, messageId, error ) );
return;
}
this._eventLoop.SendAsync( session.Context, buffer.ReadBytes() );
}
public void TestSwap()
{
using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
{
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
using ( var swapper = target.CreateSwapper() )
{
CollectionAssert.AreEqual(
Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(),
swapper.ReadBytes()
);
swapper.WriteBytes( Enumerable.Range( 11, 30 ).Select( i => ( byte )i ) );
}
CollectionAssert.AreEqual(
Enumerable.Range( 11, 30 ).Select( i => ( byte )i ).ToArray(),
target.ReadBytes().ToArray()
);
}
}
public void TestSwap_WriteBytesEmpty()
{
using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
{
using ( var stream = target.OpenWriteStream() )
{
stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
}
using ( var swapper = target.CreateSwapper() )
{
swapper.WriteBytes( Enumerable.Empty<byte>() );
}
Assert.AreEqual( 0, target.ReadBytes().Count() );
}
}
public void TestSerialize_Request()
{
// TODO: Mock filters
var objectTracingFilter = new SerializingRequestTracingFilterProvider();
var binaryTracingFilter = new SerializedRequestTracingFilterProvider();
var target =
SerializerFactory.CreateRequestMessageSerializerWithTracer(
objectTracingFilter,
binaryTracingFilter,
null,
null
);
try
{
var id = Environment.TickCount;
var method = Guid.NewGuid().ToString();
var args = new object[] { 1, "String", null, true };
var buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
Assert.IsTrue( target.Serialize( id, method, args, buffer ).IsSuccess );
byte[] serialized = buffer.ReadBytes().ToArray();
var mpo =
new MessagePackObject(
new MessagePackObject[]
{
new MessagePackObject( ( int )MessageType.Request ),
new MessagePackObject( ( uint )id ),
new MessagePackObject( method ),
new MessagePackObject[]
{
new MessagePackObject( 1 ),
new MessagePackObject( "String" ),
MessagePackObject.Nil,
new MessagePackObject( true )
}
}
);
var stream = new MemoryStream();
Packer.Create( stream ).Pack( mpo );
CollectionAssert.AreEqual( stream.ToArray(), serialized );
}
finally
{
Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
}
}
