public void TestStringValue()
        {
            byte[] rawData = new byte[]
            {
                0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o',
                0x03, (byte)'b', (byte)'y', (byte)'e', 0x55,
            };
            WireDecoder d = new WireDecoder(rawData);
            var val = d.ReadValue(NtType.String);
            Assert.That(val.Type, Is.EqualTo(NtType.String));
            Assert.That(val.Value, Is.EqualTo(v_string.Value));

            var vFalse = RpcValue.MakeString("bye");
            val = d.ReadValue(NtType.String);
            Assert.That(val.Type, Is.EqualTo(NtType.String));
            Assert.That(val.Value, Is.EqualTo(vFalse.Value));

            byte b = 0;
            Assert.That(d.Read8(ref b));
            Assert.That(b, Is.EqualTo(0x55));

            Assert.That(d.ReadValue(NtType.String), Is.Null);
            Assert.That(d.Error, Is.Null);
        }
        public void TestReadStringArray()
        {
            List<byte> b = new List<byte>()
            {
                0x02,
                0x05
            };
            b.AddRange(Encoding.UTF8.GetBytes("hello"));
            b.Add(0x07);
            b.AddRange(Encoding.UTF8.GetBytes("goodbye"));
            b.Add(0x55);
            WireDecoder d = new WireDecoder(b.ToArray());

            var val = d.ReadValue(NtType.StringArray);
            Assert.That(val.Type, Is.EqualTo(NtType.StringArray));
            Assert.That(val.Value, Is.EqualTo(v_stringArray.Value));

            byte by = 0;
            Assert.That(d.Read8(ref by));
            Assert.That(by, Is.EqualTo(0x55));

            Assert.That(d.ReadValue(NtType.StringArray), Is.Null);
            Assert.That(d.Error, Is.Null);
        }
        public void TestReadDoubleArray()
        {
            byte[] b =
            {
                0x02, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55
            };
            WireDecoder d = new WireDecoder(b);

            var val = d.ReadValue(NtType.DoubleArray);
            Assert.That(val.Type, Is.EqualTo(NtType.DoubleArray));
            Assert.That(val.Value, Is.EqualTo(v_doubleArray.Value));

            byte by = 0;
            Assert.That(d.Read8(ref by));
            Assert.That(by, Is.EqualTo(0x55));

            Assert.That(d.ReadValue(NtType.DoubleArray), Is.Null);
            Assert.That(d.Error, Is.Null);
        }
        public void TestReadString()
        {
            byte[] sNormalBytes = Encoding.UTF8.GetBytes(s_normal);
            byte[] sLongBytes = Encoding.UTF8.GetBytes(s_long);
            byte[] sBigBytes = Encoding.UTF8.GetBytes(s_big);
            List<byte> s = new List<byte>();
            s.Add(0x05);
            s.AddRange(sNormalBytes);
            s.AddRange(new byte[] { 0x80, 0x01 });
            s.AddRange(sLongBytes);
            s.AddRange(new byte[] { 0x81, 0x80, 0x04 });
            s.AddRange(sBigBytes);
            s.Add(0x55);

            WireDecoder d = new WireDecoder(s.ToArray());

            string outs = null;
            Assert.That(d.ReadString(ref outs));
            Assert.That(outs, Is.EquivalentTo(s_normal));

            Assert.That(d.ReadString(ref outs));
            Assert.That(outs, Is.EquivalentTo(s_long));

            Assert.That(d.ReadString(ref outs));
            Assert.That(outs, Is.EquivalentTo(s_big));

            byte b = 0;
            Assert.That(d.Read8(ref b));
            Assert.That(b, Is.EqualTo(0x55));

            Assert.That(d.ReadString(ref outs), Is.False);
            Assert.That(d.Error, Is.Null);
        }
        public void TestRead8()
        {
            byte[] rawData = { 0x05, 0x01, 0x00 };
            WireDecoder d = new WireDecoder(rawData);
            byte val = 0;
            Assert.That(d.Read8(ref val));
            Assert.That(val, Is.EqualTo(5));

            Assert.That(d.Read8(ref val));
            Assert.That(val, Is.EqualTo(1));

            Assert.That(d.Read8(ref val));
            Assert.That(val, Is.EqualTo(0));

            Assert.That(!d.Read8(ref val));

            Assert.That(d.Error, Is.Null);
        }