Exemple #1
0
        public void Test_ToByte()
        {
            var       converter = new DefaultConverter();
            var       actual    = converter.ToByte(_buffer, 0);
            const int expected  = 128;

            Assert.AreEqual(expected, actual);
        }
Exemple #2
0
        public void Test_ToByte(byte value)
        {
            var converter = new DefaultConverter();

            var bytes = new byte[] { 0, 0, value };

            var actual = converter.ToByte(bytes.AsSpan(2));

            Assert.Equal(value, actual);
        }
Exemple #3
0
        public void When_ByteArray_Is_Stored_With_Legacy_Flags_It_Is_Decoded_As_A_ByteArray()
        {
            var legacyByteArray = new byte[]
            {
                129, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 8, 0,
                0, 0, 5, 19, 185, 8, 248, 3, 104, 208, 188, 0,
                0, 250, 82, 116, 101, 115, 116
            };

            var converter = new DefaultConverter();
            var format    = new byte();

            var temp = converter.ToByte(legacyByteArray, 24);

            converter.SetBit(ref format, 0, converter.GetBit(temp, 0));
            converter.SetBit(ref format, 1, converter.GetBit(temp, 1));
            converter.SetBit(ref format, 2, converter.GetBit(temp, 2));
            converter.SetBit(ref format, 3, converter.GetBit(temp, 3));

            var compression = new byte();

            converter.SetBit(ref compression, 4, converter.GetBit(temp, 4));
            converter.SetBit(ref compression, 5, converter.GetBit(temp, 5));
            converter.SetBit(ref compression, 6, converter.GetBit(temp, 6));

            var flags = new Flags
            {
                DataFormat  = (DataFormat)format,
                Compression = (Compression)compression,
                TypeCode    = (TypeCode)(converter.ToUInt16(legacyByteArray, 26) & 0xff),
            };

            var transcoder = new DefaultTranscoder(new DefaultConverter());
            var result     = transcoder.Decode <byte[]>(legacyByteArray.AsMemory(28, 4), flags, OpCode.Get);

            Assert.Equal("test", Encoding.UTF8.GetString(result));
        }
        public void Test_ObserveSeqno_Parse_Packet()
        {
            var converter = new DefaultConverter();
            var packet    = new byte []
            {
                0x81,                                           //magic
                0x01,                                           //opcode
                0x00, 0x00,                                     //key length
                0x10,                                           //extra length
                0x00,                                           //data type
                0x00, 0x00,                                     //status
                0x00, 0x00, 0x00, 0x10,                         //total body
                0x00, 0x00, 0x00, 0x01,                         //opaque
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //cas
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x39, //uuid
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D  //seqno
            };
            var extras = new byte[converter.ToByte(packet, HeaderIndexFor.ExtrasLength)];
            var uuid   = converter.ToUInt64(packet, 24);
            var seqno  = converter.ToInt64(packet, 32);

            Assert.AreEqual(12345, uuid);
            Assert.AreEqual(45, seqno);
        }