public void SimpleStatement()
{
var ab = new ActionBucket
{
bar = "~`!1@2#3$4%5^6&7*8(9)0_-+={[}]:;\"\"<,<.?//*-+.a string pointed to by bar"
};
Func<Int64, Int64, Int64, Int64, ActionBucket> f = (a, b, c, d) => ab;
var s = new TemplateDictionary
{
{"foo", f}
};
const string text = "$foo(1L,2L,3L,4L).func( 'a string', 0L )[1L,2L][1L,2L].func( 'adfasdfad', 92321312L )[123123L,123123L].bar";
var result1 = Template.ImmediateApply(s, text);
Assert.IsFalse(result1.Errors.ContainsError());
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.AreEqual(ab.bar, result1.Output);
var result2 = Template.CompileAndRun("test", text, s);
Assert.IsFalse(result2.Errors.ContainsError());
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.AreEqual(ab.bar, result2.Output);
}
public void should_match_a_name_value_where_value_is_empty()
{
result = TemplateDictionary.get_matches("<property name=\"bob]\" value=\"\" />");
Assert.AreEqual(1, result.Count);
foreach (Match match in result)
{
Assert.AreEqual("name=\"bob]\" value=\"\"", match.ToString());
}
}
public void should_match_a_name_value_with_underscores()
{
result = TemplateDictionary.get_matches("<property name=\"bob_1\" value=\"bill_2\" />");
Assert.AreEqual(1, result.Count);
foreach (Match match in result)
{
Assert.AreEqual("name=\"bob_1\" value=\"bill_2\"", match.ToString());
}
}
public DataTemplate SelectTemplate(object item, DependencyObject container)
{
var key = KeySelector == null
? _defaultKeySelector.Invoke(item)
: KeySelector.Invoke(item);
if (TemplateDictionary.ContainsKey(key))
{
return(TemplateDictionary[key]);
}
return(null);
}
public void TestExistingTemplateValueLookup()
{
Dictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate("Position",
new Field[] {
new Scalar("exchange", FASTType.STRING, Operator.COPY, ScalarValue.UNDEFINED, false)
});
ScalarValue value = new StringValue("NYSE");
dictionary.Store(template, FastConstants.ANY_TYPE, new QName("exchange"), value);
Assert.AreEqual(ScalarValue.UNDEFINED, dictionary.Lookup(template, new QName("bid"), FastConstants.ANY_TYPE));
}
public void TestExistingTemplateValueLookup()
{
IDictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate(
"Position",
new Field[]
{
new Scalar("exchange", FastType.String, Operator.Copy, ScalarValue.Undefined, false)
});
ScalarValue value = new StringValue("NYSE");
dictionary.Store(template, new QName("exchange"), FastConstants.AnyType, value);
Assert.AreEqual(ScalarValue.Undefined, dictionary.Lookup(template, new QName("bid"), FastConstants.AnyType));
}
public void TestExistingTemplateValueLookup()
{
IDictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate(
"Position",
new Field[]
{
new Scalar("exchange", FastType.String, Operator.Copy, ScalarValue.Undefined, false)
});
ScalarValue value = new StringValue("NYSE");
dictionary.Store(template, new QName("exchange"), FastConstants.AnyType, value);
Assert.AreEqual(ScalarValue.Undefined, dictionary.Lookup(template, new QName("bid"), FastConstants.AnyType));
}
public void LessThanOperator()
{
var dict = new TemplateDictionary();
dict["foo"] = 3;
dict["bar"] = 4;
const string template1 = "#if ($foo < $bar) true #else false #end";
var result1 = Template.ImmediateApply(dict, template1);
Assert.False(result1.Errors.ContainsError());
Assert.AreEqual(" true ", result1.Output);
dict["foo"] = 13;
var result2 = Template.ImmediateApply(dict, template1);
Assert.False(result2.Errors.ContainsError());
Assert.AreEqual(" false ", result2.Output);
}
protected TemplateComparisonResult IsTemplateSynchronized(ModelTemplateReference reference)
{
TemplateItem template;
if (TemplateDictionary.TryGetValue(reference.Metadata.TemplateID, out template))
{
return(new TemplateComparisonResult(
template.ID.ToString(),
GetTemplateName(template),
GetModelName(reference),
_signatureProvider.GenerateTemplateSignature(template),
reference.Metadata.VersionSignature));
}
return(new TemplateComparisonResult(reference.Metadata.TemplateID, null, GetModelName(reference), null, reference.Metadata.VersionSignature));
}
public void AndOperatorYieldsProperBooleanResult()
{
var dict = new TemplateDictionary();
const string template1 = "#if ($foo == null && $bar != null) true #else false #end";
var result1 = Template.ImmediateApply(dict, template1);
Assert.False(result1.Errors.ContainsError());
Assert.AreEqual(" false ", result1.Output);
var result2 = Template.CompileAndRun("test", template1, dict);
Assert.False(result2.Errors.ContainsError());
Assert.AreEqual(" false ", result2.Output);
dict["foo"] = "not null";
dict["bar"] = null;
const string template2 = "#if ($foo == null && $bar != null) true #else false #end";
var result3 = Template.ImmediateApply(dict, template2);
Assert.False(result3.Errors.ContainsError());
Assert.AreEqual(" false ", result3.Output);
var result4 = Template.CompileAndRun("test", template2, dict);
Assert.False(result4.Errors.ContainsError());
Assert.AreEqual(" false ", result4.Output);
dict["foo"] = null;
dict["bar"] = "not null";
const string template3 = "#if ($foo == null && $bar != null) true #else false #end";
var result5 = Template.ImmediateApply(dict, template3);
Assert.False(result5.Errors.ContainsError());
Assert.AreEqual(" true ", result5.Output);
var result6 = Template.CompileAndRun("test", template3, dict);
Assert.False(result6.Errors.ContainsError());
Assert.AreEqual(" true ", result6.Output);
dict["foo"] = false;
dict["bar"] = true;
const string template4 = "#if (!$foo && $bar) true #else false #end";
var result7 = Template.ImmediateApply(dict, template4);
Assert.False(result7.Errors.ContainsError());
Assert.AreEqual(" true ", result7.Output);
var result8 = Template.CompileAndRun("test", template4, dict);
Assert.False(result8.Errors.ContainsError());
Assert.AreEqual(" true ", result8.Output);
}
public void TestLookupMultipleValuesForTemplate()
{
Dictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate("Position",
new Field[] {
new Scalar("exchange", FASTType.STRING, Operator.COPY, ScalarValue.UNDEFINED, false)
});
ScalarValue value = new StringValue("NYSE");
ScalarValue marketValue = new DecimalValue(100000.00);
dictionary.Store(template, FastConstants.ANY_TYPE, new QName("exchange"), value);
dictionary.Store(template, FastConstants.ANY_TYPE, new QName("marketValue"), marketValue);
Assert.IsFalse(value.Equals(ScalarValue.UNDEFINED));
Assert.AreEqual(value, dictionary.Lookup(template, new QName("exchange"), FastConstants.ANY_TYPE));
Assert.AreEqual(marketValue, dictionary.Lookup(template, new QName("marketValue"), FastConstants.ANY_TYPE));
}
public void ExpandNonExistentMacroResultsInError()
{
var s = new TemplateDictionary
{
{"bar", "bing"},
{"foo", "$bar"}
};
const string text = "*****@*****.**";
var result1 = Template.ImmediateApply(s, text);
Assert.IsFalse(result1.Errors.ContainsError());
Assert.IsTrue(result1.Errors.ContainsWarning());
var result2 = Template.CompileAndRun("test", text, s);
Assert.IsFalse(result2.Errors.ContainsError());
Assert.IsTrue(result2.Errors.ContainsWarning());
}
public void TestLookupMultipleValuesForTemplate()
{
IDictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate(
"Position",
new Field[]
{
new Scalar("exchange", FastType.String, Operator.Copy, ScalarValue.Undefined, false)
});
ScalarValue value = new StringValue("NYSE");
ScalarValue marketValue = new DecimalValue(100000.00);
dictionary.Store(template, new QName("exchange"), FastConstants.AnyType, value);
dictionary.Store(template, new QName("marketValue"), FastConstants.AnyType, marketValue);
Assert.AreNotEqual(ScalarValue.Undefined, value);
Assert.AreEqual(value, dictionary.Lookup(template, new QName("exchange"), FastConstants.AnyType));
Assert.AreEqual(marketValue, dictionary.Lookup(template, new QName("marketValue"), FastConstants.AnyType));
}
public void EqualsOperator()
{
var dict = new TemplateDictionary();
dict["foo"] = true.ToString();
dict["bar"] = false.ToString();
const string template1 = "#if ($foo == $bar) true #else false #end";
var result1 = Template.ImmediateApply(dict, template1);
Assert.False(result1.Errors.ContainsError());
Assert.AreEqual(" false ", result1.Output);
dict["foo"] = null;
dict["bar"] = string.Empty;
const string template2 = "#if ($foo == $bar) true #else false #end";
var result2 = Template.ImmediateApply(dict, template2);
Assert.False(result2.Errors.ContainsError());
Assert.AreEqual(" false ", result2.Output);
}
public void SimpleMacroExpands()
{
var s = new TemplateDictionary
{
{"bar", "bing"},
{"foo", "$bar"}
};
const string text = "@foo";
var result1 = Template.ImmediateApply(s, text);
Assert.IsFalse(result1.Errors.ContainsError());
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.AreEqual("bing", result1.Output);
var result2 = Template.CompileAndRun("test", text, s);
Assert.IsFalse(result2.Errors.ContainsError());
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.AreEqual("bing", result2.Output);
}
public void TestLookupMultipleValuesForTemplate()
{
IDictionary dictionary = new TemplateDictionary();
Group template = new MessageTemplate(
"Position",
new Field[]
{
new Scalar("exchange", FastType.String, Operator.Copy, ScalarValue.Undefined, false)
});
ScalarValue value = new StringValue("NYSE");
ScalarValue marketValue = new DecimalValue(100000.00);
dictionary.Store(template, new QName("exchange"), FastConstants.AnyType, value);
dictionary.Store(template, new QName("marketValue"), FastConstants.AnyType, marketValue);
Assert.AreNotEqual(ScalarValue.Undefined, value);
Assert.AreEqual(value, dictionary.Lookup(template, new QName("exchange"), FastConstants.AnyType));
Assert.AreEqual(marketValue, dictionary.Lookup(template, new QName("marketValue"), FastConstants.AnyType));
}
public static void SetupDictionaries(TestContext testContext)
{
_testContext = testContext;
templates1 = new TemplateDictionary
{
["default"] = new TemplateIdMap
{
{ "stringTemplate", (context, data) => $"default: { data.name}" },
{ "activityTemplate", (context, data) => { return(new Activity()
{
Type = ActivityTypes.Message, Text = $"(Activity)default: { data.name}"
}); } },
{ "stringTemplate2", (context, data) => $"default: Yo { data.name}" }
},
["en"] = new TemplateIdMap
{
{ "stringTemplate", (context, data) => $"en: { data.name}" },
{ "activityTemplate", (context, data) => { return(new Activity()
{
Type = ActivityTypes.Message, Text = $"(Activity)en: { data.name}"
}); } },
{ "stringTemplate2", (context, data) => $"en: Yo { data.name}" }
},
["fr"] = new TemplateIdMap
{
{ "stringTemplate", (context, data) => $"fr: { data.name}" },
{ "activityTemplate", (context, data) => { return(new Activity()
{
Type = ActivityTypes.Message, Text = $"(Activity)fr: { data.name}"
}); } },
{ "stringTemplate2", (context, data) => $"fr: Yo { data.name}" }
}
};
templates2 = new TemplateDictionary
{
["en"] = new TemplateIdMap
{
{ "stringTemplate2", (context, data) => $"en: StringTemplate2 override {data.name}" }
}
};
}
public void BadLoop()
{
var dict = new TemplateDictionary
{
{"decimal", (decimal) 1.2},
{"double", 1.2}
};
const string exp = "#loop Yalp";
var result1 = Template.ImmediateApply(dict, exp);
Assert.IsTrue(result1.Errors.ContainsError());
Assert.AreEqual("R999", result1.Errors[0].Code);
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.IsTrue(string.IsNullOrEmpty(result1.Output));
var result2 = Template.CompileAndRun("test", exp, dict);
Assert.IsTrue(result2.Errors.ContainsError());
Assert.AreEqual("R999", result2.Errors[0].Code);
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.IsTrue(string.IsNullOrEmpty(result2.Output));
}
public void Badkeyword()
{
var dict = new TemplateDictionary
{
{"decimal", (decimal) 1.2},
{"double", 1.2}
};
const string exp = "$($(decimal) + $(double))";
var result1 = Template.ImmediateApply(dict, exp);
Assert.IsTrue(result1.Errors.ContainsError());
Assert.AreEqual(2, result1.Errors.Count);
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.IsTrue(string.IsNullOrEmpty(result1.Output));
var result2 = Template.CompileAndRun("test", exp, dict);
Assert.IsTrue(result2.Errors.ContainsError());
Assert.AreEqual(2, result2.Errors.Count);
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.IsTrue(string.IsNullOrEmpty(result2.Output));
}
public void should_match_quite_a_few_times_against_a_real_settings_file()
{
result = TemplateDictionary.get_matches(DevSettings.Contents);
Assert.AreEqual(62, result.Count);
}
public ErrorList WarmUp(TemplateDictionary state)
{
_buffer = null;
_errors = new ErrorList();
_state = state;
try
{
_image(this);
}
catch (Exception e)
{
_errors.ErrorRuntimeError(e);
}
return _errors;
}
public TemplateExecutionResult Execute(TemplateDictionary state)
{
var result = new TemplateExecutionResult {Template = this};
_buffer = new StringBuilder();
_errors = new ErrorList();
_state = state;
try
{
_image(this);
result.Output = _buffer.ToString();
}
catch (Exception e)
{
result.Output = string.Empty;
_errors.ErrorRuntimeError(e);
}
result.Errors.AddRange(_errors);
return result;
}
public TemplateExecutionResult Apply(TemplateDictionary state)
{
var result = new TemplateExecutionResult();
result.Errors.AddRange(_parserErrors);
if (result.Errors.ContainsError() || result.Errors.ContainsWarning())
{
return result;
}
State = state;
var documentResult = Document(_ast);
result.Output = documentResult.Buffer.ToString();
result.Errors.AddRange(documentResult.Errors);
return result;
}
public ProcessTemplateSelector()
{
TemplateDictionary.Add("Default", () => new DefaultProcessTemplate());
TemplateDictionary.Add("Custom", () => new CustomProcessTemplate());
}
/// <summary>
/// UseTemplates- Adds templateDictionary to templateManager
/// </summary>
/// <param name="bot"></param>
/// <param name="templates"></param>
/// <returns></returns>
public static Bot UseTemplates(this Bot bot, TemplateDictionary templates)
{
return(bot.Use(new DictionaryRenderer(templates)));
}
public void LogicalAndWithLogicalOrYieldsProperBooleanResult()
{
var dict = new TemplateDictionary();
const string template1 = "#if (($foo == null || $bar == null) || ($baz != 'bing!')) true #else false #end";
var result1 = Template.ImmediateApply(dict, template1);
Assert.False(result1.Errors.ContainsError());
Assert.AreEqual(" true ", result1.Output);
var result2 = Template.CompileAndRun("test", template1, dict);
Assert.False(result2.Errors.ContainsError());
Assert.AreEqual(" true ", result2.Output);
}
public void should_return_the_value_when_the_start_and_end_parts_are_found()
{
Assert.AreEqual("bob", TemplateDictionary.get_token_value("<property name=\"bob\" value=\"$bill\" />", "name=\"", "\""));
}
public void should_return_nothing_when_the_value_when_the_end_is_not_found()
{
Assert.AreEqual(string.Empty, TemplateDictionary.get_token_value("<property name=\"bob\" value=\"$bill\" />", "name=\"", "Z"));
}
public void SeeminglyBadPound()
{
var dict = new TemplateDictionary
{
{"decimal", (decimal) 1.2},
{"double", 1.2}
};
const string exp = "#foo";
var result1 = Template.ImmediateApply(dict, exp);
Assert.IsFalse(result1.Errors.ContainsError());
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.AreEqual("#foo", result1.Output);
var result2 = Template.CompileAndRun("test", exp, dict);
Assert.IsFalse(result2.Errors.ContainsError());
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.AreEqual("#foo", result2.Output);
}
public DictionaryRenderer(TemplateDictionary templates)
{
this.languages = templates;
}
public void SeemsBadButIsOkParens()
{
var dict = new TemplateDictionary
{
{"decimal", (decimal) 1.2},
{"double", 1.2}
};
const string exp = "$($decimal) + $double)";
var result1 = Template.ImmediateApply(dict, exp);
Assert.IsFalse(result1.Errors.ContainsError());
Assert.IsFalse(result1.Errors.ContainsWarning());
Assert.AreEqual("1.2 + 1.2)", result1.Output);
var result2 = Template.CompileAndRun("test", exp, dict);
Assert.IsFalse(result2.Errors.ContainsError());
Assert.IsFalse(result2.Errors.ContainsWarning());
Assert.AreEqual("1.2 + 1.2)", result2.Output);
}
