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));
}
public void TestEncode()
{
var encoder = new FastEncoder(_context);
// --PMAP-- --TID--- ---#1--- --PMAP-- --TID--- ------------#1------------ ------------#3------------
TestUtil.AssertBitVectorEquals(
"11000000 10000001 10001111 11000000 10000010 01001001 01000010 11001101 10000000 00000000 11100110",
encoder.Encode(_message));
}
public void SetUp()
{
_output = new PipedStream();
_input = new PipedStream(_output);
_encodingContext = new Context();
_decodingContext = new Context();
_encoder = new FastEncoder(_encodingContext);
_decoder = new FastDecoder(_decodingContext, _input);
}
public void SetUp()
{
output = new PipedStream();
input = new PipedStream(output);
encodingContext = new Context();
decodingContext = new Context();
encoder = new FastEncoder(encodingContext);
decoder = new FastDecoder(decodingContext, input);
}
public void TestEncodeMessageWithUnsignedIntegerFieldTypesAndAllOperators()
{
var template = new MessageTemplate(
"",
new Field[]
{
new Scalar("1", FastType.U32, Operator.Copy, ScalarValue.Undefined, false),
new Scalar("2", FastType.U32, Operator.Delta, ScalarValue.Undefined, false),
new Scalar("3", FastType.I32, Operator.Increment, new IntegerValue(10), false),
new Scalar("4", FastType.I32, Operator.Increment, ScalarValue.Undefined, false),
new Scalar("5", FastType.I32, Operator.Constant, new IntegerValue(1), false),
/* NON-TRANSFERRABLE */
new Scalar("6", FastType.I32, Operator.Default, new IntegerValue(2), false)
});
var context = new Context();
context.RegisterTemplate(113, template);
var encoder = new FastEncoder(context);
var message = new Message(template);
message.SetInteger(1, 109);
message.SetInteger(2, 29470);
message.SetInteger(3, 10);
message.SetInteger(4, 3);
message.SetInteger(5, 1);
message.SetInteger(6, 2);
// --PMAP-- --TID--- ---#1--- ------------#2------------ ---#4---
const string msg1 = "11101000 11110001 11101101 00000001 01100110 10011110 10000011";
AssertEquals(msg1, encoder.Encode(message));
message.SetInteger(2, 29471);
message.SetInteger(3, 11);
message.SetInteger(4, 4);
message.SetInteger(6, 3);
// --PMAP-- ---#2--- ---#6---
const string msg2 = "10000100 10000001 10000011";
AssertEquals(msg2, encoder.Encode(message));
message.SetInteger(1, 96);
message.SetInteger(2, 30500);
message.SetInteger(3, 12);
message.SetInteger(4, 1);
// --PMAP-- ---#1--- --------#2------- ---#4--- ---#6---
const string msg3 = "10101100 11100000 00001000 10000101 10000001 10000011";
AssertEquals(msg3, encoder.Encode(message));
}
public void TestNullsNoInitialValue()
{
var field = new Scalar(new QName("mostlyNull"), FastType.I32, Operator.Default, ScalarValue.Undefined, true);
MessageTemplate template = Template(field);
FastEncoder encoder = Encoder(template);
var message = (Message)template.CreateValue(null);
TestUtil.AssertBitVectorEquals("11000000 10000001", encoder.Encode(message));
TestUtil.AssertBitVectorEquals("10000000", encoder.Encode(message));
}
public void TestEncodeEmptyMessage()
{
var messageTemplate = new MessageTemplate("", new Field[0]);
var message = new Message(messageTemplate);
var context = new Context();
context.RegisterTemplate(113, messageTemplate);
byte[] encoding = new FastEncoder(context).Encode(message);
AssertEquals("11000000 11110001", encoding);
}
public void TestNullsWithInitialValue()
{
var field = new Scalar(new QName("sometimesNull"), FastType.I32, Operator.Default, new IntegerValue(10), true);
MessageTemplate template = Template(field);
FastEncoder encoder = Encoder(template);
var message = (Message)template.CreateValue(null);
TestUtil.AssertBitVectorEquals("11100000 10000001 10000000", encoder.Encode(message));
TestUtil.AssertBitVectorEquals("10100000 10000000", encoder.Encode(message));
message.SetInteger(1, 10);
TestUtil.AssertBitVectorEquals("10000000", encoder.Encode(message));
}
public void TestEncodeMessageWithSignedIntegerFieldTypesAndAllOperators()
{
var template = new MessageTemplate("",
new Field[] {
new Scalar("1", FASTType.I32, Operator.COPY, ScalarValue.UNDEFINED, false),
new Scalar("2", FASTType.I32, Operator.DELTA, ScalarValue.UNDEFINED, false),
new Scalar("3", FASTType.I32, Operator.INCREMENT, new IntegerValue(10), false),
new Scalar("4", FASTType.I32, Operator.INCREMENT, ScalarValue.UNDEFINED, false),
new Scalar("5", FASTType.I32, Operator.CONSTANT, new IntegerValue(1), false), /* NON-TRANSFERRABLE */
new Scalar("6", FASTType.I32, Operator.DEFAULT, new IntegerValue(2), false)
});
var context = new Context();
context.RegisterTemplate(113, template);
var encoder = new FastEncoder(context);
var message = new Message(template);
message.SetInteger(1, 109);
message.SetInteger(2, 29470);
message.SetInteger(3, 10);
message.SetInteger(4, 3);
message.SetInteger(5, 1);
message.SetInteger(6, 2);
// --PMAP-- --TID--- --------#1------- ------------#2------------ ---#4---
const string msg1 = "11101000 11110001 00000000 11101101 00000001 01100110 10011110 10000011";
TestUtil.AssertBitVectorEquals(msg1, encoder.Encode(message));
message.SetInteger(2, 29469);
message.SetInteger(3, 11);
message.SetInteger(4, 4);
message.SetInteger(6, 3);
// --PMAP-- ---#2--- ---#6---
const string msg2 = "10000100 11111111 10000011";
TestUtil.AssertBitVectorEquals(msg2, encoder.Encode(message));
message.SetInteger(1, 96);
message.SetInteger(2, 30500);
message.SetInteger(3, 12);
message.SetInteger(4, 1);
// --PMAP-- --------#1------- --------#2------- ---#4--- ---#6---
const string msg3 = "10101100 00000000 11100000 00001000 10000111 10000001 10000011";
AssertEquals(msg3, encoder.Encode(message));
}
public void TestEncodeDecodeNestedSequence()
{
var nestedSequence = new Sequence("nested", new Field[] { new Scalar("string", FASTType.ASCII, Operator.COPY, ScalarValue.UNDEFINED, false) }, true);
var group = new Group("group", new Field[] { nestedSequence }, true);
var t = new MessageTemplate("template", new Field[] { group });
var message = new Message(t);
FastEncoder encoder = Encoder(t);
AssertEquals("11000000 10000001", encoder.Encode(message));
FastDecoder decoder = Decoder("11000000 10000001", t);
Assert.AreEqual(message, decoder.ReadMessage());
}
public void TestEncodeSequentialEmptyMessages()
{
var messageTemplate = new MessageTemplate("", new Field[0]);
var message = new Message(messageTemplate);
var nextMsg = new Message(messageTemplate);
var context = new Context();
context.RegisterTemplate(113, messageTemplate);
var encoder = new FastEncoder(context);
// Presence map should show that the only field present is the template id.
AssertEquals("11000000 11110001",
encoder.Encode(message));
// Presence map should be empty (except for leading stop bit)
AssertEquals("10000000", encoder.Encode(nextMsg));
}
public void TestEncodeSimpleMessage()
{
var template = new MessageTemplate("",
new Field[] {
new Scalar("1", FASTType.U32, Operator.COPY, ScalarValue.UNDEFINED, false)
});
var context = new Context();
context.RegisterTemplate(113, template);
var message = new Message(template);
message.SetInteger(1, 1);
var encoder = new FastEncoder(context);
AssertEquals("11100000 11110001 10000001", encoder.Encode(message));
}
public void TestMantissaIsntPresentWhenExponentIsNull()
{
const string templateXml = "<template name='SampleTemplate'>" +
" <decimal name='bid' presence='optional'>" +
" <mantissa><copy/></mantissa>" +
" <exponent><copy value='-2'/></exponent>" +
" </decimal>" +
"</template>";
MessageTemplate template = Template(templateXml);
FastEncoder encoder = Encoder(template);
var message = new Message(template);
message.SetDecimal(1, 0.63);
AssertEquals("11010000 10000001 10111111", encoder.Encode(message));
message = new Message(template);
AssertEquals("10100000 10000000", encoder.Encode(message));
}
public void TestNullValueDoesntAlterDictionary()
{
var copyField = new Scalar(new QName("value"), FastType.I32, Operator.Copy, new IntegerValue(10), true);
var field = new Scalar(new QName("value"), FastType.I32, Operator.Default, new IntegerValue(10), true);
MessageTemplate copyTemplate = Template(copyField);
MessageTemplate template = Template(field);
var context = new Context();
var encoder = new FastEncoder(context);
encoder.RegisterTemplate(1, template);
encoder.RegisterTemplate(2, copyTemplate);
var message = (Message)copyTemplate.CreateValue(null);
message.SetInteger(1, 11);
encoder.Encode(message);
Assert.AreEqual(11, context.Lookup("global", copyTemplate, new QName("value")).ToInt());
message = (Message)template.CreateValue(null);
encoder.Encode(message);
Assert.AreEqual(11, context.Lookup("global", copyTemplate, new QName("value")).ToInt());
}
public void TestMessageTemplateWithNoFieldsThatUsePresenceMapStillEncodesPresenceMap()
{
MessageTemplate template = Template(
"<template>" +
" <string name='string'/>" +
" <decimal name='decimal'><delta/></decimal>" +
"</template>");
const string encoding = "11000000 10000001 11100001 10000000 10000001";
FastDecoder decoder = Decoder(encoding, template);
FastEncoder encoder = Encoder(template);
Message message = decoder.ReadMessage();
Assert.AreEqual("a", message.GetString("string"));
Assert.AreEqual(1.0, message.GetDouble("decimal"), 0.1);
TestUtil.AssertBitVectorEquals(encoding, encoder.Encode(message));
}
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"));
}
public MessageOutputStream(Stream outputStream, Context context)
{
_outStream = outputStream;
_encoder = new FastEncoder(context);
_context = context;
}
