Example #1
0
        public static void HalfToInt16Bits()
        {
            Half  input  = (Half)12.34;
            short result = BitConverter.HalfToInt16Bits(input);

            Assert.Equal((short)18988, result);
            Half roundtripped = BitConverter.Int16BitsToHalf(result);

            Assert.Equal(input, roundtripped);
        }
Example #2
0
        public static bool TryReadHalfLittleEndian(ReadOnlySpan <byte> source, out Half value)
        {
            if (!BitConverter.IsLittleEndian)
            {
                bool success = MemoryMarshal.TryRead(source, out short tmp);
                value = BitConverter.Int16BitsToHalf(ReverseEndianness(tmp));
                return(success);
            }

            return(MemoryMarshal.TryRead(source, out value));
        }
Example #3
0
 public virtual Half ReadHalf() => BitConverter.Int16BitsToHalf(BinaryPrimitives.ReadInt16LittleEndian(InternalRead(2)));
Example #4
0
 public static Half ReadHalfLittleEndian(ReadOnlySpan <byte> source)
 {
     return(!BitConverter.IsLittleEndian ?
            BitConverter.Int16BitsToHalf(ReverseEndianness(MemoryMarshal.Read <short>(source))) :
            MemoryMarshal.Read <Half>(source));
 }
Example #5
0
        public void SpanWrite()
        {
            Assert.True(BitConverter.IsLittleEndian);

            Span <byte> span = new byte[8];

            byte byteValue = 0x11;

            MemoryMarshal.Write <byte>(span, ref byteValue);
            TestHelpers.Validate <byte>(span, byteValue);
            Assert.True(MemoryMarshal.TryWrite <byte>(span, ref byteValue));
            TestHelpers.Validate <byte>(span, byteValue);

            sbyte sbyteValue = 0x11;

            MemoryMarshal.Write <sbyte>(span, ref sbyteValue);
            TestHelpers.Validate <sbyte>(span, sbyteValue);
            Assert.True(MemoryMarshal.TryWrite <sbyte>(span, ref sbyteValue));
            TestHelpers.Validate <sbyte>(span, sbyteValue);

            ushort ushortValue = 0x1122;

            MemoryMarshal.Write <ushort>(span, ref ushortValue);
            TestHelpers.Validate <ushort>(span, ushortValue);
            Assert.True(MemoryMarshal.TryWrite <ushort>(span, ref ushortValue));
            TestHelpers.Validate <ushort>(span, ushortValue);

            uint uintValue = 0x11223344;

            MemoryMarshal.Write <uint>(span, ref uintValue);
            TestHelpers.Validate <uint>(span, uintValue);
            Assert.True(MemoryMarshal.TryWrite <uint>(span, ref uintValue));
            TestHelpers.Validate <uint>(span, uintValue);

            ulong ulongValue = 0x1122334455667788;

            MemoryMarshal.Write <ulong>(span, ref ulongValue);
            TestHelpers.Validate <ulong>(span, ulongValue);
            Assert.True(MemoryMarshal.TryWrite <ulong>(span, ref ulongValue));
            TestHelpers.Validate <ulong>(span, ulongValue);

            short shortValue = 0x1122;

            MemoryMarshal.Write <short>(span, ref shortValue);
            TestHelpers.Validate <short>(span, shortValue);
            Assert.True(MemoryMarshal.TryWrite <short>(span, ref shortValue));
            TestHelpers.Validate <short>(span, shortValue);

            int intValue = 0x11223344;

            MemoryMarshal.Write <int>(span, ref intValue);
            TestHelpers.Validate <int>(span, intValue);
            Assert.True(MemoryMarshal.TryWrite <int>(span, ref intValue));
            TestHelpers.Validate <int>(span, intValue);

            long longValue = 0x1122334455667788;

            MemoryMarshal.Write <long>(span, ref longValue);
            TestHelpers.Validate <long>(span, longValue);
            Assert.True(MemoryMarshal.TryWrite <long>(span, ref longValue));
            TestHelpers.Validate <long>(span, longValue);

            Half halfValue = BitConverter.Int16BitsToHalf(0x1122);

            MemoryMarshal.Write <Half>(span, ref halfValue);
            TestHelpers.Validate <Half>(span, halfValue);
            Assert.True(MemoryMarshal.TryWrite <Half>(span, ref halfValue));
            TestHelpers.Validate <Half>(span, halfValue);

            float floatValue = BitConverter.Int32BitsToSingle(0x11223344);

            MemoryMarshal.Write <float>(span, ref floatValue);
            TestHelpers.Validate <float>(span, floatValue);
            Assert.True(MemoryMarshal.TryWrite <float>(span, ref floatValue));
            TestHelpers.Validate <float>(span, floatValue);

            double doubleValue = BitConverter.Int64BitsToDouble(0x1122334455667788);

            MemoryMarshal.Write <double>(span, ref doubleValue);
            TestHelpers.Validate <double>(span, doubleValue);
            Assert.True(MemoryMarshal.TryWrite <double>(span, ref doubleValue));
            TestHelpers.Validate <double>(span, doubleValue);
        }
Example #6
0
        public void SpanRead()
        {
            ulong value; // [11 22 33 44 55 66 77 88]

            if (BitConverter.IsLittleEndian)
            {
                value = 0x8877665544332211;
            }
            else
            {
                value = 0x1122334455667788;
            }
            Span <byte> span;

            unsafe
            {
                span = new Span <byte>(&value, 8);
            }

            Assert.Equal <byte>(0x11, MemoryMarshal.Read <byte>(span));
            Assert.True(MemoryMarshal.TryRead(span, out byte byteValue));
            Assert.Equal(0x11, byteValue);

            Assert.Equal <sbyte>(0x11, MemoryMarshal.Read <sbyte>(span));
            Assert.True(MemoryMarshal.TryRead(span, out byte sbyteValue));
            Assert.Equal(0x11, byteValue);

            Assert.Equal <ushort>(0x1122, ReadUInt16BigEndian(span));
            Assert.True(TryReadUInt16BigEndian(span, out ushort ushortValue));
            Assert.Equal(0x1122, ushortValue);

            Assert.Equal <ushort>(0x2211, ReadUInt16LittleEndian(span));
            Assert.True(TryReadUInt16LittleEndian(span, out ushortValue));
            Assert.Equal(0x2211, ushortValue);

            Assert.Equal <short>(0x1122, ReadInt16BigEndian(span));
            Assert.True(TryReadInt16BigEndian(span, out short shortValue));
            Assert.Equal(0x1122, shortValue);

            Assert.Equal <short>(0x2211, ReadInt16LittleEndian(span));
            Assert.True(TryReadInt16LittleEndian(span, out shortValue));
            Assert.Equal(0x2211, ushortValue);

            Assert.Equal <uint>(0x11223344, ReadUInt32BigEndian(span));
            Assert.True(TryReadUInt32BigEndian(span, out uint uintValue));
            Assert.Equal <uint>(0x11223344, uintValue);

            Assert.Equal <uint>(0x44332211, ReadUInt32LittleEndian(span));
            Assert.True(TryReadUInt32LittleEndian(span, out uintValue));
            Assert.Equal <uint>(0x44332211, uintValue);

            Assert.Equal <int>(0x11223344, ReadInt32BigEndian(span));
            Assert.True(TryReadInt32BigEndian(span, out int intValue));
            Assert.Equal <int>(0x11223344, intValue);

            Assert.Equal <int>(0x44332211, ReadInt32LittleEndian(span));
            Assert.True(TryReadInt32LittleEndian(span, out intValue));
            Assert.Equal <int>(0x44332211, intValue);

            Assert.Equal <ulong>(0x1122334455667788, ReadUInt64BigEndian(span));
            Assert.True(TryReadUInt64BigEndian(span, out ulong ulongValue));
            Assert.Equal <ulong>(0x1122334455667788, ulongValue);

            Assert.Equal <ulong>(0x8877665544332211, ReadUInt64LittleEndian(span));
            Assert.True(TryReadUInt64LittleEndian(span, out ulongValue));
            Assert.Equal <ulong>(0x8877665544332211, ulongValue);

            Assert.Equal <long>(0x1122334455667788, ReadInt64BigEndian(span));
            Assert.True(TryReadInt64BigEndian(span, out long longValue));
            Assert.Equal <long>(0x1122334455667788, longValue);

            Assert.Equal <long>(unchecked ((long)0x8877665544332211), ReadInt64LittleEndian(span));
            Assert.True(TryReadInt64LittleEndian(span, out longValue));
            Assert.Equal <long>(unchecked ((long)0x8877665544332211), longValue);

            Half expectedHalf = BitConverter.Int16BitsToHalf(0x1122);

            Assert.Equal <Half>(expectedHalf, ReadHalfBigEndian(span));
            Assert.True(TryReadHalfBigEndian(span, out Half halfValue));
            Assert.Equal <Half>(expectedHalf, halfValue);

            expectedHalf = BitConverter.Int16BitsToHalf(0x2211);
            Assert.Equal <Half>(expectedHalf, ReadHalfLittleEndian(span));
            Assert.True(TryReadHalfLittleEndian(span, out halfValue));
            Assert.Equal <Half>(expectedHalf, halfValue);

            float expectedFloat = BitConverter.Int32BitsToSingle(0x11223344);

            Assert.Equal <float>(expectedFloat, ReadSingleBigEndian(span));
            Assert.True(TryReadSingleBigEndian(span, out float floatValue));
            Assert.Equal <float>(expectedFloat, floatValue);

            expectedFloat = BitConverter.Int32BitsToSingle(0x44332211);
            Assert.Equal <float>(expectedFloat, ReadSingleLittleEndian(span));
            Assert.True(TryReadSingleLittleEndian(span, out floatValue));
            Assert.Equal <float>(expectedFloat, floatValue);

            double expectedDouble = BitConverter.Int64BitsToDouble(0x1122334455667788);

            Assert.Equal <double>(expectedDouble, ReadDoubleBigEndian(span));
            Assert.True(TryReadDoubleBigEndian(span, out double doubleValue));
            Assert.Equal <double>(expectedDouble, doubleValue);

            expectedDouble = BitConverter.Int64BitsToDouble(unchecked ((long)0x8877665544332211));
            Assert.Equal <double>(expectedDouble, ReadDoubleLittleEndian(span));
            Assert.True(TryReadDoubleLittleEndian(span, out doubleValue));
            Assert.Equal <double>(expectedDouble, doubleValue);
        }