C# (CSharp) MsgPack Unpacking.UnpackDouble示例

UnpackDouble() public static method

Unpacks System.Double value from the specified Stream.

The processed bytes count can be calculated via P:Stream.Position of source when the P:Stream.CanSeek is true.

When the type of packed value is not known, use UnpackObject(Stream) instead.

/// is null. /// /// The of is false. /// /// is not valid MessagePack stream. /// Note that the state of will be unpredictable espicially it is not seekable. /// /// The unpacked result in the is not compatible to . /// Note that the state of will be unpredictable espicially it is not seekable. ///

public static UnpackDouble ( Stream source ) : Double
source	Stream	The which contains Message Pack binary stream.
return	Double

示例#1

        public void TestUnpackDouble_ByteArray_DoubleMinValue_AsIs()
        {
            var result = Unpacking.UnpackDouble(new byte[] { 0xCB, 0xFF, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF });

            Assert.AreEqual(sizeof(System.Double) + 1, result.ReadCount);
            Assert.IsTrue(Double.MinValue.Equals(result.Value));
        }

示例#2

        public void TestUnpackDouble_ByteArray_SingleMaxValue_AsIs()
        {
            var result = Unpacking.UnpackDouble(new byte[] { 0xCA, 0x7F, 0x7F, 0xFF, 0xFF });

            Assert.AreEqual(sizeof(System.Single) + 1, result.ReadCount);
            Assert.IsTrue((( double )Single.MaxValue).Equals(result.Value));
        }

示例#3

        public void TestUnpackDouble_ByteArray_SingleZero_AsIs()
        {
            var result = Unpacking.UnpackDouble(new byte[] { 0xCA, 0x00, 0x00, 0x00, 0x00 });

            Assert.AreEqual(sizeof(System.Single) + 1, result.ReadCount);
            Assert.IsTrue((0.0).Equals(result.Value));
        }

示例#4

        public void TestUnpackDoubleEpsilon_UnpackDouble_ByteArray()
        {
            var buffer = new byte[] { 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
            var result = Unpacking.UnpackDouble(buffer);

            Assert.That(result.ReadCount, Is.EqualTo(buffer.Length));
            Assert.That(Double.Epsilon.Equals(result.Value));
        }

示例#5

        public void TestUnpackDoublePositiveInfinity_UnpackDouble_ByteArray()
        {
            var buffer = new byte[] { 0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            var result = Unpacking.UnpackDouble(buffer);

            Assert.That(result.ReadCount, Is.EqualTo(buffer.Length));
            Assert.That(Double.IsPositiveInfinity(result.Value));
        }

示例#6

        public void TestUnpackDoubleNaNNegativeMaxValue_UnpackDouble_ByteArray()
        {
            var buffer = new byte[] { 0xCB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
            var result = Unpacking.UnpackDouble(buffer);

            Assert.That(result.ReadCount, Is.EqualTo(buffer.Length));
            Assert.That(Double.IsNaN(result.Value));
        }

示例#7

        public void TestUnpackDoubleNegativeZero_UnpackDouble_ByteArray()
        {
            var buffer = new byte[] { 0xCB, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            var result = Unpacking.UnpackDouble(buffer);

            Assert.That(result.ReadCount, Is.EqualTo(buffer.Length));
            Assert.That((-0.0).Equals(result.Value));
        }

示例#8

        public void TestUnpackDouble_ByteArray_Offset_OffsetIsValid_OffsetIsRespected()
        {
            // Offset 1 is Double 0.
            var result = Unpacking.UnpackDouble(new byte[] { 0xFF, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF }, 1);

            Assert.AreEqual(sizeof(System.Double) + 1, result.ReadCount);
            Assert.AreEqual(0.0, result.Value);
        }

示例#9

        private static void TestDouble(Double value)
        {
            var output = new MemoryStream();

            Packer.Create(output).Pack(value);
            Assert.AreEqual(value, Unpacking.UnpackDouble(new MemoryStream(output.ToArray())), 10e-10);
            Assert.AreEqual(value, Unpacking.UnpackDouble(output.ToArray()).Value, 10e-10);
        }

示例#10

 public void TestUnpackDouble_Stream_DoubleMinValue_AsIs()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCB, 0xFF, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.AreEqual(sizeof(System.Double) + 1, buffer.Position);
         Assert.IsTrue(Double.MinValue.Equals(result));
     }
 }

示例#11

 public void TestUnpackDoublePositiveInfinity_UnpackDouble_Stream()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCB, 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.That(buffer.Position, Is.EqualTo(buffer.Length));
         Assert.That(Double.IsPositiveInfinity(result));
     }
 }

示例#12

 public void TestUnpackDoubleNaNNegativeMaxValue_UnpackDouble_Stream()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.That(buffer.Position, Is.EqualTo(buffer.Length));
         Assert.That(Double.IsNaN(result));
     }
 }

示例#13

 public void TestUnpackDoubleNegativeZero_UnpackDouble_Stream()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCB, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.That(buffer.Position, Is.EqualTo(buffer.Length));
         Assert.That((-0.0).Equals(result));
     }
 }

示例#14

 public void TestUnpackDoubleEpsilon_UnpackDouble_Stream()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.That(buffer.Position, Is.EqualTo(buffer.Length));
         Assert.That(Double.Epsilon.Equals(result));
     }
 }

示例#15

 public void TestUnpackDouble_Stream_SingleMaxValue_AsIs()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCA, 0x7F, 0x7F, 0xFF, 0xFF }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.AreEqual(sizeof(System.Single) + 1, buffer.Position);
         Assert.IsTrue((( double )Single.MaxValue).Equals(result));
     }
 }

示例#16

 public void TestUnpackDouble_Stream_SingleZero_AsIs()
 {
     using (var buffer = new MemoryStream(new byte[] { 0xCA, 0x00, 0x00, 0x00, 0x00 }))
     {
         var result = Unpacking.UnpackDouble(buffer);
         Assert.AreEqual(sizeof(System.Single) + 1, buffer.Position);
         Assert.IsTrue((0.0).Equals(result));
     }
 }

示例#17

 public void TestUnpackDouble_ByteArray_Offset_OffsetIsNegative()
 {
     Assert.Throws <ArgumentOutOfRangeException>(() => Unpacking.UnpackDouble(new byte[] { 0x1 }, -1));
 }

示例#18

 public void TestUnpackDouble_ByteArray_Offset_Null()
 {
     Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackDouble(default(byte[]), 0));
 }

示例#19

 public void TestUnpackDouble_ByteArray_Offset_OffsetIsTooBig()
 {
     Assert.Throws <ArgumentException>(() => Unpacking.UnpackDouble(new byte[] { 0x1 }, 1));
 }

示例#20

 public void TestUnpackDouble_ByteArray_NotDouble()
 {
     Assert.Throws <MessageTypeException>(() => Unpacking.UnpackDouble(new byte[] { 0xC3 }));
 }

示例#21

 public void TestUnpackDouble_ByteArray_Offset_Empty()
 {
     Assert.Throws <ArgumentException>(() => Unpacking.UnpackDouble(new byte[0], 0));
 }

示例#22

 public void TestUnpackDouble_Stream_Null()
 {
     Assert.Throws <ArgumentNullException>(() => Unpacking.UnpackDouble(default(Stream)));
 }