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; } }