public void TestSkip_FalseValue() { var binary = new byte[]{ 0xC2, 0xC2 }; using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
private SubtreeUnpacker(ItemsUnpacker root, SubtreeUnpacker parent) { Contract.Assert(root != null); Contract.Assert(root.IsArrayHeader || root.IsMapHeader); this._root = root; this._parent = parent; this._unpacked = new Stack <long>(2); this._itemsCount = new Stack <long>(2); this._isMap = new Stack <bool>(2); if (root.ItemsCount > 0L) { this._itemsCount.Push(root.ItemsCount * (root.IsMapHeader ? ((long)2) : ((long)1))); this._unpacked.Push(0L); this._isMap.Push(root.IsMapHeader); } }
private SubtreeUnpacker( ItemsUnpacker root, SubtreeUnpacker parent ) { Contract.Assert( root != null ); Contract.Assert( root.IsArrayHeader || root.IsMapHeader ); this._root = root; this._parent = parent; this._unpacked = new Stack<long>( 2 ); this._itemsCount = new Stack<long>( 2 ); this._isMap = new Stack<bool>( 2 ); if ( root.ItemsCount > 0 ) { this._itemsCount.Push( root.ItemsCount * ( root.IsMapHeader ? 2 : 1 ) ); this._unpacked.Push( 0 ); this._isMap.Push( root.IsMapHeader ); } }
private SubtreeUnpacker( ItemsUnpacker root, SubtreeUnpacker parent ) { #if DEBUG && !UNITY_ANDROID && !UNITY_IPHONE Contract.Assert( root != null ); Contract.Assert( root.IsArrayHeader || root.IsMapHeader ); #endif // DEBUG && !UNITY_ANDROID && !UNITY_IPHONE this._root = root; this._parent = parent; this._unpacked = new Stack<long>( 2 ); this._itemsCount = new Stack<long>( 2 ); this._isMap = new Stack<bool>( 2 ); if ( root.ItemsCount > 0 ) { this._itemsCount.Push( root.InternalItemsCount * ( ( int )root.InternalCollectionType ) ); this._unpacked.Push( 0 ); this._isMap.Push( root.InternalCollectionType == ItemsUnpacker.CollectionType.Map ); } }
private SubtreeUnpacker(ItemsUnpacker root, SubtreeUnpacker parent) { #if DEBUG Contract.Assert(root != null); Contract.Assert(root.IsArrayHeader || root.IsMapHeader); #endif this._root = root; this._parent = parent; this._unpacked = new Stack <long>(2); this._itemsCount = new Stack <long>(2); this._isMap = new Stack <bool>(2); if (root.ItemsCount > 0) { this._itemsCount.Push(root.InternalItemsCount * (( int )root.InternalCollectionType)); this._unpacked.Push(0); this._isMap.Push(root.InternalCollectionType == ItemsUnpacker.CollectionType.Map); } }
private SubtreeUnpacker(ItemsUnpacker root, SubtreeUnpacker parent) { #if DEBUG && !UNITY Contract.Assert(root != null, "root != null"); Contract.Assert(root.IsArrayHeader || root.IsMapHeader, "root.IsArrayHeader || root.IsMapHeader"); #endif // DEBUG && !UNITY this._root = root; this._parent = parent; this._unpacked = new Int64Stack(2); this._itemsCount = new Int64Stack(2); this._isMap = new BooleanStack(2); if (root.ItemsCount > 0) { this._itemsCount.Push(root.InternalItemsCount * (( int )root.InternalCollectionType)); this._unpacked.Push(0); this._isMap.Push(root.InternalCollectionType == ItemsUnpacker.CollectionType.Map); } this._state = State.InHead; }
public void TestSkip_Ext8_Max() { var binary = new byte[] { 0xC7 }.Concat( new byte[] { 0xFF } ).Concat( new byte[] { 0x7F } ).Concat( Enumerable.Repeat( 0x41, 0xFF ).Select( i => ( byte )i ) ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public void TestBin8_Zero() { var binary = new byte[] { 0xC4 }.Concat( new byte[] { 0x0 } ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, false ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public SubtreeUnpacker(ItemsUnpacker parent) : this(parent, null) { }
public SubtreeUnpacker( ItemsUnpacker parent ) : this( parent, null ) { }
private SubtreeUnpacker( ItemsUnpacker root, SubtreeUnpacker parent ) { #if DEBUG Contract.Assert( root != null, "root != null" ); Contract.Assert( root.IsArrayHeader || root.IsMapHeader, "root.IsArrayHeader || root.IsMapHeader" ); #endif // DEBUG this._root = root; this._parent = parent; this._unpacked = new Int64Stack( 2 ); this._itemsCount = new Int64Stack( 2 ); this._isMap = new BooleanStack( 2 ); if ( root.ItemsCount > 0 ) { this._itemsCount.Push( root.InternalItemsCount * ( ( int )root.InternalCollectionType ) ); this._unpacked.Push( 0 ); this._isMap.Push( root.InternalCollectionType == ItemsUnpacker.CollectionType.Map ); } this._state = State.InHead; }
public async Task TestSkipAsync_FixExt8() { var binary = new byte[]{ 0xD7, 0x7F, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0xC2 }; using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = await target.SkipAsync(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public void TestBin32_Min() { var binary = new byte[] { 0xC6 }.Concat( BitConverter.GetBytes( ( uint )0x10000 ).Reverse() ).Concat( Enumerable.Repeat( 0x41, 0x10000 ).Select( i => ( byte )i ) ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, false ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public void TestSkip_Ext16_Zero() { var binary = new byte[] { 0xC8 }.Concat( BitConverter.GetBytes( ( ushort )0x0 ).Reverse() ).Concat( new byte[] { 0x7F } ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public void TestFixExt4() { var binary = new byte[]{ 0xD6, 0x7F, 0x04, 0x03, 0x02, 0x01, 0xC2 }; using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, false ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public async Task TestSkipAsync_Ext8_Zero() { var binary = new byte[] { 0xC7 }.Concat( new byte[] { 0x0 } ).Concat( new byte[] { 0x7F } ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = await target.SkipAsync(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public void TestSkip_FixExt16() { var binary = new byte[]{ 0xD8, 0x7F, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0xC2 }; using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = target.Skip(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }
public async Task TestSkipAsync_Ext32_Max() { var binary = new byte[] { 0xC9 }.Concat( BitConverter.GetBytes( ( uint )0x10001 ).Reverse() ).Concat( new byte[] { 0x7F } ).Concat( Enumerable.Repeat( 0x41, 0x10001 ).Select( i => ( byte )i ) ).Concat( new byte[] { 0xC2 } ).ToArray(); using ( var buffer = new MemoryStream( binary ) ) using ( var target = new ItemsUnpacker( buffer, PackerUnpackerStreamOptions.None ) ) { var result = await target.SkipAsync(); Assert.That( result, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); Assert.That( buffer.Position, Is.EqualTo( binary.Length - 1 /* minus centinel byte */ ) ); // Verify centinel value still exists in the stream. Assert.That( buffer.ReadByte(), Is.EqualTo( 0xC2 ) ); } }