public void TestUnpackObject_ByteArray_Int32_OffsetIsNegative() { Assert.Throws <ArgumentOutOfRangeException>(() => Unpacking.UnpackObject(new byte[] { 0x1 }, -1)); }
public void TestUnpackDictionary_DictionaryCountIsGreaterThanInt32MaxValue() { Assert.Throws <MessageNotSupportedException>(() => Unpacking.UnpackDictionary(new byte[] { 0xDF, 0x80, 0x00, 0x00, 0x00, 0xFF })); }
public void TestUnpackObject_ByteArray_Int32_ByteArrayIsEmpty() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackObject(new byte[0], 0)); }
public void TestUnpackCharStream_Stream_Null() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackCharStream(null)); }
public void TestUnpackCharStream_Stream_Encoding_EncodingIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackCharStream(new MemoryStream(new byte[] { 0xA1, ( byte )'A' }), null)); }
public void TestUnpackString_ByteArray_Int32_Encoding_OffsetIsTooBig() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackString(new byte[] { 0x1 }, 1, Encoding.UTF8)); }
public void TestUnpackString_ByteArray_Int32_Encoding_EncodingIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackString(new byte[] { 0x1 }, 0, null)); }
/// <summary> /// Transit current stage to unpackContextCollection stage with cleanuping states. /// </summary> private void TransitToUnpackContextCollection() { this._next = this._unpackHeader; this._isInCollection = true; this._contextValueHeader = MessagePackHeader.Null; this._bytesBuffer = BytesBuffer.Null; }
public void TestUnpackDictionaryCount_ByteArray_Offset_Null() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackDictionaryCount(default(byte[]), 0)); }
/// <summary> /// Try unpack object from specified source. /// </summary> /// <param name="source">Input source to unpack.</param> /// <param name="unpackingMode"><see cref="UnpackingMode"/> that controls unpacking flow.</param> /// <returns> /// Unpacked entry. The mean of the entry depends on specified <paramref name="unpackingMode"/>. /// </returns> /// <remarks> /// <para> /// When this method returns null, caller can feed extra bytes to <paramref name="source"/> and invoke this again. /// It could succeed because this instance preserves previous invocation state, and required bytes are supplied. /// </para> /// <para> /// When this method completes unpackaging single <see cref="MessagePackObject"/> tree, /// this method stops iterating <paramref name="source"/> (via <see cref="IEnumerator<T>"/>. /// This behavior is notified via <see cref="IDisposable.Dispose">IEnumerator<T>.Dispose()</see> method. /// </para> /// </remarks> public MessagePackObject? Unpack( Stream source, UnpackingMode unpackingMode ) { // FIXME:BULK LOAD Contract.Assert( source != null ); this._lastEmptyCollection = EmptyCollectionType.None; MessagePackObject? collectionItemOrRoot; while ( this._next( source, unpackingMode, out collectionItemOrRoot ) ) { if ( collectionItemOrRoot != null ) { int depth = this._collectionState.Depth; var root = this.AddToContextCollection( collectionItemOrRoot.Value ); this._hasMoreEntries = depth <= this._collectionState.Depth; if ( root != null ) { #if DEBUG Contract.Assert( this._collectionState.IsEmpty ); #endif this._next = this._unpackHeader; this._isInCollection = false; #if DEBUG Contract.Assert( this._contextValueHeader.Type == MessageType.Unknown, this._contextValueHeader.ToString() );// null Contract.Assert( this._bytesBuffer.BackingStore == null, this._bytesBuffer.ToString() ); // null #endif if ( unpackingMode == UnpackingMode.PerEntry ) { if ( this._lastEmptyCollection != EmptyCollectionType.None ) { // It was empty collection. return 0; } else { // Last item return collectionItemOrRoot.Value; } } else { // Length var readByteLength = this._readByteLength; this._readByteLength = 0L; return readByteLength; } } } else { this._hasMoreEntries = true; } // There are more entries in the tree. if ( unpackingMode == UnpackingMode.PerEntry ) { // The unpacker may return unpacked collection item. if ( this._isInCollection ) { if ( this._collectionState.UnpackedItemsCount == 0 ) { // Count return this._collectionState.UnpackingItemsCount; } else if ( this._lastEmptyCollection != EmptyCollectionType.None ) { // Empty nested collection. return 0; } else { Contract.Assert( collectionItemOrRoot.HasValue ); return collectionItemOrRoot.Value; } } } } return null; }
/// <summary> /// Transit current stage to unpackRawBytes stage with cleanuping states. /// </summary> /// <param name="length">The known length of the source.</param> private void TransitToUnpackRawBytes( uint length ) { this._next = this._unpackRawBytes; this._isInCollection = false; // Allocate buffer to store raw binaries. this._bytesBuffer = new BytesBuffer( length ); }
/// <summary> /// Initializes a new instance of the <see cref="StreamingUnpacker"/> class. /// </summary> public StreamingUnpacker() { this._unpackCollectionLength = this.UnpackCollectionLength; this._unpackHeader = this.UnpackHeader; this._unpackRawLength = this.UnpackRawLength; this._unpackRawBytes = this.UnpackRawBytes; this._unpackScalar = this.UnpackScalar; this._next = this._unpackHeader; }
public void TestMap() { var emptyMap = new Dictionary <int, int>(); { var output = new MemoryStream(); Packer.Create(output).PackDictionary(emptyMap); Assert.AreEqual(0, Unpacking.UnpackDictionaryCount(new MemoryStream(output.ToArray()))); Assert.AreEqual(0, Unpacking.UnpackDictionaryCount(output.ToArray()).Value); } var random = new Random(); for (int i = 0; i < 100; i++) { var m = new Dictionary <int, int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { m[j] = j; } var output = new MemoryStream(); Packer.Create(output).PackDictionary(m); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackDictionaryCount(streamInput)); for (int j = 0; j < len; j++) { int value; Assert.IsTrue(m.TryGetValue(Unpacking.UnpackInt32(streamInput), out value)); Assert.AreEqual(value, Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackDictionaryCount(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var keyUar = Unpacking.UnpackInt32(byteArrayInput, offset); Assert.AreNotEqual(0, keyUar.ReadCount); int value; Assert.IsTrue(m.TryGetValue(keyUar.Value, out value)); var valueUar = Unpacking.UnpackInt32(byteArrayInput, offset + keyUar.ReadCount); Assert.AreEqual(value, valueUar.Value); offset += keyUar.ReadCount + valueUar.ReadCount; } } for (int i = 0; i < 100; i++) { var m = new Dictionary <string, int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { m[j.ToString()] = j; } var output = new MemoryStream(); Packer.Create(output).PackDictionary(m); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackDictionaryCount(streamInput)); for (int j = 0; j < len; j++) { int value; Assert.IsTrue(m.TryGetValue(Unpacking.UnpackString(streamInput), out value)); Assert.AreEqual(value, Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackDictionaryCount(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var usr = Unpacking.UnpackString(byteArrayInput, offset); Assert.AreNotEqual(0, usr.ReadCount); int value; Assert.IsTrue(m.TryGetValue(usr.Value, out value)); var uar = Unpacking.UnpackInt32(byteArrayInput, offset + usr.ReadCount); Assert.AreEqual(value, uar.Value); offset += usr.ReadCount + uar.ReadCount; } } }
public void TestArray() { var emptyList = new List <int>(); { var output = new MemoryStream(); Packer.Create(output).PackCollection(emptyList); Assert.AreEqual(0, Unpacking.UnpackArrayLength(new MemoryStream(output.ToArray()))); Assert.AreEqual(0, Unpacking.UnpackArrayLength(output.ToArray()).Value); } var random = new Random(); for (int i = 0; i < 100; i++) { var l = new List <int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { l.Add(j); } var output = new MemoryStream(); Packer.Create(output).PackCollection(l); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackArrayLength(streamInput)); for (int j = 0; j < len; j++) { Assert.AreEqual(l[j], Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackArrayLength(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var uar = Unpacking.UnpackInt32(byteArrayInput, offset); Assert.AreNotEqual(0, uar.ReadCount); Assert.AreEqual(l[j], uar.Value); offset += uar.ReadCount; } } for (int i = 0; i < 100; i++) { var l = new List <String>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { l.Add(j.ToString()); } var output = new MemoryStream(); Packer.Create(output).PackCollection(l); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackArrayLength(streamInput)); for (int j = 0; j < len; j++) { Assert.AreEqual(l[j], Unpacking.UnpackString(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackArrayLength(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var usr = Unpacking.UnpackString(byteArrayInput, offset); Assert.AreEqual(l[j], usr.Value); offset += usr.ReadCount; } } }
public void TestUnpackObject_Stream_Null() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackObject(default(Stream))); }
public void TestUnpackDictionaryCount_ByteArray_Offset_OffsetIsNegative() { Assert.Throws <ArgumentOutOfRangeException>(() => Unpacking.UnpackDictionaryCount(new byte[] { 0x1 }, -1)); }
public void TestUnpackDouble_ByteArray_NotDouble() { Assert.Throws <MessageTypeException>(() => Unpacking.UnpackDouble(new byte[] { 0xC3 })); }
public void TestUnpackDictionaryCount_ByteArray_Offset_OffsetIsTooBig() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackDictionaryCount(new byte[] { 0x1 }, 1)); }
public void TestUnpackString_ByteArray_Int32_Encoding_OffsetIsNegative() { Assert.Throws <ArgumentOutOfRangeException>(() => Unpacking.UnpackString(new byte[] { 0x1 }, -1, Encoding.UTF8)); }
public void TestUnpackDictionaryCount_ByteArray_Offset_Empty() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackDictionaryCount(new byte[0], 0)); }
public void TestUnpackString_Stream_Encoding_StreamIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackString(default(Stream), Encoding.UTF8)); }
public void TestUnpackDictionary_ByteArray_NotMap() { Assert.Throws <MessageTypeException>(() => Unpacking.UnpackDictionary(new byte[] { 0x1 })); }
public void TestUnpackCharStream_Stream_Encoding_StreamIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackCharStream(null, Encoding.UTF8)); }
public void TestUnpackString_ByteArray_1ByteNonUtf8String_ExceptionInReaderOperation() { Assert.Throws <MessageTypeException>(() => Unpacking.UnpackString(new byte[] { 0xA1, 0xFF })); }
public void TestUnpackObject_ByteArray_ByteArrayIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackObject(default(byte[]))); }
public void TestUnpackString_ByteArray_Null() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackString(default(byte[]))); }
public void TestUnpackObject_ByteArray_Int32_ByteArrayIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackObject(null, 0)); }
public void TestUnpackString_ByteArray_ByteArrayIsEmpty() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackString(new byte[0])); }
public void TestUnpackObject_ByteArray_Int32_OffsetIsTooBig() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackObject(new byte[] { 0x1 }, 1)); }
public void TestUnpackString_ByteArray_Int32_Encoding_ByteArrayIsNull() { Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackString(null, 0, Encoding.UTF8)); }
public void TestUnpackBinary_BinaryLengthIsGreaterThanInt32MaxValue() { Assert.Throws <MessageNotSupportedException>(() => Unpacking.UnpackBinary(new byte[] { 0xDB, 0x80, 0x00, 0x00, 0x00, 0xFF })); }
public void TestUnpackString_ByteArray_Int32_Encoding_ByteArrayIsEmpty() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackString(new byte[0], 0, Encoding.UTF8)); }
public void TestUnpackInt32_NotNumeric() { Assert.Throws <MessageTypeException>(() => Unpacking.UnpackInt32(new byte[] { 0x80 })); }
public void TestUnpackDouble_ByteArray_Empty() { Assert.Throws <ArgumentException>(() => Unpacking.UnpackDouble(new byte[0])); }