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)); }