public void TestEnumerateSingleChunkWithFeeding()
{
bool feeded = false;
using ( var buffer = ChunkBuffer.CreateDefault() )
{
buffer.Feed( Enumerable.Range( 1, 2 ).Select( item => ( byte )item ).ToArray() );
using ( var target =
new RpcInputBuffer<object, object>(
buffer,
( _0, _1, _2 ) => ChunkBuffer.CreateDefault(),
( _0, _1, _2 ) =>
{
if ( feeded )
{
return default( BufferFeeding );
}
feeded = true;
buffer.Feed( Enumerable.Range( 3, 4 ).Select( item => ( byte )item ).ToArray() );
return new BufferFeeding( 4 );
},
null
) )
{
CollectionAssert.AreEqual( Enumerable.Range( 1, 6 ).ToArray(), target.ToArray() );
}
}
}
public void TestEnumerateMultipleChunk()
{
using ( var buffer = ChunkBuffer.CreateDefault() )
{
var expected = Enumerable.Range( 1, 6 ).Select( item => ( byte )item ).ToArray();
buffer.Feed( expected.ToArray() );
using ( var target = new RpcInputBuffer<object, object>( buffer, ( _0, _1, _2 ) => ChunkBuffer.CreateDefault(), ( _0, _1, _2 ) => default( BufferFeeding ), null ) )
{
CollectionAssert.AreEqual( expected, target.ToArray() );
}
}
}
public RequestMessage GetRequest()
{
if ( this._socketException != null )
{
throw this._socketException;
}
if ( this._request != null )
{
return this._request.Value;
}
if ( this._deserializationError != null )
{
throw this._deserializationError;
}
using ( var buffer = GCChunkBuffer.CreateDefault() )
{
buffer.Feed( new ArraySegment<byte>( this._context.Buffer, this._context.Offset, this._context.BytesTransferred ) );
using ( var rpcBuffer = new RpcInputBuffer<object,object>( buffer, ( old, _1, _2 ) => old, ( _0, _1, _2 ) => new BufferFeeding( 0 ), null ) )
{
return SerializationUtility.DeserializeRequestOrNotification( rpcBuffer );
}
}
}
public void TestDeserialize_Notification_Devided()
{
// TODO: Mock filters
var objectTracingFilter = new DeserializedRequestTracingFilterProvider();
var binaryTracingFilter = new DeserializingRequestTracingFilterProvider();
var target =
SerializerFactory.CreateRequestMessageSerializerWithTracer(
null,
null,
binaryTracingFilter,
objectTracingFilter
);
try
{
var method = Guid.NewGuid().ToString();
var args = new object[] { 1, "String", null, true };
var expected =
new MessagePackObject(
new MessagePackObject[]
{
new MessagePackObject( ( int )MessageType.Notification ),
new MessagePackObject( method ),
new MessagePackObject[]
{
new MessagePackObject( 1 ),
new MessagePackObject( "String" ),
MessagePackObject.Nil,
new MessagePackObject( true )
}
}
);
var stream = new MemoryStream();
Packer.Create( stream ).Pack( expected );
var serialized = stream.ToArray();
var packets = Segmentate( serialized, 10 ).ToArray();
int indexOfPackets = 0;
using ( var underlying = ChunkBuffer.CreateDefault() )
{
underlying.Feed( new ArraySegment<byte>( packets[ 0 ] ) );
using ( var buffer =
new RpcInputBuffer<object, object>(
underlying,
( _0, _1, _2 ) => ChunkBuffer.CreateDefault(),
( item, _0, _1 ) =>
{
indexOfPackets++;
if ( indexOfPackets >= packets.Length )
{
Assert.Fail( "Over requesting." );
};
item.Reset();
item.Feed( new ArraySegment<byte>( packets[ indexOfPackets ] ) );
return new BufferFeeding( packets[ indexOfPackets ].Length );
},
null
) )
{
RequestMessage actual;
var result = target.Deserialize( buffer, out actual );
Assert.IsTrue( result.IsSuccess, result.ToString() );
Assert.AreEqual( MessageType.Notification, actual.MessageType );
Assert.AreEqual( method, actual.Method );
Assert.AreEqual( 1, actual.Arguments[ 0 ].AsInt32() );
Assert.AreEqual( "String", actual.Arguments[ 1 ].AsString() );
Assert.IsTrue( actual.Arguments[ 2 ].IsNil );
Assert.IsTrue( actual.Arguments[ 3 ].AsBoolean() );
}
}
}
finally
{
Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
}
}
public void TestDeserialize_Request_Normal()
{
// TODO: Mock filters
var objectTracingFilter = new DeserializedRequestTracingFilterProvider();
var binaryTracingFilter = new DeserializingRequestTracingFilterProvider();
var target =
SerializerFactory.CreateRequestMessageSerializerWithTracer(
null,
null,
binaryTracingFilter,
objectTracingFilter
);
try
{
var id = Environment.TickCount;
var method = Guid.NewGuid().ToString();
var args = new object[] { 1, "String", null, true };
var expected =
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( expected );
var serialized = stream.ToArray();
using ( var underlying = ChunkBuffer.CreateDefault() )
{
underlying.Feed( new ArraySegment<byte>( serialized ) );
using ( var buffer = new RpcInputBuffer<object, object>( underlying, ReallocationNotRequired, FeedingNotRequired, null ) )
{
RequestMessage actual;
var result = target.Deserialize( buffer, out actual );
Assert.IsTrue( result.IsSuccess, result.ToString() );
Assert.AreEqual( MessageType.Request, actual.MessageType );
Assert.AreEqual( id, actual.MessageId );
Assert.AreEqual( method, actual.Method );
Assert.AreEqual( 1, actual.Arguments[ 0 ].AsInt32() );
Assert.AreEqual( "String", actual.Arguments[ 1 ].AsString() );
Assert.IsTrue( actual.Arguments[ 2 ].IsNil );
Assert.IsTrue( actual.Arguments[ 3 ].AsBoolean() );
}
}
}
finally
{
Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
}
}
private static void TestDeserializeDeviedCore( 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 DeserializedResponseTracingFilterProvider();
var binaryTracingFilter = new DeserializingResponseTracingFilterProvider();
var target =
SerializerFactory.CreateResponseMessageSerializerWithTracer(
null,
null,
binaryTracingFilter,
objectTracingFilter
);
try
{
var expected =
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( expected );
var serialized = stream.ToArray();
var packets = Segmentate( serialized, 10 ).ToArray();
int indexOfPackets = 0;
using ( var underlying = ChunkBuffer.CreateDefault() )
{
underlying.Feed( new ArraySegment<byte>( packets[ 0 ] ) );
using ( var buffer =
new RpcInputBuffer<object, object>(
underlying,
( _0, _1, _2 ) => ChunkBuffer.CreateDefault(),
( item, _0, _1 ) =>
{
indexOfPackets++;
if ( indexOfPackets >= packets.Length )
{
return default( BufferFeeding );
//Assert.Fail( "Over requesting." );
}
item.Reset();
item.Feed( new ArraySegment<byte>( packets[ indexOfPackets ] ) );
return new BufferFeeding( packets[ indexOfPackets ].Length );
},
null
) )
{
ResponseMessage actual;
var result = target.Deserialize( buffer, out actual );
Assert.IsTrue( result.IsSuccess, result.ToString() );
Assert.AreEqual( id, actual.MessageId );
if ( isVoid || returnValue == null )
{
Assert.IsTrue( actual.ReturnValue.IsNil );
}
else
{
Assert.AreEqual( returnValue.ToString(), actual.ReturnValue.AsString() );
}
if ( error == null )
{
Assert.IsNull( actual.Error );
}
else
{
Assert.AreEqual( expected.AsList()[ 2 ].AsString(), actual.Error.RpcError.Identifier );
Assert.AreEqual( expected.AsList()[ 3 ].AsDictionary()[ MessagePackConvert.EncodeString( "ErrorCode" ) ].AsInt32(), actual.Error.RpcError.ErrorCode );
Assert.AreEqual( expected.AsList()[ 3 ].AsDictionary()[ MessagePackConvert.EncodeString( "Message" ) ].AsString(), actual.Error.Message );
if ( expected.AsList()[ 3 ].AsDictionary().ContainsKey( MessagePackConvert.EncodeString( "DebugInformation" ) ) )
{
Assert.AreEqual( expected.AsList()[ 3 ].AsDictionary()[ MessagePackConvert.EncodeString( "DebugInformation" ) ].AsString(), actual.Error.DebugInformation );
}
else
{
Assert.IsNull( actual.Error.DebugInformation );
}
}
}
}
}
finally
{
Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
}
}
