public void TestEncode_Min96() { Assert.That( new Timestamp(-9223372036854775808L, 0).Encode(), Is.EqualTo(MessagePackExtendedTypeObject.Unpack(0xFF, new byte[] { 0, 0, 0, 0, 0x80, 0, 0, 0, 0, 0, 0, 0 })) ); }
/// <summary> /// Decodes specified <see cref="MessagePackExtendedTypeObject"/> and returns an equivalant <see cref="Timestamp"/>. /// </summary> /// <param name="value"><see cref="MessagePackExtendedTypeObject"/> which is native representation of <see cref="Timestamp"/>.</param> /// <returns><see cref="Timestamp"/>.</returns> /// <exception cref="ArgumentException"> /// <paramref name="value"/> does not represent msgpack timestamp. Specifically, the type code is not equal to <see cref="TypeCode"/> value. /// Or, <paramref name="value"/> does not have valid msgpack timestamp structure. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="value"/> have invalid nanoseconds value. /// </exception> /// <remarks> /// A definition of valid msgpack time stamp is: /// <list type="bullet"> /// <item>Its type code is <c>0xFF</c>(<c>-1</c>).</item> /// <item>Its length is 4, 8, or 12 bytes.</item> /// <item>Its nanoseconds part is between 0 and 999,999,999.</item> /// </list> /// </remarks> public static Timestamp Decode(MessagePackExtendedTypeObject value) { if (value.TypeCode != TypeCode) { throw new ArgumentException("The value's type code must be 0xFF.", "value"); } switch (value.Body.Length) { case 4: { // timespan32 format return(new Timestamp(BigEndianBinary.ToUInt32(value.Body, 0), 0)); } case 8: { // timespan64 format var payload = BigEndianBinary.ToUInt64(value.Body, 0); return(new Timestamp(unchecked (( long )(payload & 0x00000003ffffffffL)), unchecked (( int )(payload >> 34)))); } case 12: { // timespan96 format return(new Timestamp(BigEndianBinary.ToInt64(value.Body, sizeof(int)), unchecked (( int )BigEndianBinary.ToUInt32(value.Body, 0)))); } default: { throw new ArgumentException("The value's length is not valid.", "value"); } } }
public void TestEncode_Min64() { Assert.That( new Timestamp(0L, 1).Encode(), Is.EqualTo(MessagePackExtendedTypeObject.Unpack(0xFF, new byte[] { 0, 0, 0, 0x4, 0, 0, 0, 0 })) ); }
public void TestEncode_Max64() { Assert.That( new Timestamp(17179869183L, 999999999).Encode(), Is.EqualTo(MessagePackExtendedTypeObject.Unpack(0xFF, new byte[] { 0xEE, 0x6B, 0x27, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF })) ); }
public void TestEncode_Max32() { Assert.That( new Timestamp(4294967295L, 0).Encode(), Is.EqualTo(MessagePackExtendedTypeObject.Unpack(0xFF, new byte[] { 0xFF, 0xFF, 0xFF, 0xFF })) ); }
public void TestEncode_Max96() { Assert.That( new Timestamp(9223372036854775807L, 999999999).Encode(), Is.EqualTo(MessagePackExtendedTypeObject.Unpack(0xFF, new byte[] { 0x3B, 0x9A, 0xC9, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF })) ); }
public void TestToString_ExtendedTypeObject_AsIs() { var mpeto = new MessagePackExtendedTypeObject(123, new byte[] { 1, 2, 3 }); Assert.AreEqual( mpeto.ToString(), new MessagePackObject(mpeto).ToString() ); }
public void TestProperties() { byte typeCode = 0; var body = new byte[] { 1 }; var actual = new MessagePackExtendedTypeObject(typeCode, body); Assert.That(actual.TypeCode, Is.EqualTo(typeCode)); Assert.That(actual.Body, Is.SameAs(body)); Assert.That(actual.GetBody(), Is.Not.SameAs(body).And.EqualTo(body)); }
public void TestEquality_Self() { var left = new MessagePackExtendedTypeObject(0, new byte[] { 1 }); var right = left; Assert.That(left.Equals(right), Is.True, "IEquatable.Equals"); Assert.That(left.Equals(( object )right), Is.True, "Equals"); Assert.That(left == right, Is.True, "=="); Assert.That(left != right, Is.False, "!="); }
/// <summary> /// Encodes this instance to a <see cref="MessagePackExtendedTypeObject"/>. /// </summary> /// <returns>A <see cref="MessagePackExtendedTypeObject"/> which equivalant to this instance.</returns> public MessagePackExtendedTypeObject Encode() { if ((this.unixEpochSeconds >> 34) != 0) { // timestamp 96 var value = this; var body = new byte[12]; body[0] = unchecked (( byte )((this.nanoseconds >> 24) & 0xFF)); body[1] = unchecked (( byte )((this.nanoseconds >> 16) & 0xFF)); body[2] = unchecked (( byte )((this.nanoseconds >> 8) & 0xFF)); body[3] = unchecked (( byte )((this.nanoseconds) & 0xFF)); body[4] = unchecked (( byte )((this.unixEpochSeconds >> 56) & 0xFF)); body[5] = unchecked (( byte )((this.unixEpochSeconds >> 48) & 0xFF)); body[6] = unchecked (( byte )((this.unixEpochSeconds >> 40) & 0xFF)); body[7] = unchecked (( byte )((this.unixEpochSeconds >> 32) & 0xFF)); body[8] = unchecked (( byte )((this.unixEpochSeconds >> 24) & 0xFF)); body[9] = unchecked (( byte )((this.unixEpochSeconds >> 16) & 0xFF)); body[10] = unchecked (( byte )((this.unixEpochSeconds >> 8) & 0xFF)); body[11] = unchecked (( byte )(this.unixEpochSeconds & 0xFF)); return(MessagePackExtendedTypeObject.Unpack(TypeCode, body)); } else { var encoded = ((( ulong )this.nanoseconds) << 34) | unchecked (( ulong )this.unixEpochSeconds); if ((encoded & 0xFFFFFFFF00000000L) == 0) { // timestamp 32 var value = unchecked (( uint )encoded); var body = new byte[4]; body[0] = unchecked (( byte )((encoded >> 24) & 0xFF)); body[1] = unchecked (( byte )((encoded >> 16) & 0xFF)); body[2] = unchecked (( byte )((encoded >> 8) & 0xFF)); body[3] = unchecked (( byte )(encoded & 0xFF)); return(MessagePackExtendedTypeObject.Unpack(TypeCode, body)); } else { // timestamp 64 var body = new byte[8]; body[0] = unchecked (( byte )((encoded >> 56) & 0xFF)); body[1] = unchecked (( byte )((encoded >> 48) & 0xFF)); body[2] = unchecked (( byte )((encoded >> 40) & 0xFF)); body[3] = unchecked (( byte )((encoded >> 32) & 0xFF)); body[4] = unchecked (( byte )((encoded >> 24) & 0xFF)); body[5] = unchecked (( byte )((encoded >> 16) & 0xFF)); body[6] = unchecked (( byte )((encoded >> 8) & 0xFF)); body[7] = unchecked (( byte )(encoded & 0xFF)); return(MessagePackExtendedTypeObject.Unpack(TypeCode, body)); } } }
public virtual bool ReadMessagePackExtendedTypeObject(out MessagePackExtendedTypeObject result) { if (!this.Read()) { result = default(MessagePackExtendedTypeObject); return(false); } result = this.LastReadData.AsMessagePackExtendedTypeObject(); return(true); }
public override bool ReadMessagePackExtendedTypeObject(out MessagePackExtendedTypeObject result) { this.DiscardCompletedStacks(); if (this._itemsCount.Count == 0) { result = default(MessagePackExtendedTypeObject); return(false); } if (!this._root.ReadMessagePackExtendedTypeObject(out result)) { return(false); } switch (this._internalRoot.CollectionType) { case CollectionType.Array: { this._itemsCount.Push(this._root.ItemsCount); this._unpacked.Push(0); this._isMap.Push(false); break; } case CollectionType.Map: { this._itemsCount.Push(this._root.ItemsCount * 2); this._unpacked.Push(0); this._isMap.Push(true); break; } default: { this._unpacked.Push(this._unpacked.Pop() + 1); break; } } return(true); }
public void TestEquality_ValueEqual() { foreach (var testCase in new[] { Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 1 }, true), Tuple.Create(0, 1, new byte[] { 1 }, new byte[] { 1 }, false), Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 1, 2 }, false), Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 2 }, false), }) { checked { MessagePackObject left = new MessagePackExtendedTypeObject(( byte )testCase.Item1, testCase.Item3); MessagePackObject right = new MessagePackExtendedTypeObject(( byte )testCase.Item2, testCase.Item4); Assert.That(left.Equals(right), Is.EqualTo(testCase.Item5), "IEquatable.Equals"); Assert.That(left.Equals(( object )right), Is.EqualTo(testCase.Item5), "Equals"); Assert.That(left == right, Is.EqualTo(testCase.Item5), "=="); Assert.That(left != right, Is.EqualTo(!testCase.Item5), "!="); } } }
public void TestExts() { var sw = new Stopwatch(); 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 } ) { sw.Reset(); sw.Start(); 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); Assert.AreEqual( value, UnpackOne(output).AsMessagePackExtendedTypeObject() ); sw.Stop(); } Console.WriteLine("Ext: {0:0.###} msec/byte", sw.ElapsedMilliseconds / 0x10000); }
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 TestToObject_ExtendedTypeObject_Success() { var value = new MessagePackExtendedTypeObject(1, new byte[] { 1 }); TestToObjectCore(value, value); }
public void TestDecode_InvalidLength_13() { Assert.Throws <ArgumentException>(() => Timestamp.Decode(MessagePackExtendedTypeObject.Unpack(0xFF, new byte [13]))); }