public void InferredScopeVariableCallsOnAdding()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject globalObject = new SimpleExpressionResolverDataObject(1, "Top Object", 2.2);
SimpleExpressionResolverDataObject templateMyScopeObject = new SimpleExpressionResolverDataObject(2, "My Template", 3.2);
SimpleExpressionResolverDataObject curLoopScopeObject = new SimpleExpressionResolverDataObject(3, "Current to loop", 5.2);
string globalKey = "foo";
string templateKey = "My";
string loopKey = "Cur";
string expression = "${MyString}";
string globalExpression = "${foo.MyString}";
SampleSimpleDataControl ctlGlobal = new SampleSimpleDataControl(globalObject);
dc.RegisterDataItem(globalKey, ctlGlobal);
string result = dc.CalculateVariableValue(globalExpression);
Assert.AreEqual(globalObject.MyString, result, "Global object wrong");
dc.RegisterLocalValue(templateKey, templateMyScopeObject);
result = dc.CalculateVariableValue(expression);
Assert.IsFalse(string.IsNullOrEmpty(result), "Scope value is null");
Assert.AreEqual(templateMyScopeObject.MyString, result, "Template scoped item wrong");
dc.RegisterLocalValue(loopKey, curLoopScopeObject);
result = dc.CalculateVariableValue(expression);
Assert.IsFalse(string.IsNullOrEmpty(result), "Scope value is null in loop");
Assert.AreEqual(curLoopScopeObject.MyString, result, "Loop scoped item wrong");
}
public void GlobalRegisteredSimpleValueResolution()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject globalData =
new SimpleExpressionResolverDataObject(10, "I am a beast", 2.2);
string globalKey = "foo";
string localKey = "babar";
string expGlobalStr = "${foo.MyString}";
string expGlobalInt = "${foo.MyInt}";
string expGlobalFloat = "${foo.MyFloat}";
Assert.IsNull(dc.CalculateVariableValue(expGlobalStr));
Assert.IsNull(dc.CalculateVariableValue(expGlobalInt));
Assert.IsNull(dc.CalculateVariableValue(expGlobalFloat));
dc.RegisterDataItem(globalKey, globalData);
Assert.IsNotEmpty(dc.CalculateVariableValue(expGlobalStr));
Assert.IsNotEmpty(dc.CalculateVariableValue(expGlobalInt));
Assert.IsNotEmpty(dc.CalculateVariableValue(expGlobalFloat));
Assert.AreEqual(globalData.MyString, dc.CalculateVariableValue(expGlobalStr));
Assert.AreEqual(globalData.MyInt.ToString(), dc.CalculateVariableValue(expGlobalInt));
Assert.AreEqual(globalData.MyFloat.ToString(), dc.CalculateVariableValue(expGlobalFloat));
}
public void ListDataIndexExpression()
{
DataContext dc = new DataContext();
List <SimpleExpressionResolverDataObject> listData = new List <SimpleExpressionResolverDataObject>();
SimpleExpressionResolverDataObject expectedData = new SimpleExpressionResolverDataObject(12, "I love milk", 12.2);
listData.Add(expectedData);
//SampleSimpleDataControl ctlList = new SampleSimpleDataControl(listData);
string key = "foo";
string expression = "${foo[0].MyString}";
dc.RegisterDataItem(key, listData);
string result = dc.CalculateVariableValue(expression);
Assert.IsNotNull(result, "List result is null");
Assert.IsFalse(string.IsNullOrEmpty(result));
Assert.AreEqual(expectedData.MyString, result, "Calculated value does not match");
string result2 = dc.GetVariableValue(expression);
Assert.AreEqual(result, result2, "Two entry points are not resolving the same");
}
public void NestedExpresionEvaluatorObjects()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject innerData =
new SimpleExpressionResolverDataObject(10, "I am a beast", 2.2);
ComplexExpressionResolverDataObject outerObject =
new ComplexExpressionResolverDataObject("Hello Outer", innerData);
string key = "xdata";
string expOuterStr = AsKey(key + ".MyString");
string expNestedStr = AsKey(key + ".nested.MyString");
string expNestedObject = AsKey(key + ".nested");
Assert.IsNull(dc.CalculateVariableValue(expOuterStr));
Assert.IsNull(dc.CalculateVariableValue(expNestedStr));
dc.RegisterDataItem(key, outerObject);
Assert.IsNotNull(dc.CalculateVariableValue(expOuterStr));
Assert.IsNotNull(dc.CalculateVariableValue(expNestedStr));
Assert.AreEqual(outerObject.MyString, dc.CalculateVariableValue(expOuterStr));
Assert.AreEqual(innerData.MyString, dc.CalculateVariableValue(expNestedStr));
Assert.IsNull(dc.CalculateVariableValue(expNestedObject), "Object reference is incorrectly not null for string eval");
}
public void ExpressionModuloValue()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject data = new SimpleExpressionResolverDataObject(12, "I love milk", 12.2);
int expectedValue = data.MyInt % 2;
string key = "foo";
string expression = "${foo.MyInt % 2}";
dc.RegisterDataItem(key, data);
Assert.IsTrue(TestExpressionEvaluation(dc, expectedValue, expression));
}
public void ExpressionDividesOddValue()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject data = new SimpleExpressionResolverDataObject(13, "I love milk", 12.2);
double expectedValue = (double)data.MyInt / 2;
string key = "foo";
string expression = "${foo.MyInt / 2}";
dc.RegisterDataItem(key, data);
Assert.IsTrue(TestExpressionEvaluation(dc, expectedValue, expression));
}
public void PrivateParameterListDeepReferenceResolves()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject fooData =
new SimpleExpressionResolverDataObject(10, "I am a beast", 2.2);
SimpleExpressionResolverDataObject barData =
new SimpleExpressionResolverDataObject(12, "I love milk", 12.2);
List <SimpleExpressionResolverDataObject> items = new List <SimpleExpressionResolverDataObject>();
items.Add(fooData);
items.Add(barData);
string expression = "${My.list[0].MyString}";
string expressionInt = "${My.list[0].MyInt}";
string expressionInferred = "${list[0].MyString}";
Assert.IsNull(dc.CalculateVariableValue(expression));
Assert.IsNull(dc.CalculateVariableValue(expressionInt));
Assert.IsNull(dc.CalculateVariableValue(expressionInferred));
Assert.IsNull(dc.CalculateVariableValue("${My}"));
string privateKey = "My";
Dictionary <string, object> paramDict = new Dictionary <string, object>();
paramDict.Add("list", items);
dc.RegisterLocalValue(privateKey, paramDict);
Assert.IsNotNull(dc.CalculateVariableValue("${My}"));
Assert.IsNotNull(dc.CalculateVariableValue(expression), "Deep expression is null: " + expression);
Assert.IsNotEmpty(dc.CalculateVariableValue(expression));
Assert.IsNotNull(dc.CalculateVariableValue(expressionInferred), "Inferred variable failed to resolve: " + expressionInferred);
Assert.AreEqual(fooData.MyString, dc.CalculateVariableValue(expression));
Assert.AreEqual(fooData.MyString, dc.CalculateVariableValue(expressionInferred));
Assert.AreEqual(fooData.MyInt.ToString(), dc.CalculateVariableValue(expressionInt));
//and remove
dc.RemoveLocalValue(privateKey);
Assert.IsNull(dc.CalculateVariableValue(expression));
Assert.IsNull(dc.CalculateVariableValue(expressionInferred));
}
public void MixedDataLiteralEquivilencyEvaluations(int dataIntVal, double dataDoubleVal, string expression, bool expectedResult)
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject dataObject
= new SimpleExpressionResolverDataObject(dataIntVal, "Top Object", dataDoubleVal);
string key = "foo";
dc.RegisterDataItem(key, dataObject);
ResolvedExpression result = Engine.ResolveExpression(expression, dc);
Assert.AreEqual(ResolvedExpression.booleanType, result.ResolvedType);
Assert.AreEqual(expectedResult, result.ResolvedValue, "Expression did not evalute: " + expression);
}
public void CompareTwoVariableValues()
{
DataContext dc = new DataContext();
int expectedInt = 9;
SimpleExpressionResolverDataObject fooData =
new SimpleExpressionResolverDataObject(expectedInt, "I am a beast", 2.2);
SimpleExpressionResolverDataObject barData =
new SimpleExpressionResolverDataObject(expectedInt, "I love milk", 12.2);
string fooKey = "foo";
string barKey = "babar";
string expFooInt = "${foo.MyInt}";
string expBarInt = "${babar.MyInt}";
string comparisonExpression = "${foo.MyInt == babar.MyInt}";
Assert.IsNull(dc.CalculateVariableValue(expFooInt));
Assert.IsNull(dc.CalculateVariableValue(expBarInt));
dc.RegisterDataItem(fooKey, fooData);
Assert.IsNotNull(dc.CalculateVariableValue(expFooInt));
dc.RegisterDataItem(barKey, barData);
Assert.IsNotNull(dc.CalculateVariableValue(expBarInt));
Assert.AreEqual(fooData.MyInt.ToString(), dc.CalculateVariableValue(expFooInt));
Assert.AreEqual(expectedInt.ToString(), dc.CalculateVariableValue(expFooInt));
Assert.AreEqual(barData.MyInt.ToString(), dc.CalculateVariableValue(expBarInt));
Assert.AreEqual(expectedInt.ToString(), dc.CalculateVariableValue(expBarInt));
string bCalculated = dc.CalculateVariableValue(comparisonExpression);
bool result;
Assert.IsTrue(Boolean.TryParse(bCalculated, out result));
Assert.IsTrue(result, "Parsed boolean return value was not true");
}
/// <summary>
/// Builds a sample data context with test data
/// </summary>
/// <returns></returns>
DataContext BuildTestDataContext(SimpleExpressionResolverDataObject data)
{
DataContext dc = new DataContext();
IResourceBundle resource = new GenericResourceBundle();
resource.AddString("Hello", "hello world");
dc.AddResourceBundle(resource);
resource = new GenericResourceBundle("es");
resource.AddString("Hello", "hola mundo");
dc.AddResourceBundle(resource);
dc.RegisterDataItem("xdata", data);
return(dc);
}
public void ListWithSelectorsResolution()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject fooData =
new SimpleExpressionResolverDataObject(9, "bob", 2.2);
SimpleExpressionResolverDataObject barData =
new SimpleExpressionResolverDataObject(12, "steve", 12.2);
SimpleExpressionResolverDataObject zooData =
new SimpleExpressionResolverDataObject(10, "kim", 2.2);
List <IExpressionEvaluator> dataList = new List <IExpressionEvaluator>();
dataList.Add(fooData);
dataList.Add(barData);
dataList.Add(zooData);
string listKey = "fooList";
string expIndexFooStr = "${fooList[0].MyString}";
string expSelectorBarInt = "${fooList[@MyString='steve'].MyInt}";
string expSelectorBarStr = "${fooList[@MyString='kim'].MyString}";
Assert.IsNull(dc.CalculateVariableValue(listKey));
Assert.IsNull(dc.CalculateVariableValue(expIndexFooStr));
Assert.IsNull(dc.CalculateVariableValue(expSelectorBarStr));
dc.RegisterDataItem(listKey, dataList);
Assert.IsNotNull(dc.CalculateVariableObjectValue(listKey));
string result = dc.CalculateVariableValue(expIndexFooStr);
Assert.AreEqual("bob", result, "Index get from list failed");
result = dc.CalculateVariableValue(expSelectorBarInt);
Assert.AreEqual("12", result, "Selector get from list failed");
result = dc.CalculateVariableValue(expSelectorBarStr);
Assert.AreEqual("kim", result, "Selector get from list failed");
}
/// <summary>
/// Builds a sample data context with test data
/// </summary>
/// <returns></returns>
DataContext BuildTestDataContext(SimpleExpressionResolverDataObject data)
{
DataContext dc = new DataContext();
IResourceBundle resource = new GenericResourceBundle();
resource.AddString("Hello", "hello world");
resource.AddString("embedded", "I can say ${Msg.Hello}");
resource.AddString("triple", "Some people think they need to say: ${Msg.embedded}");
dc.AddResourceBundle(resource);
resource = new GenericResourceBundle("es");
resource.AddString("Hello", "hola mundo");
dc.AddResourceBundle(resource);
dc.RegisterDataItem("xdata", data);
return(dc);
}
public void LocalRegisteredVariableParameterDictionaryResolution()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject fooData =
new SimpleExpressionResolverDataObject(10, "I am a beast", 2.2);
SimpleExpressionResolverDataObject barData =
new SimpleExpressionResolverDataObject(12, "I love milk", 12.2);
string fooKey = "foo";
string barKey = "babar";
string expFooStr = "${foo.MyString}";
string expFooInt = "${foo.MyInt}";
string expFooFloat = "${foo.MyFloat}";
string expBarStr = "${babar.MyString}";
string expBarInt = "${babar.MyInt}";
string expBarFloat = "${babar.MyFloat}";
string dictFooKey = "dfoo";
string dictBarKey = "dbar";
string localKey = "loco";
string expLocalFoo = string.Format("{0}{1}.{2}.##prop##{3}",
new string[] {
DataContext.VARIABLE_START,
localKey, dictFooKey,
DataContext.VARIABLE_END
});
string expLocalFooString = expLocalFoo.Replace("##prop##", "MyString");
string expLocalFooInt = expLocalFoo.Replace("##prop##", "MyInt");
string expLocalBarString = expLocalFooString.Replace(dictFooKey, dictBarKey);
string expLocalBarInt = expLocalFooInt.Replace(dictFooKey, dictBarKey);
Assert.IsNull(dc.CalculateVariableValue(expFooStr));
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
dc.RegisterDataItem(fooKey, fooData);
Assert.IsNotNull(dc.CalculateVariableValue(expFooStr));
Assert.IsNotEmpty(dc.CalculateVariableValue(expFooStr));
dc.RegisterDataItem(barKey, barData);
Assert.IsNotNull(dc.CalculateVariableValue(expBarStr));
Assert.IsNotNull(dc.CalculateVariableValue(expBarInt));
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
//now register the parameters
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add(dictFooKey, "${" + fooKey + "}");
parameters.Add(dictBarKey, "${" + barKey + "}");
dc.RegisterLocalValue(localKey, parameters);
Assert.IsNotEmpty(dc.CalculateVariableValue(expLocalFooString));
Assert.IsNotEmpty(dc.CalculateVariableValue(expLocalBarString));
Assert.IsNotNull(dc.CalculateVariableValue(expLocalFooString));
Assert.IsNotNull(dc.CalculateVariableValue(expLocalBarString));
Assert.AreEqual(fooData.MyString, dc.CalculateVariableValue(expLocalFooString));
Assert.AreEqual(fooData.MyInt.ToString(), dc.CalculateVariableValue(expLocalFooInt));
Assert.AreEqual(barData.MyString, dc.CalculateVariableValue(expLocalBarString));
Assert.AreEqual(barData.MyInt.ToString(), dc.CalculateVariableValue(expLocalBarInt));
//and remove
dc.RemoveLocalValue(localKey);
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
}
public void InferredScopeParents()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject globalObject = new SimpleExpressionResolverDataObject(1, "Top Object", 2.2);
SimpleExpressionResolverDataObject templateValScopeObject = new SimpleExpressionResolverDataObject(2, "My Template", 3.2);
SimpleExpressionResolverDataObject nestObject = new SimpleExpressionResolverDataObject(5, "Nest Temp", 5.5);
Dictionary <string, object> nestedMyObject = new Dictionary <string, object>();
nestedMyObject.Add("nest", nestObject);
nestedMyObject.Add("simple", "value");
nestedMyObject.Add("one", 1);
Dictionary <string, object> templateMyObject = new Dictionary <string, object>();
templateMyObject.Add("val", templateValScopeObject);
templateMyObject.Add("x", "X");
SimpleExpressionResolverDataObject curLoopScopeObject = new SimpleExpressionResolverDataObject(3, "Current to loop", 5.2);
Dictionary <string, object> thirdMyObject = new Dictionary <string, object>();
thirdMyObject.Add("outer", "outside");
thirdMyObject.Add("two", "2");
thirdMyObject.Add("one", "All the way");
string globalKey = "foo";
string templateKey = "My";
//string fullParent = "${" + parentKey +
SampleSimpleDataControl ctlGlobal = new SampleSimpleDataControl(globalObject);
//Nest number 1
dc.RegisterDataItem(globalKey, ctlGlobal);
dc.RegisterLocalValue(templateKey, nestedMyObject);
Assert.AreEqual("value", dc.CalculateVariableValue("${My.simple}"));
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableObjectValue("${My.nest.MyString}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableObjectValue("${nest.MyString}"));
//Nest #2
dc.RegisterLocalValue(templateKey, templateMyObject);
Assert.AreNotEqual("value", dc.CalculateVariableValue("${My.simple}"), "Explicit scope My.simple should now be empty");
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"), "Inferred simple in Parent is failing");
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
Assert.AreEqual("1", dc.CalculateVariableValue("${one}"));
Assert.AreEqual("X", dc.CalculateVariableValue("${My.x}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableValue("${nest.MyString}"), "Parent nested object failing");
//Nest #3
dc.RegisterLocalValue(templateKey, thirdMyObject);
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"), "Inferred simple in Parent.Parent is failing");
Assert.AreEqual("value", dc.CalculateVariableValue("${My.Parent.Parent.simple}"), "Explicit scope not working");
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${two}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${My.two}"));
Assert.AreEqual("All the way", dc.CalculateVariableValue("${one}"));
Assert.AreEqual("1", dc.CalculateVariableValue("${My.Parent.Parent.one}"));
//Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
//Unregister
dc.RemoveLocalValue(templateKey);
Assert.IsTrue(string.IsNullOrEmpty(dc.CalculateVariableValue("${two}")), "Remove outer didn't erase value");
Assert.AreEqual("X", dc.CalculateVariableValue("${My.x}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"), "Parent objects not re-registering");
Assert.AreEqual("1", dc.CalculateVariableValue("${one}"));
}
public void LocalRegisteredListResolution()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject fooData =
new SimpleExpressionResolverDataObject(10, "I am a beast", 2.2);
SimpleExpressionResolverDataObject barData =
new SimpleExpressionResolverDataObject(12, "I love milk", 12.2);
string fooKey = "foo";
string barKey = "babar";
string expFooStr = "${foo.MyString}";
string expFooInt = "${foo.MyInt}";
string expFooFloat = "${foo.MyFloat}";
string expBarStr = "${babar.MyString}";
string expBarInt = "${babar.MyInt}";
string expBarFloat = "${babar.MyFloat}";
string localKey = "loco";
string expressionBase = AsKey(localKey + "[##index##].##prop##");
string expLocalFoo = expressionBase.Replace("##index##", "0");
string expLocalBar = expressionBase.Replace("##index##", "1");
string expLocalFooString = expLocalFoo.Replace("##prop##", "MyString");
string expLocalFooInt = expLocalFoo.Replace("##prop##", "MyInt");
string expLocalBarString = expLocalBar.Replace("##prop##", "MyString");
string expLocalBarInt = expLocalBar.Replace("##prop##", "MyInt");
Assert.IsNull(dc.CalculateVariableValue(expFooStr));
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
dc.RegisterDataItem(fooKey, fooData);
Assert.IsNotNull(dc.CalculateVariableValue(expFooStr));
Assert.IsNotEmpty(dc.CalculateVariableValue(expFooStr));
dc.RegisterDataItem(barKey, barData);
Assert.IsNotNull(dc.CalculateVariableValue(expBarStr));
Assert.IsNotNull(dc.CalculateVariableValue(expBarInt));
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
//now register the parameters
ArrayList localList = new ArrayList();
localList.Add(fooData);
localList.Add(barData);
dc.RegisterLocalValue(localKey, localList);
Assert.IsNotEmpty(dc.CalculateVariableValue(expLocalFooString));
Assert.IsNotEmpty(dc.CalculateVariableValue(expLocalBarString));
Assert.IsNotNull(dc.CalculateVariableValue(expLocalFooString));
Assert.IsNotNull(dc.CalculateVariableValue(expLocalBarString));
Assert.AreEqual(fooData.MyString, dc.CalculateVariableValue(expLocalFooString));
Assert.AreEqual(fooData.MyInt.ToString(), dc.CalculateVariableValue(expLocalFooInt));
Assert.AreEqual(barData.MyString, dc.CalculateVariableValue(expLocalBarString));
Assert.AreEqual(barData.MyInt.ToString(), dc.CalculateVariableValue(expLocalBarInt));
//and remove
dc.RemoveLocalValue(localKey);
Assert.IsNull(dc.CalculateVariableValue(expLocalFooString));
}
