public void TestBytes_Splitted()
{
foreach (
var count in
new[]
{
0, // empty
1, // only one
2, // minimum multiple
0xFF, // max bin8 size
0x100, // min bin16 size
0xffff, // max bin16 size
0x10000, // min bin32 size
}
)
{
using (var output = new MemoryStream())
{
Packer.Create(output).PackBinary(Enumerable.Range(0, count).Select(i => ( byte )(i % Byte.MaxValue)).ToArray());
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
Assert.That(
Enumerable.Range(0, count).Select(i => ( byte )(i % Byte.MaxValue)).ToArray(),
Is.EqualTo(Unpacking.UnpackObject(splitted).AsBinary())
);
}
}
}
}
public void TestDictionary_Splitted()
{
foreach (
var count in
new[]
{
0, // empty
1, // only one
2, // minimum multiple
0xf, // max fix map size
0x10, // min map16 size
#if !AOT // Too heavy for mobile envs.
0xffff, // max map16 size
0x10000, // min map32 size
#endif // !AOT
}
)
{
using (var output = new MemoryStream())
{
Packer.Create(output).PackDictionary(Enumerable.Range(0, count).ToDictionary(item => item.ToString(), item => item));
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
Assert.That(
Enumerable.Range(0, count).ToDictionary(item => item.ToString(), item => item),
Is.EqualTo(Unpacking.UnpackObject(splitted).AsDictionary().ToDictionary(kv => kv.Key.AsString(), kv => kv.Value.AsInt32()))
);
}
}
}
}
public void TestChars_Splitted()
{
foreach (
var count in
new[]
{
0, // empty
1, // only one
2, // minimum multiple
0x1f, // max fix raw size
0x20, // min str8 size
0xFF, // max str8 size
0x100, // min str16 size
0xffff, // max str16 size
0x10000, // min str32 size
}
)
{
using (var output = new MemoryStream())
{
Packer.Create(output).PackString(String.Concat(Enumerable.Range(0, count).Select(i => (i % 10).ToString()).ToArray()));
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
Assert.AreEqual(
String.Concat(Enumerable.Range(0, count).Select(i => (i % 10).ToString()).ToArray()),
Unpacking.UnpackObject(splitted).AsString()
);
}
}
}
}
public void TestUnpackFixStr_0_AsString_Read_JustLength_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xA0 }
.Concat( Enumerable.Repeat( ( byte )'A', 0 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( ( String )result.Value, Is.EqualTo( new String( 'A', 0 ) ) );
Assert.That( result.Value.UnderlyingType, Is.EqualTo( typeof( String ) ) );
// raw/str always can be byte[]
var asBinary = ( byte[] )result.Value;
var asString = ( String )result.Value;
Assert.That( result.Value.IsTypeOf( typeof( string ) ).GetValueOrDefault() );
Assert.That( result.Value.IsTypeOf( typeof( byte[] ) ).GetValueOrDefault() );
}
}
public void TestArray_Splitted()
{
foreach (
var count in
new[]
{
0, // empty
1, // only one
2, // minimum multiple
0xf, // max fix array size
0x10, // min array16 size
#if !AOT // Too heavy for mobile envs.
0xffff, // max array16 size
0x10000, // min array32 size
#endif // !AOT
}
)
{
using (var output = new MemoryStream())
{
Packer.Create(output).PackCollection(Enumerable.Range(0, count).ToArray());
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
Assert.That(
Enumerable.Range(0, count).ToArray(),
Is.EqualTo(Unpacking.UnpackObject(splitted).AsEnumerable().Select(item => item.AsInt32()).ToArray())
);
}
}
}
}
public void TestRead_Int64MinValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xD3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( ( System.Int64 )result.Value, Is.EqualTo( -9223372036854775808 ) );
}
}
public void TestByte_Splitted()
{
var value = Byte.MaxValue;
using( var output = new MemoryStream() )
{
Packer.Create( output ).Pack( value );
output.Position = 0;
using( var splitted = new SplittingStream( output ) )
{
var mpo = Unpacking.UnpackObject( splitted );
Assert.AreEqual( value, ( Byte )mpo );
Assert.AreEqual( value, mpo.AsByte() );
}
}
}
public void TestByte_Splitted()
{
var value = Byte.MaxValue;
using (var output = new MemoryStream())
{
Packer.Create(output).Pack(value);
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
var mpo = Unpacking.UnpackObject(splitted);
Assert.AreEqual(value, ( Byte )mpo);
Assert.AreEqual(value, mpo.AsByte());
}
}
}
public void TestRead_FixExt1_AndBinaryLengthIs1JustLength_Success_Splitted()
{
var typeCode = ( byte )( Math.Abs( Environment.TickCount ) % 128 );
using( var buffer =
new MemoryStream(
new byte[] { 0xD4, typeCode }
.Concat( Enumerable.Repeat( ( byte )0xFF, 1 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
var actual = ( MessagePackExtendedTypeObject )result;
Assert.That( actual.TypeCode, Is.EqualTo( typeCode ) );
Assert.That( actual.Body, Is.Not.Null );
Assert.That( actual.Body.Length, Is.EqualTo( 1 ) );
}
}
public void TestExts_Splitted()
{
foreach (
var count in
new[]
{
0, // empty
1, // fixext1
2, // fixext2
4, // fixext4
8, // fixext8
16, // fixext16
17, // min ext8 size
0xff, // max ext8 size
0x100, // min ext16 size
0xffff, // max ext16 size
0x10000, // min ext32 size
}
)
{
using (var output = new MemoryStream())
{
var value = new MessagePackExtendedTypeObject(
1, Enumerable.Range(0, count).Select(i => ( byte )(i % 0x100)).ToArray());
Packer.Create(output, PackerCompatibilityOptions.None).PackExtendedTypeValue(value);
output.Position = 0;
using (var splitted = new SplittingStream(output))
{
Assert.AreEqual(
value,
Unpacking.UnpackObject(splitted).AsMessagePackExtendedTypeObject()
);
}
}
}
}
public void TestReadNullableInt64_NegativeFixNumMinValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xE0 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Int64? result;
Assert.IsTrue( unpacker.ReadNullableInt64( out result ) );
Assert.That( result.Value, Is.EqualTo( -32 ) );
}
}
public void TestUnpackBin32_65536_ReadString_TooShort_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC6, 0, 1, 0, 0 }
.Concat( Enumerable.Repeat( ( byte )'A', 65535 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
String result;
Assert.Throws<InvalidMessagePackStreamException>( () => unpacker.ReadString( out result ) );
}
}
public void TestUnpackStr8_1_AsString_Read_TooShort_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xD9, 1 }
.Concat( Enumerable.Repeat( ( byte )'A', 0 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.Throws<InvalidMessagePackStreamException>( () => unpacker.Read() );
}
}
public async Task TestReadNullableSingleAsync_SingleNaNPositiveMaxValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCA, 0x7F, 0xFF, 0xFF, 0xFF } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Single? result;
var ret = await unpacker.ReadNullableSingleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Single.IsNaN( result.Value ) );
}
}
public void TestUnpackBin32_65535_AsBinary_Read_TooShort_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC6, 0, 0, 0xFF, 0xFF }
.Concat( Enumerable.Repeat( ( byte )0xFF, 65534 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.Throws<InvalidMessagePackStreamException>( () => unpacker.Read() );
}
}
public void TestUnpackBin16_256_ReadBinary_TooShort_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC5, 1, 0 }
.Concat( Enumerable.Repeat( ( byte )0xFF, 255 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Byte[] result;
Assert.Throws<InvalidMessagePackStreamException>( () => unpacker.ReadBinary( out result ) );
}
}
public void TestRead_PlusOne_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0x1 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( ( System.UInt64 )result.Value, Is.EqualTo( 1 ) );
}
}
public void TestReadNullableUInt64_Zero_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0x0 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
UInt64? result;
Assert.IsTrue( unpacker.ReadNullableUInt64( out result ) );
Assert.That( result.Value, Is.EqualTo( 0 ) );
}
}
public void TestReadInt64_Int64MinValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xD3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Int64 result;
Assert.IsTrue( unpacker.ReadInt64( out result ) );
Assert.That( result, Is.EqualTo( -9223372036854775808 ) );
}
}
public async Task TestReadNullableUInt64Async_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xC0 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
UInt64? result;
var ret = await unpacker.ReadNullableUInt64Async();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( result, Is.Null );
}
}
public async Task TestReadNullableDoubleAsync_DoublePositiveInfinity_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Double? result;
var ret = await unpacker.ReadNullableDoubleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Double.IsPositiveInfinity( result.Value ) );
}
}
public async Task TestReadAsync_DoublePositiveInfinity_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( await unpacker.ReadAsync() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( Double.IsPositiveInfinity( ( System.Double )result.Value ) );
}
}
public async Task TestReadDoubleAsync_DoubleNaNNegativeMaxValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Double result;
var ret = await unpacker.ReadDoubleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Double.IsNaN( result ) );
}
}
public void TestUnpackStr32_0_AsBinary_Read_HasExtra_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xDB, 0, 0, 0, 0 }
.Concat( Enumerable.Repeat( ( byte )0xFF, 1 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
// raw/str always can be byte[]
var asBinary = ( byte[] )result.Value;
var asString = ( String )result.Value;
Assert.That( result.Value.IsTypeOf( typeof( string ) ).GetValueOrDefault() );
Assert.That( result.Value.IsTypeOf( typeof( byte[] ) ).GetValueOrDefault() );
}
}
public void TestUnpackBin16_255_ReadBinary_HasExtra_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC5, 0, 0xFF }
.Concat( Enumerable.Repeat( ( byte )0xFF, 256 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Byte[] result;
Assert.IsTrue( unpacker.ReadBinary( out result ) );
Assert.That( result, Is.EqualTo( Enumerable.Repeat( 0xFF, 255 ).ToArray() ) );
}
}
public void TestReadUInt64_PlusOne_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0x1 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
UInt64 result;
Assert.IsTrue( unpacker.ReadUInt64( out result ) );
Assert.That( result, Is.EqualTo( 1 ) );
}
}
public void TestUnpackBin16_65535_AsBinary_Read_JustLength_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC5, 0xFF, 0xFF }
.Concat( Enumerable.Repeat( ( byte )0xFF, 65535 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( ( Byte[] )result.Value, Is.EqualTo( Enumerable.Repeat( 0xFF, 65535 ).ToArray() ) );
Assert.That( result.Value.UnderlyingType, Is.EqualTo( typeof( Byte[] ) ) );
// raw/str always can be byte[]
var asBinary = ( byte[] )result.Value;
Assert.Throws<InvalidOperationException>( () => { var asString = ( String )result.Value; } );
Assert.That( result.Value.IsTypeOf( typeof( string ) ).GetValueOrDefault(), Is.False );
Assert.That( result.Value.IsTypeOf( typeof( byte[] ) ).GetValueOrDefault() );
}
}
public async Task TestReadDoubleAsync_DoubleEpsilon_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Double result;
var ret = await unpacker.ReadDoubleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Double.Epsilon.Equals( result ) );
}
}
public void TestUnpackBin32_65536_ReadBinary_JustLength_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC6, 0, 1, 0, 0 }
.Concat( Enumerable.Repeat( ( byte )0xFF, 65536 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Byte[] result;
Assert.IsTrue( unpacker.ReadBinary( out result ) );
Assert.That( result, Is.EqualTo( Enumerable.Repeat( 0xFF, 65536 ).ToArray() ) );
}
}
public async Task TestReadNullableDoubleAsync_DoubleMaxValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0x7F, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Double? result;
var ret = await unpacker.ReadNullableDoubleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Double.MaxValue.Equals( result.Value ) );
}
}
public void TestUnpackStr8_0_ReadString_JustLength_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xD9, 0 }
.Concat( Enumerable.Repeat( ( byte )'A', 0 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
String result;
Assert.IsTrue( unpacker.ReadString( out result ) );
Assert.That( result, Is.EqualTo( new String( 'A', 0 ) ) );
}
}
public async Task TestReadSingleAsync_SingleNegativeInfinity_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCA, 0xFF, 0x80, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Single result;
var ret = await unpacker.ReadSingleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( Single.IsNegativeInfinity( result ) );
}
}
public void TestUnpackBin32_65536_AsString_Read_HasExtra_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC6, 0, 1, 0, 0 }
.Concat( Enumerable.Repeat( ( byte )'A', 65537 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( unpacker.Read() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
// raw/str always can be byte[]
var asBinary = ( byte[] )result.Value;
Assert.Throws<InvalidOperationException>( () => { var asString = ( String )result.Value; } );
Assert.That( result.Value.IsTypeOf( typeof( string ) ).GetValueOrDefault(), Is.False );
Assert.That( result.Value.IsTypeOf( typeof( byte[] ) ).GetValueOrDefault() );
}
}
public async Task TestReadAsync_SingleNaNNegativeMaxValue_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCA, 0xFF, 0xFF, 0xFF, 0xFF } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Assert.IsTrue( await unpacker.ReadAsync() );
#pragma warning disable 612,618
var result = unpacker.Data;
#pragma warning restore 612,618
Assert.IsTrue( result.HasValue );
Assert.That( Single.IsNaN( ( System.Single )result.Value ) );
}
}
public void TestUnpackBin32_65536_ReadString_HasExtra_Splitted()
{
using( var buffer =
new MemoryStream(
new byte[] { 0xC6, 0, 1, 0, 0 }
.Concat( Enumerable.Repeat( ( byte )'A', 65537 ) ).ToArray()
)
)
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
String result;
Assert.IsTrue( unpacker.ReadString( out result ) );
Assert.That( result, Is.EqualTo( new String( 'A', 65536 ) ) );
}
}
public async Task TestReadNullableDoubleAsync_DoubleNegativeZero_Splitted()
{
using( var buffer = new MemoryStream( new byte[] { 0xCB, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } ) )
using( var splitted = new SplittingStream( buffer ) )
using( var unpacker = Unpacker.Create( splitted ) )
{
Double? result;
var ret = await unpacker.ReadNullableDoubleAsync();
Assert.IsTrue( ret.Success );
result = ret.Value;
Assert.That( ( -0.0 ).Equals( result.Value ) );
}
}
