Пример #1
0
        public unsafe void MixedWrite()
        {
            byte[] data = new byte[256];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
                writer.Write((byte)66);
                writer.Write(0x48484848);
                writer.Write(0x84848484U);
                writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
            }

            using (MemoryStream ms = new MemoryStream(data))
                using (BinaryReader reader = new BinaryReader(ms))
                {
                    Assert.AreEqual(reader.ReadString(), "abcABCäöüÄÖÜßáÁàÀ♥♦♣♠", "BinaryMemoryReader String incompatible to BinaryReader.");
                    Assert.AreEqual(reader.ReadByte(), (byte)66, "BinaryMemoryReader Byte incompatible to BinaryReader.");
                    Assert.AreEqual(reader.ReadInt32(), 0x48484848, "BinaryMemoryReader Int incompatible to BinaryReader.");
                    Assert.AreEqual(reader.ReadUInt32(), 0x84848484U, "BinaryMemoryReader UInt incompatible to BinaryReader.");
                    Assert.AreEqual(reader.ReadString(), "abcABCäöüÄÖÜßáÁàÀ♥♦♣♠", "BinaryMemoryReader 2nd String incompatible to BinaryReader.");
                }
        }
Пример #2
0
        public unsafe void UnsafeBinaryMemoryWriter_Initialize()
        {
            byte[] data = new byte[1];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                writer.Write((byte)0x5A);
            }
        }
Пример #3
0
        public unsafe void UnsafeBinaryMemoryWriter_Strings()
        {
            byte[] data = new byte[102400];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 10240; count++)
                {
                    writer.Write("ABCDEFGHI");
                }
            }
        }
Пример #4
0
        public unsafe void UnsafeBinaryMemoryWriter_Short()
        {
            byte[] data = new byte[20480];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 10240; count++)
                {
                    writer.Write((short)0x5AA5);
                }
            }
        }
Пример #5
0
        public unsafe void UnsafeBinaryMemoryWriter_Bytes()
        {
            byte[] data = new byte[10240];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 10240; count++)
                {
                    writer.Write((byte)0x5A);
                }
            }
        }
Пример #6
0
        public unsafe void StringWrite()
        {
            foreach (int size in new int[] { 1, 127, 128, 16383, 16384, 2097151, 2097152, 268435455, 268435456, 300000000 })
            {
                byte[] data = new byte[size + 8];

                fixed(byte *pData = data)
                {
                    UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                    writer.Write(new string('A', size));
                }

                using (MemoryStream ms = new MemoryStream(data))
                    using (BinaryReader reader = new BinaryReader(ms))
                        Assert.AreEqual(reader.ReadString(), new string('A', size), "UnsafeBinaryMemoryWriter String incompatible to BinaryWriter.");
            }
        }
Пример #7
0
        public unsafe void SevenBitEncoded()
        {
            byte[] data;

            List <KeyValuePair <ulong, int> > pairs = new List <KeyValuePair <ulong, int> >();

            pairs.Add(new KeyValuePair <ulong, int>(0L, 1));

            for (int d = 1; d < 10; d++)
            {
                pairs.Add(new KeyValuePair <ulong, int>((1UL << (d * 7)) - 1, d));
                pairs.Add(new KeyValuePair <ulong, int>(1UL << (d * 7), d + 1));
            }

            pairs.Add(new KeyValuePair <ulong, int>(ulong.MaxValue, 10));

            foreach (KeyValuePair <ulong, int> pair in pairs)
            {
                data = new byte[pair.Value * 3];

                fixed(byte *pData = data)
                {
                    UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                    writer.Write7BitEncoded(pair.Key);
                    writer.Write7BitEncoded(pair.Key);
                    writer.Write7BitEncoded(pair.Key);

                    UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);

                    try
                    {
                        Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
                        Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
                        Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
                    }
                    catch
                    {
                        Assert.Fail($"Should not have thrown an Exception, but did with {pair.Key}.");
                    }
                }
            }
        }
Пример #8
0
        public unsafe void DecimalWrite()
        {
            byte[] data = new byte[4096];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 256; count++)
                {
                    writer.Write(count * 12347822345.34m);
                }
            }

            using (MemoryStream ms = new MemoryStream(data))
                using (BinaryReader reader = new BinaryReader(ms))
                    for (int count = 0; count < 256; count++)
                    {
                        Assert.AreEqual(reader.ReadDecimal(), count * 12347822345.34m, "UnsafeBinaryMemoryWriter Decimal incompatible to BinaryWriter.");
                    }
        }
Пример #9
0
        public unsafe void DoubleWrite()
        {
            byte[] data = new byte[2048];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 256; count++)
                {
                    writer.Write((double)count);
                }
            }

            using (MemoryStream ms = new MemoryStream(data))
                using (BinaryReader reader = new BinaryReader(ms))
                    for (int count = 0; count < 256; count++)
                    {
                        Assert.AreEqual(reader.ReadDouble(), count, "UnsafeBinaryMemoryWriter Double incompatible to BinaryWriter.");
                    }
        }
Пример #10
0
        public unsafe void UIntWrite()
        {
            byte[] data = new byte[1024];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 256; count++)
                {
                    writer.Write((uint)count);
                }
            }

            using (MemoryStream ms = new MemoryStream(data))
                using (BinaryReader reader = new BinaryReader(ms))
                    for (int count = 0; count < 256; count++)
                    {
                        Assert.AreEqual(reader.ReadUInt32(), (uint)count, "UnsafeBinaryMemoryWriter UInt incompatible to BinaryWriter.");
                    }
        }
Пример #11
0
        public unsafe void BooleanWrite()
        {
            byte[] data = new byte[256];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 256; count++)
                {
                    writer.Write(count % 2 == 0);
                }
            }

            using (MemoryStream ms = new MemoryStream(data))
                using (BinaryReader reader = new BinaryReader(ms))
                    for (int count = 0; count < 256; count++)
                    {
                        Assert.AreEqual(reader.ReadBoolean(), count % 2 == 0, "UnsafeBinaryMemoryWriter Boolean incompatible to BinaryWriter.");
                    }
        }
Пример #12
0
        public unsafe void BytesWrite()
        {
            Random rng = new Random();

            byte[] src = new byte[1024];
            byte[] chk;

            rng.NextBytes(src);

            byte[] data = new byte[262144];

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                for (int count = 0; count < 256; count++)
                {
                    writer.WriteBytes(src, 0, 1024);
                }
            }

            using (MemoryStream ms = new MemoryStream(data))
            {
                using (BinaryReader reader = new BinaryReader(ms))
                    for (int count = 0; count < 256; count++)
                    {
                        chk = reader.ReadBytes(1024);

                        for (int position = 0; position < 1024; position++)
                        {
                            Assert.AreEqual(chk[position], src[position], $"Invalid content at position {position}.");
                        }
                    }

                data = ms.ToArray();
            }
        }
Пример #13
0
        public unsafe void CompressedTimeSpanRead()
        {
            int required = 0;

            List <long> timeLongs = new List <long>()
            {
                //Limits 1 Byte -> 3 Byte
                0, 1, -1, 0x1F, -0x1F, 0x20, -0x20,

                0xFF_FF, -0xFF_FF, 0x01_00_00, -0x01_00_00,

                //Limits 3 Byte -> 5 Byte
                0x1F_FF_FF, -0x1F_FF_FF, 0x20_00_00, -0x20_00_00,

                0x01_00_00_00, -0x01_00_00_00,
                0xFF_FF_FF_FF, -0xFF_FF_FF_FF,
                0x01_00_00_00_00, -0x01_00_00_00_00,
                0x01_01_00_00_00, -0x01_01_00_00_00,
                0x01_00_01_00_00, -0x01_00_01_00_00,
                0x01_00_00_01_00, -0x01_00_00_01_00,
                0x01_00_00_00_01, -0x01_00_00_00_01,

                //Limits 5 Byte -> 8 Byte
                0x1F_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF, 0x20_00_00_00_00, -0x20_00_00_00_00,

                0x01_00_00_00_00, -0x01_00_00_00_00,
                0xFF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF,
                0xFF_00_FF_FF_FF, -0xFF_00_FF_FF_FF,
                0xFF_FF_00_FF_FF, -0xFF_FF_00_FF_FF,
                0xFF_FF_FF_00_FF, -0xFF_FF_FF_00_FF,
                0xFF_FF_FF_FF_00, -0xFF_FF_FF_FF_00,
                0x01_00_00_00_00_00, -0x01_00_00_00_00_00,
                0x01_00_00_01_00_00, -0x01_00_00_01_00_00,
                0x01_00_00_00_01_00, -0x01_00_00_00_01_00,
                0x01_00_00_00_00_01, -0x01_00_00_00_00_01,
                0xFF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF,
                0x01_00_00_00_00_00_00, -0x01_00_00_00_00_00_00,
                0x01_00_00_00_00_01_00, -0x01_00_00_00_00_01_00,
                0x01_00_00_00_00_00_01, -0x01_00_00_00_00_00_01,
                0xFF_FF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF_FF,
                0x01_00_00_00_00_00_00_00, -0x01_00_00_00_00_00_00_00,
                0x01_00_00_00_00_00_01_00, -0x01_00_00_00_00_00_01_00,
                0x01_00_00_00_00_00_00_01, -0x01_00_00_00_00_00_00_01,

                //Limits -> 8 Byte
                0x1F_FF_FF_FF_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF_FF_FF_FF
            };

            foreach (long timeLong in timeLongs)
            {
                long checkLong = timeLong;
                if (checkLong < 0)
                {
                    checkLong = -checkLong;
                }

                if (checkLong >= 137438953472)
                {
                    required += 8;
                }
                else if (checkLong >= 2097152)
                {
                    required += 5;
                }
                else if (checkLong >= 32)
                {
                    required += 3;
                }
                else
                {
                    required += 1;
                }
            }

            byte[] data = new byte[required];

            List <TimeSpan> timeSpans = new List <TimeSpan>();

            foreach (long timeLong in timeLongs)
                timeSpans.Add(new TimeSpan(timeLong));

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);

                foreach (TimeSpan timeSpan in timeSpans)
                {
                    writer.WriteCompressed(timeSpan);
                }
            }

            fixed(byte *pData = data)
            {
                UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);

                foreach (TimeSpan timeSpan in timeSpans)
                {
                    Assert.AreEqual(timeSpan, reader.ReadCompressedTimeSpan(), "UnsafeBinaryMemoryReader TimeSpan Compressed incompatible to UnsafeBinaryMemoryWriter.");
                }
            }
        }