コード例 #1
0
        public void TestDecodeMessageWithAllFieldTypes()
        {
            //               --PMAP-- --TID--- ---#1--- -------#2-------- ------------#3------------ ---#4--- ------------#5------------ ---#6---
            const string msgstr = "11111111 11110001 11001000 10000001 11111111 11111101 00001001 10110001 11111111 01100001 01100010 11100011 10000010";
            Stream input = ByteUtil.CreateByteStream(msgstr);

            var template = new MessageTemplate("",
                    new Field[] {
                    new Scalar("1", FASTType.ASCII, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("2", FASTType.BYTE_VECTOR, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("3", FASTType.DECIMAL, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("4", FASTType.I32, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("5", FASTType.ASCII, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("6", FASTType.U32, Operator.COPY, ScalarValue.UNDEFINED, false),
                });
            var context = new Context();
            context.RegisterTemplate(113, template);

            GroupValue message = new Message(template);
            message.SetString(1, "H");
            message.SetByteVector(2, new[] { (byte)0xFF });
            message.SetDecimal(3, 1.201);
            message.SetInteger(4, -1);
            message.SetString(5, "abc");
            message.SetInteger(6, 2);
            Assert.AreEqual(message, new FastDecoder(context, input).ReadMessage());
        }
コード例 #2
0
        public void TestEncodeMessageWithAllFieldTypes()
        {
            var template = new MessageTemplate("",
                    new Field[] {
                    new Scalar("1", FASTType.STRING, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("2", FASTType.BYTE_VECTOR, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("3", FASTType.DECIMAL, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("4", FASTType.I32, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("5", FASTType.STRING, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("6", FASTType.U32, Operator.COPY, ScalarValue.UNDEFINED, false),
                });
            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetString(1, "H");
            message.SetByteVector(2, new[] { (byte)0xFF });
            message.SetDecimal(3, 1.201);
            message.SetInteger(4, -1);
            message.SetString(5, "abc");
            message.SetInteger(6, 2);

            //               --PMAP-- --TID--- ---#1--- -------#2-------- ------------#3------------ ---#4--- ------------#5------------ ---#6---
            const string msgstr = "11111111 11110001 11001000 10000001 11111111 11111101 00001001 10110001 11111111 01100001 01100010 11100011 10000010";
            AssertEquals(msgstr, new FastEncoder(context).Encode(message));
        }
コード例 #3
0
        public void TestDictionaryNotInherited()
        {
            const string templateDef = "<template name=\"OptDeltaDec\" id=\"58\" dictionary=\"template\">" +
                                   "    <string name=\"desc\"/>" +
                                   "    <decimal id=\"1\" presence=\"optional\" name=\"Line1\">" +
                                   "         <exponent><copy/></exponent>" +
                                   "         <mantissa><copy/></mantissa>" +
                                   "    </decimal>" +
                                   "    <decimal id=\"1\" presence=\"optional\" name=\"Line2\">" +
                                   "         <exponent><copy/></exponent>" +
                                   "         <mantissa><copy/></mantissa>" +
                                   "    </decimal>    " +
                                   "    <decimal id=\"1\" presence=\"optional\" name=\"Line3\">" +
                                   "         <exponent><copy/></exponent> " +
                                   "         <mantissa><copy/></mantissa>" +
                                   "    </decimal>" +
                                   "</template>";

            MessageTemplate template = Template(templateDef);

            var m = new Message(template);

            m.SetString("desc", "prev");
            m.SetDecimal("Line2", 9427.61 );
            m.SetDecimal("Line3", 9427.6 );

            byte[] bytes = Encoder(template).Encode(m);
            Message m2 = Decoder(template, bytes).ReadMessage();

            Assert.AreEqual(m, m2);
        }
コード例 #4
0
        public void TestConversions()
        {
            MessageTemplate template = Template(
                    "<template>" +
                    "  <string name=\"string\"/>" +
                    "  <uInt32 name=\"uint\"/>" +
                    "  <int8 name=\"byte\"/>" +
                    "  <int16 name=\"short\"/>" +
                    "  <int64 name=\"long\"/>" +
                    "  <byteVector name=\"bytevector\"/>" +
                    "  <decimal name=\"decimal\"/>" +
                    "</template>");

            var message = new Message(template);
            message.SetByteVector("string", byt("7f001a"));
            message.SetDecimal("uint", 150.0);
            message.SetString("byte", "4");
            message.SetString("short", "-5");
            message.SetString("long", "1000000000000000000");
            message.SetString("bytevector", "abcd");
            message.SetString("decimal", "2.3");

            FastEncoder encoder = Encoder(template);

            byte[] encoding = encoder.Encode(message);

            FastDecoder decoder = Decoder(template, encoding);
            Message decodedMessage = decoder.ReadMessage();

            Assert.AreEqual("7f001a", decodedMessage.GetString("string"));
            Assert.AreEqual(150, decodedMessage.GetInt("uint"));
            Assert.AreEqual(150, decodedMessage.GetShort("uint"));
            Assert.AreEqual(4, decodedMessage.GetByte("byte"));
            Assert.AreEqual(-5, decodedMessage.GetShort("short"));
            Assert.AreEqual(1000000000000000000L, decodedMessage.GetLong("long"));
            Assert.AreEqual("61626364", decodedMessage.GetString("bytevector"));
        }
コード例 #5
0
        public void TestTailOperatorWithOptionalField()
        {
            var field = new Scalar("", FASTType.STRING, Operator.TAIL,
                    new StringValue("abc"), true);
            MessageTemplate template = registerTemplate(field);

            var msg1 = new Message(template);
            msg1.SetString(1, "abc");

            var msg2 = new Message(template);
            msg2.SetString(1, "abd");

            var msg3 = new Message(template);

            var msg4 = new Message(template);
            msg4.SetString(1, "dbef");

            //                     --PMAP-- --TID---
            encodeAndAssertEquals("11000000 11110001", msg1);

            //                     --PMAP-- ---#1---
            encodeAndAssertEquals("10100000 11100100", msg2);

            //                     --PMAP-- ---#1---
            encodeAndAssertEquals("10100000 10000000", msg3);

            //                     --PMAP-- -----------------#1----------------
            encodeAndAssertEquals("10100000 01100100 01100010 01100101 11100110",
                msg4);

            readMessageAndAssertEquals(msg1);
            readMessageAndAssertEquals(msg2);
            readMessageAndAssertEquals(msg3);
            readMessageAndAssertEquals(msg4);
        }
コード例 #6
0
        public void testDecodeMessageWithStringFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate("",
                    new Field[] {
                    new Scalar("1", FASTType.ASCII, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("2", FASTType.ASCII, Operator.DELTA, ScalarValue.UNDEFINED, false),
                    new Scalar("3", FASTType.ASCII, Operator.CONSTANT,
                        new StringValue("e"), false), /* NON-TRANSFERRABLE */
                new Scalar("4", FASTType.ASCII, Operator.DEFAULT,
                        new StringValue("long"), false)
                });

            var message = new Message(template);
            message.SetString(1, "on");
            message.SetString(2, "DCB32");
            message.SetString(3, "e");
            message.SetString(4, "long");

            //             --PMAP-- --TID--- --------#1------- ---------------------#2---------------------
            const string msg1 = "11100000 11110001 01101111 11101110 10000000 01000100 01000011 01000010 00110011 10110010";

            //             --PMAP-- ------------#2------------ ---------------------#4---------------------
            const string msg2 = "10010000 10000010 00110001 10110110 01110011 01101000 01101111 01110010 11110100";

            Stream input = ByteUtil.CreateByteStream(msg1 + ' ' + msg2);
            var context = new Context();
            context.RegisterTemplate(113, template);

            var decoder = new FastDecoder(context, input);

            Message readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);

            message.SetString(2, "DCB16");
            message.SetString(4, "short");

            readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);
        }
コード例 #7
0
        public void TestEncodeMessageWithStringFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate("",
                    new Field[] {
                    new Scalar("1", FASTType.STRING, Operator.COPY, ScalarValue.UNDEFINED, false),
                    new Scalar("2", FASTType.STRING, Operator.DELTA, ScalarValue.UNDEFINED, false),
                    new Scalar("3", FASTType.STRING, Operator.CONSTANT, new StringValue("e"), false), /* NON-TRANSFERRABLE */
                    new Scalar("4", FASTType.STRING, Operator.DEFAULT, new StringValue("long"), false)
                });
            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetString(1, "on");
            message.SetString(2, "DCB32");
            message.SetString(3, "e");
            message.SetString(4, "long");

            //             --PMAP-- --TID--- --------#1------- ---------------------#2------------------------------
            const string msg1 = "11100000 11110001 01101111 11101110 10000000 01000100 01000011 01000010 00110011 10110010";

            //             --PMAP-- --------#2---------------- ---------------------#4---------------------
            const string msg2 = "10010000 10000010 00110001 10110110 01110011 01101000 01101111 01110010 11110100";

            var encoder = new FastEncoder(context);

            AssertEquals(msg1, encoder.Encode(message));

            message.SetString(2, "DCB16");
            message.SetString(4, "short");

            AssertEquals(msg2, encoder.Encode(message));
        }