public override ICurrencyMatrix DeserializeImpl(IFudgeFieldContainer message, IFudgeDeserializer deserializer) { var matrixImpl = new CurrencyMatrix(); IFudgeField field = message.GetByName(UniqueIDFieldName); if (field != null) { var uid = UniqueId.Parse((string)field.Value); matrixImpl.UniqueId = uid; } field = message.GetByName(CrossConvertFieldName); if (field != null) { var crossconvert = (FudgeMsg)field.Value; matrixImpl.LoadCross(crossconvert); } field = message.GetByName(FixedRateFieldName); if (field != null) { throw new NotImplementedException(); } field = message.GetByName(ValueRequirementsFieldName); if (field != null) { FudgeMsg value = (FudgeMsg)field.Value; matrixImpl.LoadReq(value, deserializer); } return(matrixImpl); }
public void LookupByNameSingleValue() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); IFudgeField field = null; IList <IFudgeField> fields = null; field = msg.GetByName("boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); field = msg.GetByName("Boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal((object)false, field.Value); Assert.Equal("Boolean", field.Name); Assert.Null(field.Ordinal); fields = msg.GetAllByName("boolean"); Assert.NotNull(fields); Assert.Equal(1, fields.Count); field = fields[0]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); // Check the indicator type specially Assert.Same(IndicatorType.Instance, msg.GetValue("indicator")); }
public void LoadCross(FudgeMsg message) { var values = new Dictionary<Tuple<Currency, Currency>, CurrencyMatrixValue>(); foreach (IFudgeField field in message) { CurrencyMatrixValue cross = CurrencyMatrixValue.Create(Currency.Create(field.Name)); var value = field.Value; foreach (IFudgeField field2 in (IFudgeFieldContainer)value) { Currency source = Currency.Create(field2.Name); var value2 = field2.Value; if (value2 is IFudgeFieldContainer) { Currency target = Currency.Create(((IFudgeFieldContainer)value2).First().Name); values.Add(Tuple.Create(source, target), cross); } else { Currency target = Currency.Create((string)value2); values.Add(Tuple.Create(source, target), cross); values.Add(Tuple.Create(target, source), cross); } } foreach (var valueEntry in values) { AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item1, valueEntry.Value); } } }
public void AsQueriesToLongNames() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); Assert.Equal((long?)((sbyte)5), msg.GetLong("byte")); Assert.Equal((long?)((sbyte)5), msg.GetLong("Byte")); short shortValue = ((short)sbyte.MaxValue) + 5; Assert.Equal((long?)(shortValue), msg.GetLong("short")); Assert.Equal((long?)(shortValue), msg.GetLong("Short")); int intValue = ((int)short.MaxValue) + 5; Assert.Equal((long?)(intValue), msg.GetLong("int")); Assert.Equal((long?)(intValue), msg.GetLong("Integer")); long longValue = ((long)int.MaxValue) + 5; Assert.Equal((long?)(longValue), msg.GetLong("long")); Assert.Equal((long?)(longValue), msg.GetLong("Long")); Assert.Equal((long?)(0), msg.GetLong("float")); Assert.Equal((long?)(0), msg.GetLong("Float")); Assert.Equal((long?)(0), msg.GetLong("double")); Assert.Equal((long?)(0), msg.GetLong("Double")); }
public void PrimitiveExactQueriesOrdinalsMatch() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext); Assert.Equal((sbyte)5, msg.GetSByte((short)3)); Assert.Equal((sbyte)5, msg.GetSByte((short)4)); short shortValue = ((short)sbyte.MaxValue) + 5; Assert.Equal(shortValue, msg.GetShort((short)5)); Assert.Equal(shortValue, msg.GetShort((short)6)); int intValue = ((int)short.MaxValue) + 5; Assert.Equal(intValue, msg.GetInt((short)7)); Assert.Equal(intValue, msg.GetInt((short)8)); long longValue = ((long)int.MaxValue) + 5; Assert.Equal(longValue, msg.GetLong((short)9)); Assert.Equal(longValue, msg.GetLong((short)10)); Assert.Equal(0.5f, msg.GetFloat((short)11)); Assert.Equal(0.5f, msg.GetFloat((short)12)); Assert.Equal(0.27362, msg.GetDouble((short)13)); Assert.Equal(0.27362, msg.GetDouble((short)14)); Assert.Equal("Kirk Wylie", msg.GetString((short)15)); }
protected FudgeMsgEnvelope CycleMessage(FudgeContext context, FudgeMsg msg) { FudgeStreamParser parser = new FudgeStreamParser(context); byte[] msgAsBytes = context.ToByteArray(msg); return(parser.Parse(new MemoryStream(msgAsBytes))); }
public void PrimitiveExactQueriesNamesMatch() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); Assert.Equal((sbyte)5, msg.GetSByte("byte")); Assert.Equal((sbyte)5, msg.GetSByte("Byte")); short shortValue = ((short)sbyte.MaxValue) + 5; Assert.Equal(shortValue, msg.GetShort("short")); Assert.Equal(shortValue, msg.GetShort("Short")); int intValue = ((int)short.MaxValue) + 5; Assert.Equal(intValue, msg.GetInt("int")); Assert.Equal(intValue, msg.GetInt("Integer")); long longValue = ((long)int.MaxValue) + 5; Assert.Equal(longValue, msg.GetLong("long")); Assert.Equal(longValue, msg.GetLong("Long")); Assert.Equal(0.5f, msg.GetFloat("float")); Assert.Equal(0.5f, msg.GetFloat("Float")); Assert.Equal(0.27362, msg.GetDouble("double")); Assert.Equal(0.27362, msg.GetDouble("Double")); Assert.Equal("Kirk Wylie", msg.GetString("String")); }
internal static FudgeMsg CreateMessageAllOrdinals(FudgeContext context) { FudgeMsg msg = context.NewMessage(); msg.Add(1, true); msg.Add(2, (object)(false)); msg.Add(3, (sbyte)5); msg.Add(4, (object)((sbyte)5)); short shortValue = ((short)sbyte.MaxValue) + 5; msg.Add(5, shortValue); msg.Add(6, (object)(shortValue)); int intValue = ((int)short.MaxValue) + 5; msg.Add(7, intValue); msg.Add(8, (object)(intValue)); long longValue = ((long)int.MaxValue) + 5; msg.Add(9, longValue); msg.Add(10, (object)(longValue)); msg.Add(11, 0.5f); msg.Add(12, (object)(0.5f)); msg.Add(13, 0.27362); msg.Add(14, (object)(0.27362)); msg.Add(15, "Kirk Wylie"); msg.Add(16, new float[24]); msg.Add(17, new double[273]); return(msg); }
/// <summary> /// Convenience method to deserialize an object graph from a message. /// </summary> /// <param name="msg">Message containing serialized state.</param> /// <param name="hintType">The type to use if not specified in the metadata.</param> /// <returns>Deserialized object graph.</returns> public object Deserialize(FudgeMsg msg, Type hintType = null) { // Delegate to FudgeDeserializer to do the work var deserializer = new MessageFudgeDeserializationContext(context, typeMap, TypeMappingStrategy, msg); return(deserializer.DeserializeGraph(hintType)); }
/// <summary> /// Convenience method to deserialize an object graph from a message. /// </summary> /// <param name="msg">Message containing serialized state.</param> /// <typeparam name="T">The type to use if not specified in the metadata.</typeparam> /// <returns>Deserialized object graph.</returns> public T Deserialize <T>(FudgeMsg msg) { // Delegate to FudgeDeserializer to do the work var deserializer = new MessageFudgeDeserializationContext(context, typeMap, TypeMappingStrategy, msg); return(deserializer.DeserializeGraph <T>()); }
public void AsQueriesToLongOrdinals() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext); Assert.Equal((long)((sbyte)5), msg.GetLong((short)3)); Assert.Equal((long)((sbyte)5), msg.GetLong((short)4)); short shortValue = ((short)sbyte.MaxValue) + 5; Assert.Equal((long)(shortValue), msg.GetLong((short)5)); Assert.Equal((long)(shortValue), msg.GetLong((short)6)); int intValue = ((int)short.MaxValue) + 5; Assert.Equal((long)(intValue), msg.GetLong((short)7)); Assert.Equal((long)(intValue), msg.GetLong((short)8)); long longValue = ((long)int.MaxValue) + 5; Assert.Equal(longValue, msg.GetLong((short)9)); Assert.Equal(longValue, msg.GetLong((short)10)); Assert.Equal(0, msg.GetLong((short)11)); Assert.Equal(0, msg.GetLong((short)12)); Assert.Equal(0, msg.GetLong((short)13)); Assert.Equal(0, msg.GetLong((short)14)); }
public void LookupByNameMultipleValues() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); IFudgeField field = null; IList <IFudgeField> fields = null; // Now add a second by name. msg.Add("boolean", true); field = msg.GetByName("boolean"); Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); fields = msg.GetAllByName("boolean"); Assert.NotNull(fields); Assert.Equal(2, fields.Count); field = fields[0]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); field = fields[1]; Assert.NotNull(field); Assert.Equal(PrimitiveFieldTypes.BooleanType, field.Type); Assert.Equal(true, field.Value); Assert.Equal("boolean", field.Name); Assert.Null(field.Ordinal); }
public void ToFudgeMsg(IAppendingFudgeFieldContainer message, IFudgeSerializer s) { message.Add("name", Name); if (_uniqueID != null) { message.Add("uniqueId", _uniqueID.ToString()); } s.WriteInline(message, "identifier", PortfolioIdentifier); s.WriteInline(message, "user", User); s.WriteInline(message, "resultModelDefinition", ResultModelDefinition); if (DefaultCurrency != null) { message.Add("currency", DefaultCurrency.ISOCode); } WriteNullableTimeSpanField(message, "minDeltaCalcPeriod", MinDeltaCalcPeriod); WriteNullableTimeSpanField(message, "maxDeltaCalcPeriod", MaxDeltaCalcPeriod); WriteNullableTimeSpanField(message, "fullDeltaCalcPeriod", MinFullCalcPeriod); WriteNullableTimeSpanField(message, "maxFullCalcPeriod", MaxFullCalcPeriod); foreach (var calcConfig in CalculationConfigurationsByName.Values) { FudgeMsg calcConfigMsg = s.Context.NewMessage(); calcConfig.ToFudgeMsg(calcConfigMsg, s); message.Add("calculationConfiguration", calcConfigMsg); } }
public void LoadCross(FudgeMsg message) { var values = new Dictionary <Tuple <Currency, Currency>, CurrencyMatrixValue>(); foreach (IFudgeField field in message) { CurrencyMatrixValue cross = CurrencyMatrixValue.Create(Currency.Create(field.Name)); var value = field.Value; foreach (IFudgeField field2 in (IFudgeFieldContainer)value) { Currency source = Currency.Create(field2.Name); var value2 = field2.Value; if (value2 is IFudgeFieldContainer) { Currency target = Currency.Create(((IFudgeFieldContainer)value2).First().Name); values.Add(Tuple.Create(source, target), cross); } else { Currency target = Currency.Create((string)value2); values.Add(Tuple.Create(source, target), cross); values.Add(Tuple.Create(target, source), cross); } } foreach (var valueEntry in values) { AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item1, valueEntry.Value); } } }
public TRet Put <TRet>(object reqObj, string subMessageField) { var reqMsg = _fudgeContext.GetSerializer().SerializeToMsg(reqObj); FudgeMsg retMsg = FudgeRequestImpl("PUT", reqMsg); return(ProjectSubMessage <TRet>(retMsg, subMessageField)); }
private T FudgeDeserializedRequestImpl <T>(string method = "GET", FudgeMsg reqMsg = null) { return(FudgeMimeRequestImpl( (response, stream) => _fudgeContext.DeFudgeSerialize <T>(stream), () => _fudgeContext.DeFudgeSerialize <T>(_fudgeContext.NewMessage()), default(T), method, reqMsg)); }
public void LongInLongOut() { FudgeMsg msg = new FudgeMsg(); msg.Add("test", (long)5); Assert.Equal((long)5, msg.GetLong("test")); }
public void Example() { var context = new FudgeContext(); // Create a message var msg = new FudgeMsg(new Field("name", "Eric"), new Field("age", 14), new Field("address", new Field("line1", "29 Acacia Road"), new Field("city", "London"))); // Serialise it var stream = new MemoryStream(); context.Serialize(msg, stream); // Get the raw bytes var bytes = stream.ToArray(); // Deserialise it var msg2 = context.Deserialize(bytes).Message; // Get some data int age = msg2.GetInt("age") ?? 0; }
/// <inheritdoc/> public void StartSubMessage(string name, int? ordinal) { msgStack.Push(current); FudgeMsg newMsg = context.NewMessage(); current.Add(name, ordinal, newMsg); current = newMsg; }
public void AllOrdinalsCodecWithTaxonomy() { FudgeContext context = new FudgeContext(); FudgeMsg inputMsg = context.NewMessage(); inputMsg.Add(ORDINALS[0], "value1"); inputMsg.Add(ORDINALS[1], "value2"); inputMsg.Add(ORDINALS[2], "value3"); inputMsg.Add(ORDINALS[3], "value4"); var resolverMap = new Dictionary <int, IFudgeTaxonomy>(); resolverMap.Add(45, new MapFudgeTaxonomy(ORDINALS, NAMES)); context.TaxonomyResolver = new ImmutableMapTaxonomyResolver(resolverMap); FudgeMsg outputMsg = CycleMessage(inputMsg, context, (short)45); Assert.Equal("value1", outputMsg.GetString(NAMES[0])); Assert.Equal("value1", outputMsg.GetString(ORDINALS[0])); Assert.Equal("value2", outputMsg.GetString(NAMES[1])); Assert.Equal("value2", outputMsg.GetString(ORDINALS[1])); Assert.Equal("value3", outputMsg.GetString(NAMES[2])); Assert.Equal("value3", outputMsg.GetString(ORDINALS[2])); Assert.Equal("value4", outputMsg.GetString(NAMES[3])); Assert.Equal("value4", outputMsg.GetString(ORDINALS[3])); }
public void RaisesEventAfterEachMessage() { var context = new FudgeContext(); var messages = new FudgeMsg[] { new FudgeMsg(context, new Field("test", "data")), new FudgeMsg(context, new Field("life", 42)) }; var reader = new FudgeMsgStreamReader(context, messages); var writer = new FudgeMsgStreamWriter(context); var pipe = new FudgeStreamPipe(reader, writer); int count = 0; pipe.MessageProcessed += () => { var message = writer.DequeueMessage(); FudgeUtils.AssertAllFieldsMatch(messages[count], message); count++; }; pipe.Process(); Assert.Equal(2, count); }
/// <summary> /// Convenience method for writing a <see cref="FudgeMsg"/> to a <see cref="IFudgeStreamWriter"/>. /// </summary> /// <param name="writer">Writer to write the data.</param> /// <param name="msg">Message to write.</param> public static void WriteMsg(this IFudgeStreamWriter writer, FudgeMsg msg) { var reader = new FudgeMsgStreamReader(msg.Context, msg); var pipe = new FudgeStreamPipe(reader, writer); pipe.ProcessOne(); }
public void MultipleMessages() { // Same as CheckElementsCorrectForSimpleMessage but without using HasNext var context = new FudgeContext(); var msg1 = context.NewMessage(); msg1.Add("Test", "Bob"); var msg2 = context.NewMessage(); msg2.Add("Test2", "Shirley"); var msgs = new FudgeMsg[] { msg1, msg2 }; var stream = new MemoryStream(); var writer = new FudgeEncodedStreamWriter(context, stream); new FudgeStreamPipe(new FudgeMsgStreamReader(context, msgs), writer).Process(); stream.Position = 0; var reader = new FudgeEncodedStreamReader(context, stream); Assert.Equal(FudgeStreamElement.MessageStart, reader.MoveNext()); Assert.Equal(FudgeStreamElement.SimpleField, reader.MoveNext()); Assert.Equal(FudgeStreamElement.MessageEnd, reader.MoveNext()); Assert.Equal(FudgeStreamElement.MessageStart, reader.MoveNext()); Assert.Equal(FudgeStreamElement.SimpleField, reader.MoveNext()); Assert.Equal(FudgeStreamElement.MessageEnd, reader.MoveNext()); Assert.Equal(FudgeStreamElement.NoElement, reader.MoveNext()); Assert.Equal(FudgeStreamElement.NoElement, reader.MoveNext()); }
protected override void SerializeImpl(ValueProperties obj, IAppendingFudgeFieldContainer msg, IFudgeSerializer serializer) { var finite = obj as FiniteValueProperties; if (finite != null) { finite.Serialize(msg, serializer); } else { if (obj is EmptyValueProperties) { return; } var withoutMessage = new FudgeMsg(serializer.Context); if (obj is NearlyInfiniteValueProperties) { foreach (var without in ((NearlyInfiniteValueProperties)obj).Without) { withoutMessage.Add((string)null, without); } } msg.Add("without", withoutMessage); } }
public void LoadReq(FudgeMsg message, IFudgeDeserializer deserializer) { var values = new Dictionary <Tuple <Currency, Currency>, CurrencyMatrixValue>(); foreach (var field in message) { Currency source = Currency.Create(field.Name); foreach (var field2 in (IFudgeFieldContainer)field.Value) { Currency target = Currency.Create(field2.Name); if (field2.Value is IFudgeFieldContainer) { CurrencyMatrixValue value = deserializer.FromField <CurrencyMatrixValue.CurrencyMatrixValueRequirement>(field2); values.Add(Tuple.Create(source, target), value); values.Add(Tuple.Create(target, source), value.Reciprocal); } else { values.Remove(Tuple.Create(target, source)); } } } foreach (var valueEntry in values) { AddConversion(valueEntry.Key.Item1, valueEntry.Key.Item2, valueEntry.Value); } }
/// <inheritdoc/> public void EndSubMessage() { if (msgStack.Count == 0) { throw new InvalidOperationException("Ending more sub-messages than started"); } current = msgStack.Pop(); }
private void Cycle(FudgeTime t) { var msg1 = new FudgeMsg(context, new Field("t", t)); var bytes = msg1.ToByteArray(); var msg2 = context.Deserialize(bytes).Message; Assert.Equal(t, msg2.GetValue <FudgeTime>("t")); }
public void Minimization() { FudgeMsg msg = new FudgeMsg(); msg.Add("int?", 17); Assert.Same(PrimitiveFieldTypes.SByteType, msg.GetByName("int?").Type); }
private void Cycle(FudgeTime t) { var msg1 = new FudgeMsg(context, new Field("t", t)); var bytes = msg1.ToByteArray(); var msg2 = context.Deserialize(bytes).Message; Assert.Equal(t, msg2.GetValue<FudgeTime>("t")); }
public void ToByteArray() { FudgeMsg msg = StandardFudgeMessages.CreateMessageAllNames(fudgeContext); byte[] bytes = msg.ToByteArray(); Assert.NotNull(bytes); Assert.True(bytes.Length > 10); }
public void Unknown() { FudgeMsg inputMsg = new FudgeMsg( new Field("unknown", new UnknownFudgeFieldValue(new byte[10], new FudgeTypeDictionary().GetUnknownType(200)))); FudgeMsg outputMsg = CycleMessage(inputMsg, "unknown.dat"); FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg); }
/// <summary> /// Will output a <see cref="FudgeMsg"/> to <see cref="Console.Out"/> so that you can visually /// examine it. /// </summary> public void OutputToStdoutAllOrdinals() { Console.Out.WriteLine("FudgeMsgFormatterTest.OutputToStdoutAllOrdinals()"); FudgeMsg msg = StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext); msg.Add("Sub Message", (short)9999, StandardFudgeMessages.CreateMessageAllOrdinals(fudgeContext)); new FudgeMsgFormatter(Console.Out).Format(msg); }
public bool Finished(FudgeMsg fudgeMsg, int index) { Type objectType = GetObjectType(index, null, fudgeMsg, false); if (objectType != null) { DeserializeFromMessageImpl(index, fudgeMsg, objectType); return true; } return false; }
public void RoundTrip() { var d = new FudgeDate(1999, 12, 10); var msg1 = new FudgeMsg(context, new Field("d", d)); var bytes = msg1.ToByteArray(); var msg2 = context.Deserialize(bytes).Message; Assert.Equal("1999-12-10", msg2.GetValue<FudgeDate>("d").ToString()); }
public void BindingParams() { // Make sure we can handle constants that are coming in from outside the query var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR"), CreateTickMsg(5.2, 5.5, "ZIP") }; double bid = 2.4; var query = from tick in msgs.AsQueryable<Tick>() where tick.Bid == bid // bid here comes from outside the query select tick.Ticker; var tickers = query.ToArray(); Assert.Equal(new string[] { "BAR" }, tickers); }
public void FudgeMsgVsIFudgeFieldContainer() { // Make sure that we can work with enumerables of IFudgeFieldContainer, enumerables of IFudgeMsg and also arrays directly var array = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR") }; IEnumerable<IFudgeFieldContainer> containerList = array; IEnumerable<FudgeMsg> msgList = array; var query1 = from tick in containerList.AsQueryable<Tick>() select tick.Ticker; var query2 = from tick in msgList.AsQueryable<Tick>() select tick.Ticker; var query3 = from tick in array.AsQueryable<Tick>() select tick.Ticker; Assert.Equal(query1, query2); Assert.Equal(query1, query3); }
public void ToFudgeMsg(IAppendingFudgeFieldContainer a, IFudgeSerializer s) { s.WriteTypeHeader(a, GetType()); var fudgeMsg = new FudgeMsg(s.Context); foreach (var viewCycleExecutionOptionse in _executionSequence) { FudgeMsg msg = ((OpenGammaFudgeContext)s.Context).GetSerializer().SerializeToMsg(viewCycleExecutionOptionse); fudgeMsg.Add(null, null, msg); } a.Add("sequence", fudgeMsg); }
/// <summary> /// Creates a new <c>FudgeMsgEnvelope</c> around an existing <c>FudgeMsg</c> with a specific encoding schema version. The default /// schema version is 0. /// </summary> /// <param name="message">message contained within the envelope</param> /// <param name="version">schema version, 0 to 255</param> public FudgeMsgEnvelope(FudgeMsg message, int version) { if (message == null) { throw new ArgumentNullException("message", "Must specify a message to wrap."); } if ((version < 0) || (version > 255)) { throw new ArgumentOutOfRangeException("version", "Provided version " + version + " which doesn't fit within one byte."); } this.message = message; this.version = version; }
public void ComplexSelect() { // This code is used in the Fudge.Linq namespace doc example. var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR") }; var query = from tick in msgs.AsQueryable<Tick>() where tick.Ask > 4.0 select new { tick.Ticker, tick.Ask }; var results = query.ToArray(); Assert.Equal(1, results.Length); Assert.Equal("FOO", results[0].Ticker); Assert.Equal(11.1, results[0].Ask); }
public void FixedWidthByteArrays() { FudgeMsg inputMsg = new FudgeMsg( new Field("byte[4]", CreateRandomArray(4)), new Field("byte[8]", CreateRandomArray(8)), new Field("byte[16]", CreateRandomArray(16)), new Field("byte[20]", CreateRandomArray(20)), new Field("byte[32]", CreateRandomArray(32)), new Field("byte[64]", CreateRandomArray(64)), new Field("byte[128]", CreateRandomArray(128)), new Field("byte[256]", CreateRandomArray(256)), new Field("byte[512]", CreateRandomArray(512)), new Field("byte[28]", CreateRandomArray(28))); FudgeMsg outputMsg = CycleMessage(inputMsg); FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg); }
public void CheckSecondaryTypes() { var msg = new FudgeMsg(context); var dt = new DateTime(1987, 1, 13, 8, 6, 5); var dto = new DateTimeOffset(1822, 7, 20, 13, 2, 15, new TimeSpan(-2, 0, 0)); msg.Add("dt", dt); msg.Add("dto", dto); Assert.Same(DateTimeFieldType.Instance, msg.GetByName("dt").Type); Assert.IsType<FudgeDateTime>(msg.GetByName("dt").Value); Assert.Same(DateTimeFieldType.Instance, msg.GetByName("dto").Type); Assert.IsType<FudgeDateTime>(msg.GetByName("dto").Value); Assert.Equal(dt, msg.GetValue<DateTime>("dt")); Assert.Equal(dto, msg.GetValue<DateTime>("dto")); }
public void AddingFieldContainerCopiesFields() { var msg = new FudgeMsg(); // Add a normal sub-message (shouldn't copy) IFudgeFieldContainer sub1 = new FudgeMsg(new Field("age", 37)); msg.Add("sub1", sub1); Assert.Same(sub1, msg.GetValue("sub1")); // Add a sub-message that isn't a FudgeMsg (should copy) IFudgeFieldContainer sub2 = (IFudgeFieldContainer)new Field("dummy", new Field("colour", "blue")).Value; Assert.IsNotType<FudgeMsg>(sub2); // Just making sure msg.Add("sub2", sub2); Assert.NotSame(sub2, msg.GetValue("sub2")); Assert.IsType<FudgeMsg>(msg.GetValue("sub2")); Assert.Equal("blue", msg.GetMessage("sub2").GetString("colour")); }
public void NestedMessages() { var msg = new FudgeMsg(new Field("name", "Fred"), new Field("address", new Field("number", 17), new Field("line1", "Our House"), new Field("line2", "In the middle of our street"))); var sb = new StringBuilder(); var xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { OmitXmlDeclaration = true }); var writer = new FudgeXmlStreamWriter(context, xmlWriter, "msg"); var reader = new FudgeMsgStreamReader(context, msg); new FudgeStreamPipe(reader, writer).Process(); xmlWriter.Flush(); string s = sb.ToString(); Assert.Equal("<msg><name>Fred</name><address><number>17</number><line1>Our House</line1><line2>In the middle of our street</line2></address></msg>", s); }
public void OrderBy() { var msgs = new FudgeMsg[] { CreateTickMsg(10.3, 11.1, "FOO"), CreateTickMsg(2.4, 3.1, "BAR"), CreateTickMsg(5.2, 5.5, "ZIP") }; var query = from tick in msgs.AsQueryable<Tick>() orderby tick.Ask select tick.Ticker; string[] tickers = query.ToArray(); Assert.Equal(new string[] { "BAR", "ZIP", "FOO" }, tickers); // And descending query = from tick in msgs.AsQueryable<Tick>() orderby tick.Bid descending select tick.Ticker; tickers = query.ToArray(); Assert.Equal(new string[] { "FOO", "ZIP", "BAR" }, tickers); }
public void Minimsation() { var msg = new FudgeMsg(context); var dt = new DateTime(1990, 2, 1); var fdt = new FudgeDateTime(1990, 2, 1, 0, 0, 0, 0, FudgeDateTimePrecision.Day); msg.Add("dt", dt); msg.Add("fdt", fdt); Assert.Same(DateFieldType.Instance, msg.GetByName("dt").Type); Assert.IsType<FudgeDate>(msg.GetByName("dt").Value); Assert.Same(DateFieldType.Instance, msg.GetByName("fdt").Type); Assert.IsType<FudgeDate>(msg.GetByName("fdt").Value); Assert.Equal(dt, msg.GetValue<DateTime>("dt")); Assert.Equal(fdt, msg.GetValue<FudgeDateTime>("fdt")); // Error cases FudgeFieldType type = null; Assert.Equal(null, DateTimeFieldType.Instance.Minimize(null, ref type)); Assert.Throws<ArgumentException>(() => DateTimeFieldType.Instance.Minimize("fred", ref type)); }
public static void AssertAllFieldsMatch(FudgeMsg expectedMsg, FudgeMsg actualMsg) { var expectedIter = expectedMsg.GetAllFields().GetEnumerator(); var actualIter = actualMsg.GetAllFields().GetEnumerator(); while (expectedIter.MoveNext()) { Assert.True(actualIter.MoveNext()); IFudgeField expectedField = expectedIter.Current; IFudgeField actualField = actualIter.Current; Assert.Equal(expectedField.Name, actualField.Name); Assert.Equal(expectedField.Type, actualField.Type); Assert.Equal(expectedField.Ordinal, actualField.Ordinal); if (expectedField.Value.GetType().IsArray) { Assert.Equal(expectedField.Value.GetType(), actualField.Value.GetType()); Assert.Equal(expectedField.Value, actualField.Value); // XUnit will check all values in the arrays } else if (expectedField.Value is FudgeMsg) { Assert.True(actualField.Value is FudgeMsg); AssertAllFieldsMatch((FudgeMsg)expectedField.Value, (FudgeMsg)actualField.Value); } else if (expectedField.Value is UnknownFudgeFieldValue) { Assert.IsType<UnknownFudgeFieldValue>(actualField.Value); UnknownFudgeFieldValue expectedValue = (UnknownFudgeFieldValue)expectedField.Value; UnknownFudgeFieldValue actualValue = (UnknownFudgeFieldValue)actualField.Value; Assert.Equal(expectedField.Type.TypeId, actualField.Type.TypeId); Assert.Equal(expectedValue.Type.TypeId, actualField.Type.TypeId); Assert.Equal(expectedValue.Contents, actualValue.Contents); } else { Assert.Equal(expectedField.Value, actualField.Value); } } Assert.False(actualIter.MoveNext()); }
public void VariableWidthColumnSizes() { FudgeMsg inputMsg = new FudgeMsg(); inputMsg.Add("100", new byte[100]); inputMsg.Add("1000", new byte[1000]); inputMsg.Add("10000", new byte[100000]); FudgeMsg outputMsg = CycleMessage(inputMsg); Assert.NotNull(outputMsg); FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg); }
public void RoundTrip() { var dt = new FudgeDateTime(1999, 12, 10, 3, 4, 5, 987654321, -75, FudgeDateTimePrecision.Nanosecond); var msg1 = new FudgeMsg(context, new Field("dt", dt)); var bytes = msg1.ToByteArray(); var msg2 = context.Deserialize(bytes).Message; Assert.Equal("1999-12-10T03:04:05.987654321-01:15", msg2.GetValue<FudgeDateTime>("dt").ToString()); }
public void WriteIndicatorType() { var msg = new FudgeMsg(new Field("blank", IndicatorType.Instance)); var sb = new StringBuilder(); var xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings { OmitXmlDeclaration = true }); var writer = new FudgeXmlStreamWriter(context, xmlWriter, "msg") { AutoFlushOnMessageEnd = true }; var reader = new FudgeMsgStreamReader(context, msg); new FudgeStreamPipe(reader, writer).Process(); xmlWriter.Flush(); string s = sb.ToString(); Assert.Equal("<msg><blank /></msg>", s); }
protected void CheckResultsMatch(FudgeMsg msg) { CheckResultsMatch(msg, new FudgeContext()); }
public void Unknown() { FudgeMsg inputMsg = new FudgeMsg(); inputMsg.Add("unknown", new UnknownFudgeFieldValue(new byte[10], new FudgeTypeDictionary().GetUnknownType(200))); FudgeMsg outputMsg = CycleMessage(inputMsg); FudgeUtils.AssertAllFieldsMatch(inputMsg, outputMsg); }
public void GetAllNames() { var msg = new FudgeMsg(); msg.Add("foo", 3); msg.Add("bar", 17); msg.Add("foo", 2); // Deliberately do a duplicate var names = msg.GetAllFieldNames(); Assert.Equal(2, names.Count); Assert.Contains("foo", names); Assert.Contains("bar", names); }
//throws IOException protected static FudgeMsg CycleMessage(FudgeMsg msg) { byte[] content = fudgeContext.ToByteArray(msg); // Double-check the size calc was right Assert.Equal(content.Length, new FudgeMsgEnvelope(msg).ComputeSize(null)); MemoryStream stream2 = new MemoryStream(content); FudgeMsgEnvelope outputMsgEnvelope = fudgeContext.Deserialize(stream2); Assert.NotNull(outputMsgEnvelope); Assert.NotNull(outputMsgEnvelope.Message); return outputMsgEnvelope.Message; }
protected FudgeMsgEnvelope CycleMessage(FudgeContext context, FudgeMsg msg) { FudgeStreamParser parser = new FudgeStreamParser(context); byte[] msgAsBytes = context.ToByteArray(msg); return parser.Parse(new MemoryStream(msgAsBytes)); }
public void HasField_FRN82() { var msg = new FudgeMsg(); msg.Add("foo", 3); msg.Add(17, "bar"); Assert.True(msg.HasField("foo")); Assert.False(msg.HasField("bar")); Assert.True(msg.HasField(17)); Assert.False(msg.HasField(3)); }
/** * @param msg */ protected void CheckResultsMatch(FudgeMsg msg, FudgeContext fudgeContext) { FudgeMsgEnvelope result = CycleMessage(fudgeContext, msg); Assert.NotNull(result); Assert.NotNull(result.Message); FudgeMsg resultMsg = result.Message; FudgeUtils.AssertAllFieldsMatch(msg, resultMsg); }
public ClassWithMessageIn() { Message = new FudgeMsg(); }