public void FuncDependency()
{
var expr = VCExpression.ParseDefault("1 + f()", ("f", _ => 1));
var deps = expr.Expression.Dependencies.ToList();
Assert.That(deps, Is.EquivalentTo(new IDependency[] { new FuncDependency("f") }));
}
public void NoDependency()
{
var expr = VCExpression.ParseDefault("1 + 1");
var deps = expr.Expression.Dependencies.ToList();
Assert.That(deps, Is.Empty);
}
public void MixedDependencies()
{
var expr = VCExpression.ParseDefault("A ? now() : today()");
var deps = expr.Expression.Dependencies.ToList();
Assert.That(deps, Is.EquivalentTo(new IDependency[] { new PropDependency("A"), TemporalDependency.Now, TemporalDependency.Today }));
}
public static List <ParseResult <object> > ParseMultiple(string exprString)
{
return(new List <ParseResult <object> >
{
VCExpression.ParseDefault(exprString),
CSharpExpression.ParseMethod(exprString)
});
}
public void PropertyDeps(string exprString, params string[] deps)
{
var expr = VCExpression.ParseDefault(exprString);
var depList = expr.Expression.Dependencies.ToList();
Assert.That(depList, Is.All.TypeOf <PropDependency>());
var propDefs = depList.OfType <PropDependency>().ToList();
Assert.That(propDefs.Select(p => p.Name), Is.EquivalentTo(deps));
}
public void ParseErrorTest(string exprString, string exprError)
{
var parseResult = VCExpression.ParseDefault(exprString);
Assert.That(parseResult.Success, Is.False);
var exprMessage = string.Join(
"\n",
parseResult.ParseErrors.Select(e => e.GetExprError(exprString)));
Assert.That(exprMessage, Is.EqualTo(exprError));
}
public void AccessValueInDictionary()
{
var expr = VCExpression.ParseDefault(
"(a + b) * c");
var dic = new Dictionary <string, object>
{
{ "a", 10 },
{ "b", 5 },
{ "c", 3 }
};
var result = expr.Expression.Evaluate(dic);
Assert.That(result, Is.EqualTo(45));
}
public void EvalLegacyMathFunction(string exprString, object expected)
{
var funcs = new DefaultFunctions <object>();
funcs.Register("GetValue", (a, b) => Convert.ToDouble(a[1]));
var parseResult = VCExpression.ParseDefault(exprString, funcs);
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(expected));
var funcs2 = new DefaultCSharpFunctions();
funcs2.Register("GetValue", (a, b) => $"Convert.ToDouble({a[1]})");
var parseResult2 = CSharpExpression.ParseMethod(exprString, funcs2);
var expr2 = parseResult2.Expression;
var result2 = expr2.Evaluate(new { });
Assert.That(result2, Is.EqualTo(expected));
}
public void AccessDictionaryInDictionary_WithOverride()
{
var expr = VCExpression.ParseDefault(
"let x = a + b.b_value in x");
var dic = new Dictionary <string, object>
{
{ "a", 10 },
{
"b",
new Dictionary <string, object>()
{
{ "b_value", 5 }
}
}
};
var result = expr.Expression.Evaluate(dic);
Assert.That(result, Is.EqualTo(15));
}
public void AccessDictionaryInDictionary_WithOtherCalculation()
{
var expr = VCExpression.ParseDefault(
"(a + b.b_value) ^ 2 * c + 25");
var dic = new Dictionary <string, object>
{
{ "a", 10 },
{
"b",
new Dictionary <string, object>()
{
{ "b_value", 5 }
}
},
{ "c", 3 }
};
var result = expr.Expression.Evaluate(dic);
Assert.That(result, Is.EqualTo(700));
}
