예제 #1
0
        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()
                );
            }
        }
예제 #2
0
        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()
                );
            }
        }
예제 #3
0
        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() );
            }
        }
예제 #4
0
        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 );
                }
            }
        }
        private static void SerializeCore( RpcOutputBuffer buffer, int? messageId, RequestMessageSerializationContext context )
        {
            using ( var stream = buffer.OpenWriteStream() )
            using ( var packer = Packer.Create( stream ) )
            {
                packer.PackArrayHeader( messageId == null ? 3 : 4 );
                packer.Pack( ( int )( messageId == null ? MessageType.Notification : MessageType.Request ) );

                if ( messageId != null )
                {
                    packer.Pack( unchecked( ( uint )messageId.Value ) );
                }

                packer.PackString( context.MethodName );
                packer.PackItems( context.Arguments );
            }
        }