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