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_WriteBytesNull() { 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( null ); } } }
/// <summary> /// Serialize RPC call to specified buffer. /// </summary> /// <param name="messageId">ID of message. If message is notification message, specify null.</param> /// <param name="method">Method name to be called.</param> /// <param name="arguments">Arguments of method call.</param> /// <param name="buffer">Buffer to be set serialized stream.</param> /// <returns>Error message of serialization.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="method"/>, <paramref name="arguments"/>, or <paramref name="buffer"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="method"/> is illegal. /// </exception> public RpcErrorMessage Serialize( int? messageId, string method, IList<object> arguments, RpcOutputBuffer buffer ) { if ( method == null ) { throw new ArgumentNullException( "method" ); } // TODO: more strict validation. if ( String.IsNullOrWhiteSpace( method ) ) { throw new ArgumentException( "'method' must not be empty nor blank.", "method" ); } if ( arguments == null ) { throw new ArgumentNullException( "arguments" ); } if ( buffer == null ) { throw new ArgumentNullException( "buffer" ); } Contract.EndContractBlock(); var context = new RequestMessageSerializationContext( buffer, messageId, method, arguments ); foreach ( var preSerializationFilter in this._preSerializationFilters ) { preSerializationFilter.GetFilter().Process( context ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } } SerializeCore( buffer, messageId, context ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } foreach ( var postSerializationFilter in this._postSerializationFilters ) { using ( var swapper = buffer.CreateSwapper() ) { swapper.WriteBytes( postSerializationFilter.GetFilter().Process( swapper.ReadBytes(), context ) ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } } } return RpcErrorMessage.Success; }
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() ); } }
/// <summary> /// Serialize response message to specified buffer. /// </summary> /// <param name="messageId">ID of message.</param> /// <param name="returnValue">Return value of the method.</param> /// <param name="isVoid">If the method is void, then true.</param> /// <param name="exception">Exception thrown from the method.</param> /// <param name="buffer">Buffer to be stored serialized response stream.</param> /// <returns>Error information.</returns> public RpcErrorMessage Serialize( int messageId, object returnValue, bool isVoid, RpcException exception, RpcOutputBuffer buffer ) { var context = exception != null ? new ResponseMessageSerializationContext( buffer, messageId, exception, isVoid ) : ( isVoid ? new ResponseMessageSerializationContext( buffer, messageId ) : new ResponseMessageSerializationContext( buffer, messageId, returnValue ) ); foreach ( var preSerializationFilter in this._preSerializationFilters ) { preSerializationFilter.GetFilter().Process( context ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } } SerializeCore( MessageType.Response, messageId, context ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } foreach ( var postSerializationFilter in this._postSerializationFilters ) { using ( var swapper = buffer.CreateSwapper() ) { swapper.WriteBytes( postSerializationFilter.GetFilter().Process( swapper.ReadBytes(), context ) ); if ( !context.SerializationError.IsSuccess ) { return context.SerializationError; } } } return RpcErrorMessage.Success; }