public void EvalUnitDExpr( object sD, object optionEquivSplitPos, object expected, string exprString) { var o = new { P = sD, O = optionEquivSplitPos }; Maybe <object> result = null; var parser = VCExpression.MaybeParser(); var sw = Stopwatch.StartNew(); var pr = parser.Parse(exprString); var parseTime = sw.Elapsed; sw.Restart(); for (var i = 0; i < 50; i++) { result = pr.Expression.Evaluate(o); } var evalTime = sw.Elapsed; Assert.That(result.Value, Is.EqualTo(expected)); Console.WriteLine("Parse: " + parseTime.TotalMilliseconds + "ms"); Console.WriteLine("Eval: " + evalTime.TotalMilliseconds * 20 + "µs"); }
public void StringLetGuard(double a, double l, string expected) { var exprStr = @" let p = a / l in (match | p < 0.5 = 'Low' | p < 0.75 = 'Normal' | p < 1.0 = 'Near Breach' | p < 1.25 = 'Breach' | otherwise 'Critical') "; var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new { a, l }); Assert.That(result.HasValue); Assert.That(result.Value, Is.EqualTo(expected)); foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { var expr2 = parseResult.Expression; var result2 = expr2.Evaluate(new { a, l }); Assert.That(result2, Is.EqualTo(expected)); } }
private void CompareMaybeNone(string exprString, object o = null) { var expr = VCExpression.ParseMaybe(exprString).Expression; var result = expr.Evaluate(o ?? new { }); Assert.That(result.HasValue, Is.EqualTo(false)); }
public void GuardWithoutOtherwise(double a, double expected) { var exprStr = @" match | A < 0.03 = 0.01 | A < 0.1 = 0.05 | A < 0.225 = 0.15 | A < 0.4 = 0.3 | A < 0.6 = 0.5 | A < 0.775 = 0.7 | A < 0.9 = 0.85 | A < 0.97 = 0.95 | A >= 0.97 = 0.99"; var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new { A = a }); Assert.That(result.HasValue); Assert.That(result.Value, Is.EqualTo(expected)); foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { var expr2 = parseResult.Expression; var result2 = expr2.Evaluate(new { A = a }); Assert.That(result2, Is.EqualTo(expected)); } }
public void TernaryMaybeNone(string exprStr, object a, object b, object c) { var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new { A = a, B = b, C = c }); Assert.That(result.HasValue, Is.False); }
public void NaNTest() { var expr = VCExpression.ParseMaybe("A / B / C * 100"); var res = expr.Expression.Evaluate(new { A = 1.0, B = 1.0, C = double.NaN }); Assert.That(res.Value, Is.EqualTo(double.NaN)); }
public void NoDependency() { var expr = VCExpression.ParseDefault("1 + 1"); var deps = expr.Expression.Dependencies.ToList(); Assert.That(deps, Is.Empty); }
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 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 CompareNoneAfterPropertyCache() { var o = new { }; var expr = VCExpression.ParseMaybe("A + B"); expr.Expression.Evaluate(o); // First Eval to Cache Property Infos var res = expr.Expression.Evaluate(o); Assert.That(res.HasValue, Is.False); }
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 InInvalid(string exprString) { foreach (var parseResult in CompositeExpression.ParseMultiple(exprString)) { Assert.False(parseResult.Success); } var parsedMaybe = VCExpression.ParseMaybe(exprString); Assert.False(parsedMaybe.Success); }
public void InMaybe(string exprString) { foreach (var parseResult in CompositeExpression.ParseMultiple(exprString)) { Assert.True(parseResult.Success); } var parsedMaybe = VCExpression.ParseMaybe(exprString); Assert.True(parsedMaybe.Success); var maybeResult = parsedMaybe.Expression.Evaluate(new { }); Assert.False(maybeResult.HasValue); }
public void TernaryOp(string exprStr, object a, object b, object c, object expected) { var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new { A = a, B = b, C = c }); Assert.That(result.HasValue); Assert.That(result.Value, Is.EqualTo(expected)); foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { var expr2 = parseResult.Expression; var result2 = expr2.Evaluate(new { A = a, B = b, C = c }); Assert.That(result2, Is.EqualTo(expected)); } }
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 LetOp() { var exprStr = "let x = 1, y = 2 in x + y"; var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new object()); Assert.That(result.HasValue); Assert.That(result.Value, Is.EqualTo(3)); foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { var expr2 = parseResult.Expression; var result2 = expr2.Evaluate(new object()); Assert.That(result2, Is.EqualTo(3)); } }
private void Compare(string exprString, bool expected, object o = null) { foreach (var parseResult in CompositeExpression.ParseMultiple(exprString)) { Assert.True(parseResult.Success, "Default expression parse"); var result = parseResult.Expression.Evaluate(o ?? new { }); Assert.That(result, Is.EqualTo(expected).Within(0.0001), "Default expression evaluated"); } var maybeExpr = VCExpression.ParseMaybe(exprString); Assert.True(maybeExpr.Success, "Maybe expression parse"); var maybeResult = maybeExpr.Expression.Evaluate(o ?? new { }); Assert.True(maybeResult.HasValue, "Maybe expression evaluate has value"); Assert.That(maybeResult.Value, Is.EqualTo(expected).Within(0.0001), "Maybe expression evaluated"); }
private void CompareResult(string exprString, bool expected, object o) { foreach (var parseResult in CompositeExpression.ParseMultiple(exprString)) { Assert.True(parseResult.Success); var result = parseResult.Expression.Evaluate(o ?? new { }); Assert.AreEqual(expected, result); } var maybeExpr = VCExpression.ParseMaybe(exprString); Assert.True(maybeExpr.Success); var maybeResult = maybeExpr.Expression.Evaluate(o ?? new { }); Assert.True(maybeResult.HasValue); Assert.AreEqual(expected, maybeResult.Value); }
public void TernaryNullCase(string exprStr, object a, object c) { var expr = VCExpression.ParseMaybe(exprStr).Expression; var result = expr.Evaluate(new { A = a }); Assert.That(result.HasValue, Is.True); if (result.HasValue) { Assert.AreEqual(c, result.Value); } foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { var expr2 = parseResult.Expression; var result2 = expr2.Evaluate(new { A = a }); Assert.AreEqual(result2, c); } }
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)); }
public void ShouldEvaluate(string exprStr, object expected) { foreach (var parseResult in CompositeExpression.ParseMultiple(exprStr)) { Assert.That(parseResult.Success, Is.True, "Is successful"); var expr = parseResult.Expression; var result = expr.Evaluate(new { }); Assert.That(result, Is.EqualTo(expected)); } var parseResult2 = VCExpression.ParseMaybe(exprStr); Assert.That(parseResult2.Success, Is.True, "Is successful"); var expr2 = parseResult2.Expression; var result2 = expr2.Evaluate(new { }); Assert.That(result2.HasValue, Is.True, "Have value"); Assert.That(result2.Value, Is.EqualTo(expected)); }
public void Eval(string exprStr, bool hasValue = false, object expected = null) { // Verifies that these expressions all return Maybe.Nothing when called with an empty expression var parseResult = VCExpression.ParseMaybe(exprStr); if (!parseResult.Success) { var errorString = string.Join("\n", parseResult.ParseErrors.Select(p => $"Error parsing at token '{p.Token}' in {p.GetExprError(exprStr)}")); Console.WriteLine(errorString); } Assert.That(parseResult.Success, Is.True); var expr = parseResult.Expression; var result = expr.Evaluate(new { }); Assert.That(result.HasValue, Is.EqualTo(hasValue)); if (hasValue) { Assert.That(result.Value, Is.EqualTo(expected)); } }