public void TestReadSubtree_InNestedScalar()
{
using (var buffer = new MemoryStream(new byte[] { 0x81, 0x1, 0x91, 0x1 }))
using (var target = Unpacker.Create(buffer))
{
Assert.That(target.Read());
Assert.That(target.IsMapHeader, Is.True);
Assert.That(target.Read());
Assert.That(target.IsMapHeader, Is.False);
Assert.Throws <InvalidOperationException>(() => target.ReadSubtree());
}
}
private static MessagePackObjectDictionary UnpackDictionaryCore(Stream source)
{
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
if (!(IsNil(unpacker) || unpacker.IsMapHeader))
{
throw new MessageTypeException("The underlying stream is not map type.");
}
return(UnpackDictionaryCore(unpacker));
}
}
private static IList <MessagePackObject> UnpackArrayCore(Stream source)
{
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
if (!(IsNil(unpacker) || unpacker.IsArrayHeader))
{
throw new MessageTypeException("The underlying stream is not array type.");
}
return(UnpackArrayCore(unpacker));
}
}
private static object UnpackNullCore(Stream source)
{
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
VerifyIsScalar(unpacker);
if (!unpacker.Data.Value.IsNil)
{
throw new MessageTypeException("The underlying stream is not nil.");
}
return(null);
}
}
public void TestReadArrayLength_EmptyArray_RecognizeEmptyArray()
{
using (var buffer = new MemoryStream(new byte[] { 0x90, 0x1 }))
using (var target = Unpacker.Create(buffer))
{
long result;
Assert.That(target.ReadArrayLength(out result));
Assert.That(target.IsArrayHeader);
Assert.That(result, Is.EqualTo(0));
Assert.That(target.LastReadData == 0, target.LastReadData.ToString());
Assert.That(target.ItemsCount, Is.EqualTo(0));
}
}
public void TestRead_ScalarSequence_AsIs()
{
using (var buffer = new MemoryStream(new byte[] { 0x1, 0x2, 0x3 }))
using (var rootUnpacker = Unpacker.Create(buffer))
{
Assert.That(rootUnpacker.Read(), "1st");
Assert.That(rootUnpacker.Data.Value.Equals(1));
Assert.That(rootUnpacker.Read(), "2nd");
Assert.That(rootUnpacker.Data.Value.Equals(2));
Assert.That(rootUnpacker.Read(), "3rd");
Assert.That(rootUnpacker.Data.Value.Equals(3));
}
}
public void TestReadMapLength_EmptyMap_RecognizeEmptyMap()
{
using (var buffer = new MemoryStream(new byte[] { 0x80, 0x1 }))
using (var target = Unpacker.Create(buffer))
{
long result;
Assert.That(target.ReadMapLength(out result));
Assert.That(target.IsMapHeader);
Assert.That(result, Is.EqualTo(0));
Assert.That(target.Data.Value == 0, target.Data.Value.ToString());
Assert.That(target.ItemsCount, Is.EqualTo(0));
}
}
public void TestReadData_Array_AsSingleArray()
{
using (var buffer = new MemoryStream(new byte[] { 0x92, 0x1, 0x2 }))
using (var target = Unpacker.Create(buffer))
{
var result = target.ReadItem();
Assert.That(result.HasValue);
var array = result.Value.AsList();
Assert.That(array.Count, Is.EqualTo(2), result.Value.ToString());
Assert.That(array[0] == 1, result.Value.ToString());
Assert.That(array[1] == 2, result.Value.ToString());
Assert.That(target.ReadItem(), Is.Null);
}
}
public void TestReadData_Map_AsSingleMap()
{
using (var buffer = new MemoryStream(new byte[] { 0x82, 0x1, 0x2, 0x3, 0x4 }))
using (var target = Unpacker.Create(buffer))
{
var result = target.ReadItem();
Assert.That(result.HasValue);
var map = result.Value.AsDictionary();
Assert.That(map.Count, Is.EqualTo(2), result.Value.ToString());
Assert.That(map[1] == 2, result.Value.ToString());
Assert.That(map[3] == 4, result.Value.ToString());
Assert.That(target.ReadItem(), Is.Null);
}
}
public void Run()
{
using ( var pacStream = new MemoryStream() )
using ( var pacCompactStream = new MemoryStream() )
{
Unpacker pac = Unpacker.Create( pacStream );
Unpacker pac_compact = Unpacker.Create( pacCompactStream );
FeedFile( pacStream, "." + Path.DirectorySeparatorChar + "cases.mpac" );
FeedFile( pacCompactStream, "." + Path.DirectorySeparatorChar + "cases_compact.mpac" );
pac.SequenceEqual( pac_compact, EqualityComparer<MessagePackObject>.Default );
}
}
public void TestRead_InSubtreeMode_Fail()
{
using (var buffer = new MemoryStream(new byte[] { 0x91, 0x1 }))
using (var rootUnpacker = Unpacker.Create(buffer))
{
Assert.That(rootUnpacker.Read(), "Failed to first read");
using (var subTreeUnpacker = rootUnpacker.ReadSubtree())
{
// To be failed.
Assert.Throws <InvalidOperationException>(() => rootUnpacker.Read());
}
}
}
public void TestCreate_OwnsStreamisFalse_NotDisposeStream()
{
using (var stream = new MemoryStream())
{
using (var unpacker = Unpacker.Create(stream, false))
{
Assert.That(unpacker, Is.InstanceOf <MessagePackStreamUnpacker>());
Assert.That((unpacker as MessagePackStreamUnpacker).DebugOwnsStream, Is.False);
}
// Should not throw ObjectDisposedException.
stream.WriteByte(1);
}
}
public void TestGetEnumerator_UnderSkipping()
{
using (var buffer = new MemoryStream(new byte[] { 0xD1, 0x1 }))
using (var target = Unpacker.Create(buffer))
{
Assert.That(target.Skip(), Is.Null, "Precondition");
Assert.Throws <InvalidOperationException>(() =>
{
foreach (var item in target)
{
}
}
);
}
}
public void TestReadSubtree_InRootHead_Success()
{
using (var buffer = new MemoryStream(new byte[] { 0x91, 0x1 }))
using (var target = Unpacker.Create(buffer))
{
Assert.That(target.Read());
Assert.That(target.IsArrayHeader);
using (var subTreeUnpacker = target.ReadSubtree())
{
Assert.That(subTreeUnpacker.Read());
Assert.That(subTreeUnpacker.Data.Value.Equals(0x1));
}
}
}
private static byte[] UnpackBinaryCore(Stream source)
{
using (var unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
try
{
return(unpacker.LastReadData.AsBinary());
}
catch (InvalidOperationException ex)
{
throw NewTypeMismatchException(typeof(byte[]), ex);
}
}
}
public void TestRead_ReadInTail_NoEffect()
{
using (var buffer = new MemoryStream(new byte[] { 0x1, 0x2, 0x3 }))
using (var rootUnpacker = Unpacker.Create(buffer))
{
Assert.That(rootUnpacker.Read(), "1st");
Assert.That(rootUnpacker.Data.Value.Equals(1));
Assert.That(rootUnpacker.Read(), "2nd");
Assert.That(rootUnpacker.Data.Value.Equals(2));
Assert.That(rootUnpacker.Read(), "3rd");
Assert.That(rootUnpacker.Data.Value.Equals(3));
Assert.That(rootUnpacker.Read(), Is.False, "Tail");
// Data should be last read.
Assert.That(rootUnpacker.Data.Value.Equals(3));
}
}
private static uint?UnpackDictionaryCountCore(Stream source)
{
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
if (IsNil(unpacker))
{
return(null);
}
if (!unpacker.IsMapHeader)
{
throw new MessageTypeException("The underlying stream is not map type.");
}
return(new uint?((uint)unpacker.Data.Value));
}
}
private static bool UnpackBooleanCore(Stream source)
{
using (var unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
VerifyIsScalar(unpacker);
try
{
return(( bool )unpacker.LastReadData);
}
catch (InvalidOperationException ex)
{
throw NewTypeMismatchException(typeof(bool), ex);
}
}
}
public void TestReadData_TwoScalar_AsTwoScalar()
{
using (var buffer = new MemoryStream(new byte[] { 0x1, 0x2 }))
using (var target = Unpacker.Create(buffer))
{
var result1 = target.ReadItem();
Assert.That(result1.HasValue);
Assert.That(result1.Value == 1, result1.Value.ToString());
var result2 = target.ReadItem();
Assert.That(result2.HasValue);
Assert.That(result2.Value == 2, result2.Value.ToString());
Assert.That(target.ReadItem(), Is.Null);
}
}
public void TestReadObjectFromInt8()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = -32;
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsTypeOf <sbyte>().GetValueOrDefault(), "Type: Int8");
Assert.That(result.Equals(value), "Value: " + result);
}
}
}
public void TestReadObjectFromReal32()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = Single.Epsilon;
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsTypeOf <float>().GetValueOrDefault(), "Type: Real32");
Assert.That(result.Equals(value), "Value: " + result);
}
}
}
private static byte[] UnpackBinaryCore(Stream source)
{
byte[] buffer;
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
try
{
buffer = unpacker.Data.Value.AsBinary();
}
catch (InvalidOperationException exception)
{
throw NewTypeMismatchException(typeof(byte[]), exception);
}
}
return(buffer);
}
private static uint?UnpackArrayLengthCore(Stream source)
{
using (var unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
if (IsNil(unpacker))
{
return(null);
}
if (!unpacker.IsArrayHeader)
{
throw new MessageTypeException("The underlying stream is not array type.");
}
return(( uint )unpacker.LastReadData);
}
}
public void TestReadData_MapOfMap_AsSingleMap()
{
using (var buffer = new MemoryStream(new byte[] { 0x82, 1, 0x82, 11, 1, 12, 2, 2, 0x82, 21, 1, 22, 2 }))
using (var target = Unpacker.Create(buffer))
{
var result = target.ReadItem();
Assert.That(result.HasValue);
var map = result.Value.AsDictionary();
Assert.That(map.Count, Is.EqualTo(2), result.Value.ToString());
Assert.That(map[1].IsMap, result.Value.ToString());
Assert.That(map[1].AsDictionary()[11] == 1, result.Value.ToString());
Assert.That(map[1].AsDictionary()[12] == 2, result.Value.ToString());
Assert.That(map[2].IsMap, result.Value.ToString());
Assert.That(map[2].AsDictionary()[21] == 1, result.Value.ToString());
Assert.That(map[2].AsDictionary()[22] == 2, result.Value.ToString());
Assert.That(target.ReadItem(), Is.Null);
}
}
public void TestReadObjectFromArray32()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = Enumerable.Repeat(1, UInt16.MaxValue + 1).ToArray();
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsList, "Type: Array32");
Assert.That(result.AsList().SequenceEqual(value.Select(i => ( MessagePackObject )i)), "Value: " + result);
Assert.That(result.AsList().Count(), Is.EqualTo(value.Count()), "Count:" + result);
}
}
}
public void TestReadObjectFromMap32()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = Enumerable.Range(1, UInt16.MaxValue + 1).ToDictionary(i => i, i => ~i);
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsDictionary, "Type: Map32");
DictionaryEquals(result.AsDictionary(), value);
Assert.That(result.AsDictionary().Count(), Is.EqualTo(value.Count()), "Count:" + result);
}
}
}
public void TestReadObjectFromStr32()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = new String(Enumerable.Repeat('a', UInt16.MaxValue + 1).ToArray());
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsTypeOf <string>().GetValueOrDefault(), "Type: Str32");
Assert.That(result.AsString().Equals(value), "Value: " + result);
Assert.That(result.AsString().Count(), Is.EqualTo(value.Count()), "Count:" + result);
}
}
}
public void TestReadObjectFromBin32()
{
using (var buffer = new MemoryStream())
using (var packer = Packer.Create(buffer))
{
var value = Enumerable.Repeat(( byte )1, UInt16.MaxValue + 1).ToArray();
packer.Pack(value);
buffer.Position = 0;
using (var unpacker = Unpacker.Create(buffer))
{
MessagePackObject result;
Assert.That(unpacker.ReadObject(out result));
Assert.That(result.IsTypeOf <byte[]>().GetValueOrDefault(), "Type: Bin32");
Assert.That(result.AsBinary().SequenceEqual(value), "Value: " + result);
Assert.That(result.AsBinary().Count(), Is.EqualTo(value.Count()), "Count:" + result);
}
}
}
private static ulong UnpackUInt64Core(Stream source)
{
ulong num;
using (Unpacker unpacker = Unpacker.Create(source, false))
{
UnpackOne(unpacker);
VerifyIsScalar(unpacker);
try
{
num = (ulong)unpacker.Data.Value;
}
catch (InvalidOperationException exception)
{
throw NewTypeMismatchException(typeof(ulong), exception);
}
}
return(num);
}
public void TestCreate_StreamOptionIsNull()
{
PackerUnpackerStreamOptions.AlwaysWrap = true;
try
{
using (var stream = new MemoryStream())
using (var unpacker = Unpacker.Create(stream, default(PackerUnpackerStreamOptions), default(UnpackerOptions)))
{
Assert.That(unpacker, Is.InstanceOf <MessagePackStreamUnpacker>());
var streamUnpacker = unpacker as MessagePackStreamUnpacker;
Assert.That(streamUnpacker.DebugOwnsStream, Is.False);
Assert.That(streamUnpacker.DebugSource, Is.SameAs(stream));
}
}
finally
{
PackerUnpackerStreamOptions.AlwaysWrap = false;
}
}
