public void WireEncoderWrite32()
        {
            int         off = BUFSIZE - 4;
            WireEncoder e   = new WireEncoder(0x0300);

            for (int i = 0; i < off; i++)
            {
                e.Write8(0);
            }
            e.Write32(5);
            e.Write32(1);
            e.Write32(0xabcd);
            e.Write32(0x12345678);
            e.Write32(0);

            Assert.That(e.Buffer.Length - off, Is.EqualTo(20));
            byte[] checkArray  = { 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xab, 0xcd, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00 };
            byte[] bufferArray = new byte[checkArray.Length];
            Array.Copy(e.Buffer, off, bufferArray, 0, checkArray.Length);
            Assert.That(bufferArray, Is.EquivalentTo(checkArray));
        }
Beispiel #2
0
        public void Write(WireEncoder encoder)
        {
            switch (Type)
            {
            case MsgType.KeepAlive:
                encoder.Write8((byte)MsgType.KeepAlive);
                break;

            case MsgType.ClientHello:
                encoder.Write8((byte)MsgType.ClientHello);
                encoder.Write16((ushort)encoder.ProtoRev);
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;
                }
                encoder.WriteString(m_str);
                break;

            case MsgType.ProtoUnsup:
                encoder.Write8((byte)MsgType.ProtoUnsup);
                encoder.Write16((ushort)encoder.ProtoRev);
                break;

            case MsgType.ServerHelloDone:
                encoder.Write8((byte)MsgType.ServerHelloDone);
                break;

            case MsgType.ServerHello:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.ServerHello);
                encoder.Write8((byte)Flags);
                encoder.WriteString(m_str);
                break;

            case MsgType.ClientHelloDone:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.ClientHelloDone);
                break;

            case MsgType.EntryAssign:
                encoder.Write8((byte)MsgType.EntryAssign);
                encoder.WriteString(m_str);
                encoder.WriteType(Val.Type);
                encoder.Write16((ushort)Id);
                encoder.Write16((ushort)SeqNumUid);
                if (encoder.ProtoRev >= 0x0300u)
                {
                    encoder.Write8((byte)Flags);
                }
                encoder.WriteValue(Val);
                break;

            case MsgType.EntryUpdate:
                encoder.Write8((byte)MsgType.EntryUpdate);
                encoder.Write16((ushort)Id);
                encoder.Write16((ushort)SeqNumUid);
                if (encoder.ProtoRev >= 0x0300u)
                {
                    encoder.WriteType(Val.Type);
                }
                encoder.WriteValue(Val);
                break;

            case MsgType.FlagsUpdate:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.FlagsUpdate);
                encoder.Write16((ushort)Id);
                encoder.Write8((byte)Flags);
                break;

            case MsgType.EntryDelete:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.EntryDelete);
                encoder.Write16((ushort)Id);
                break;

            case MsgType.ClearEntries:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.ClearEntries);
                encoder.Write32(ClearAllMagic);
                break;

            case MsgType.ExecuteRpc:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.ExecuteRpc);
                encoder.Write16((ushort)Id);
                encoder.Write16((ushort)SeqNumUid);
                encoder.WriteValue(Val);
                break;

            case MsgType.RpcResponse:
                if (encoder.ProtoRev < 0x0300u)
                {
                    return;                                  // new message in version 3.0
                }
                encoder.Write8((byte)MsgType.RpcResponse);
                encoder.Write16((ushort)Id);
                encoder.Write16((ushort)SeqNumUid);
                encoder.WriteValue(Val);
                break;
            }
        }