protected override void Translate()
{
if (Context.ActiveParentCommandBlock != null)
{
//If a parent command block is already present, just translate the expression and return it
_generatedExpression = translate_Expression(RootParseNode);
return;
}
//If there is no parent command block yet, create a composite expression command block
var newCompositeExpr = CompositeExpression.Create(Context.ActiveParentScope);
Context.PushState(newCompositeExpr.ChildCommandBlockScope);
//Begin translation of the expression
var finalExpr = translate_Expression(RootParseNode);
//If there is any command in the composite expression, create and set the output local variable
newCompositeExpr.OutputVariable = newCompositeExpr.ExpressionToLocalVariable(finalExpr);
//Return the whole composite expression as the translated language expression
_generatedExpression = newCompositeExpr;
Context.PopState();
}
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 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));
}
}
public void AndExpressionTest()
{
CompositeExpression compositeExpression = new CompositeExpression(QueryOperator.And)
{
Expressions = new List <QueryExpression>
{
new BooleanQueryExpression(QueryOperator.Exists, new List <PathFilter>
{
new FieldFilter("FirstName")
}, null),
new BooleanQueryExpression(QueryOperator.Exists, new List <PathFilter>
{
new FieldFilter("LastName")
}, null)
}
};
var o1 = JsonDocument.Parse("{\"Title\":\"Title!\",\"FirstName\":\"FirstName!\",\"LastName\":\"LastName!\"}").RootElement;
Assert.True(compositeExpression.IsMatch(o1, o1));
var o2 = JsonDocument.Parse("{\"Title\":\"Title!\",\"FirstName\":\"FirstName!\"}").RootElement;
Assert.False(compositeExpression.IsMatch(o2, o2));
var o3 = JsonDocument.Parse("{\"Title\":\"Title!\"}").RootElement;
Assert.False(compositeExpression.IsMatch(o3, o3));
}
public void FilterExistWithAndOr()
{
JPath path = new JPath("[?(@.name&&@.title||@.pie)]");
CompositeExpression andExpression = (CompositeExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(QueryOperator.And, andExpression.Operator);
Assert.AreEqual(2, andExpression.Expressions.Count);
var first = (BooleanQueryExpression)andExpression.Expressions[0];
var firstPaths = (List <PathFilter>)first.Left;
Assert.AreEqual("name", ((FieldFilter)firstPaths[0]).Name);
Assert.AreEqual(QueryOperator.Exists, first.Operator);
CompositeExpression orExpression = (CompositeExpression)andExpression.Expressions[1];
Assert.AreEqual(2, orExpression.Expressions.Count);
var orFirst = (BooleanQueryExpression)orExpression.Expressions[0];
var orFirstPaths = (List <PathFilter>)orFirst.Left;
Assert.AreEqual("title", ((FieldFilter)orFirstPaths[0]).Name);
Assert.AreEqual(QueryOperator.Exists, orFirst.Operator);
var orSecond = (BooleanQueryExpression)orExpression.Expressions[1];
var orSecondPaths = (List <PathFilter>)orSecond.Left;
Assert.AreEqual("pie", ((FieldFilter)orSecondPaths[0]).Name);
Assert.AreEqual(QueryOperator.Exists, orSecond.Operator);
}
/// <summary>
/// Convert the given expression into a local variable by adding an assignment command if necessary
/// and returning the lhs local variable of the assignment as the new atomic expression. If the given expression
/// is a local variable of this command block it is returned directly.
/// </summary>
/// <param name="commandBlock"></param>
/// <param name="expr"></param>
/// <returns></returns>
public static SymbolLocalVariable ExpressionToLocalVariable(this CompositeExpression commandBlock, ILanguageExpression expr)
{
SymbolLocalVariable localVariable;
//If expr is a local variable of the command block's child scope return the local variable
var valueAccess = expr as LanguageValueAccess;
if (valueAccess != null && valueAccess.IsFullAccessLocalVariable)
{
localVariable = valueAccess.RootSymbolAsLocalVariable;
if (localVariable.ParentScope.ObjectId == commandBlock.ChildScope.ObjectId)
{
return(localVariable);
}
}
//Else create a loical variable to hold value and return the local variable as a direct value access object
localVariable = commandBlock.DefineLocalVariable(expr.ExpressionType).LocalVariable;
var lhs = LanguageValueAccess.Create(localVariable);
commandBlock.AddCommand_Assign(lhs, expr);
return(localVariable);
}
public void GetAndEvaluateWhileExpression()
{
WhileExpression expression = WhileExpression.Instance;
Assert.IsNotNull(expression);
Machine machine = new Machine();
List <Expression> listcond = new List <Expression>();
listcond.Add(DupExpression.Instance);
listcond.Add(new IntegerExpression(0));
listcond.Add(EqualsExpression.Instance);
listcond.Add(NotExpression.Instance);
List <Expression> listblock = new List <Expression>();
listblock.Add(IntegerDecrementOperation.Instance);
CompositeExpression cond = new CompositeExpression(listcond);
CompositeExpression block = new CompositeExpression(listblock);
machine.Push(10);
machine.Push(block);
machine.Push(cond);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsInstanceOfType(machine.Top(), typeof(int));
Assert.AreEqual(0, machine.Pop());
}
public void CreateAndEvaluateQuotationExpression()
{
Machine machine = new Machine();
List <Expression> list = new List <Expression>();
list.Add(new IntegerExpression(1));
list.Add(new IntegerExpression(2));
list.Add(new IntegerExpression(3));
QuotationExpression expression = new QuotationExpression(list);
Assert.IsNotNull(expression);
Assert.IsNotNull(expression.Expressions);
Assert.AreEqual(3, expression.Expressions.Count);
Assert.AreEqual(0, machine.StackCount);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsInstanceOfType(machine.Top(), typeof(CompositeExpression));
CompositeExpression composite = (CompositeExpression)machine.Pop();
Assert.IsNotNull(composite);
Assert.AreEqual(3, composite.Expressions.Count);
}
private void Compare(string exprString, object expected)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var result = parseResult.Expression.Evaluate(new { });
Assert.That(result, Is.EqualTo(expected));
}
}
// Need to add invalid times
public void TestTimeSpan(string timeStr)
{
foreach (var expr in CompositeExpression.ParseMultiple(timeStr))
{
var result = expr.Expression.Evaluate(new { });
Assert.That(result, Is.EqualTo(TimeSpan.Parse(timeStr)));
}
}
// Need to add invalid dates
public void TestDateTimeOffset(string dateStr)
{
foreach (var expr in CompositeExpression.ParseMultiple(dateStr))
{
var result = expr.Expression.Evaluate(new { });
Assert.That(result, Is.EqualTo(DateTimeOffset.Parse(dateStr.Substring(1))));
}
}
public void TestPrimitives(string exprString, object expected)
{
foreach (var expr in CompositeExpression.ParseMultiple(exprString))
{
var result = expr.Expression.Evaluate(new { });
Assert.That(result, Is.EqualTo(expected));
}
}
private void CompareDefault(string exprString, bool expected, object o = null)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
Assert.True(parseResult.Success);
var result = parseResult.Expression.Evaluate(o ?? new { });
Assert.That(result, Is.EqualTo(expected).Within(0.0001));
}
}
public void EvalTotalDays(string exprString)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(1));
}
}
public void EvalLegacyTodayDay(string exprString)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(DateTime.Today.Day));
}
}
public void EvalMember(string exprString, object expected)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(expected));
}
}
public void Subtract(string exprString, int d, int h, int m, int s, int ms)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(new TimeSpan(d, h, m, s, ms)));
}
}
public void SubtractTimeFromDateTime(string exprString, int y, int mo, int d, int h, int m, int s, int ms)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(new DateTimeOffset(y, mo, d, h, m, s, ms, TimeSpan.Zero)));
}
}
public void EvalNullDependencyDefaultFunction(string exprString, object expected)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { A = (object)null });
Assert.That(result, Is.EqualTo(expected));
}
}
public void CompareIntervalExpression(string exprString, bool expectedResult)
{
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(expectedResult));
}
}
public void AndExpressionTest()
{
CompositeExpression compositeExpression = new CompositeExpression
{
Operator = QueryOperator.And,
Expressions = new List <QueryExpression>
{
new BooleanQueryExpression
{
Operator = QueryOperator.Exists,
Path = new List <PathFilter>
{
new FieldFilter
{
Name = "FirstName"
}
}
},
new BooleanQueryExpression
{
Operator = QueryOperator.Exists,
Path = new List <PathFilter>
{
new FieldFilter
{
Name = "LastName"
}
}
}
}
};
JObject o1 = new JObject
{
{ "Title", "Title!" },
{ "FirstName", "FirstName!" },
{ "LastName", "LastName!" }
};
Assert.IsTrue(compositeExpression.IsMatch(o1, o1));
JObject o2 = new JObject
{
{ "Title", "Title!" },
{ "FirstName", "FirstName!" }
};
Assert.IsFalse(compositeExpression.IsMatch(o2, o2));
JObject o3 = new JObject
{
{ "Title", "Title!" }
};
Assert.IsFalse(compositeExpression.IsMatch(o3, o3));
}
public void NullCheckSum(double cpv, double ppv, double expected)
{
var row = new { cpv = cpv, ppv = ppv };
foreach (var parseResult in CompositeExpression.ParseMultiple(Expressions.NullCheckSum))
{
var result = parseResult.Expression.Evaluate(row);
Assert.That(result, Is.EqualTo(expected).Within(0.000001));
}
}
public void Expr5LetGuardCompare(double p, double o, double expected)
{
var row = new { P = p, O = o };
foreach (var parseResult in CompositeExpression.ParseMultiple(Expressions.TestExpr5LetGuard))
{
var letGuardResult = parseResult.Expression.Evaluate(row);
Assert.That(letGuardResult, Is.EqualTo(expected).Within(0.000001));
}
}
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 EvalToday()
{
var exprString = "today()";
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var value = expr.Evaluate(new { });
Assert.That(value, Is.EqualTo(DateTime.Today));
}
}
public void EvalNow()
{
var exprString = "now()";
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var value = expr.Evaluate(new { });
Assert.That(value, Is.EqualTo(DateTime.Now).Within(TimeSpan.FromSeconds(1)));
}
}
public void EvalDateFunction(string exprString, string dateTime)
{
var expected = DateTimeOffset.Parse(dateTime);
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result = expr.Evaluate(new { });
Assert.That(result, Is.EqualTo(expected));
}
}
public void FilterExistWithAnd()
{
JPath path = new JPath("[?(@.name&&@.title)]");
CompositeExpression expressions = (CompositeExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(QueryOperator.And, expressions.Operator);
Assert.AreEqual(2, expressions.Expressions.Count);
Assert.AreEqual("name", ((FieldFilter)((BooleanQueryExpression)expressions.Expressions[0]).Path[0]).Name);
Assert.AreEqual(QueryOperator.Exists, expressions.Expressions[0].Operator);
Assert.AreEqual("title", ((FieldFilter)((BooleanQueryExpression)expressions.Expressions[1]).Path[0]).Name);
Assert.AreEqual(QueryOperator.Exists, expressions.Expressions[1].Operator);
}
public void ExecuteTwoAssignCommands()
{
Context context = new Context();
AssignExpression expr1 = new AssignExpression("one", new ConstantExpression(1));
AssignExpression expr2 = new AssignExpression("two", new ConstantExpression(2));
CompositeExpression expr = new CompositeExpression(new IExpression[] { expr1, expr2 });
var result = expr.Evaluate(context);
Assert.AreEqual(2, result);
Assert.AreEqual(1, context.GetValue("one"));
Assert.AreEqual(2, context.GetValue("two"));
}
public void MultipleLetEval()
{
var exprString = "let x = a + 1 in x + b";
foreach (var parseResult in CompositeExpression.ParseMultiple(exprString))
{
var expr = parseResult.Expression;
var result1 = expr.Evaluate(new { a = 5, b = 6 });
var result2 = expr.Evaluate(new { a = 10, b = 11 });
Assert.That(result1, Is.EqualTo(12));
Assert.That(result2, Is.EqualTo(22));
}
}
private QueryExpression ParseExpression()
{
QueryExpression rootExpression = null;
CompositeExpression parentExpression = null;
while (_currentIndex < _expression.Length)
{
EatWhitespace();
if (_expression[_currentIndex] != '@')
throw new JsonException("Unexpected character while parsing path query: " + _expression[_currentIndex]);
_currentIndex++;
List<PathFilter> expressionPath = new List<PathFilter>();
if (ParsePath(expressionPath, _currentIndex, true))
throw new JsonException("Path ended with open query.");
EatWhitespace();
EnsureLength("Path ended with open query.");
QueryOperator op;
object value = null;
if (_expression[_currentIndex] == ')'
|| _expression[_currentIndex] == '|'
|| _expression[_currentIndex] == '&')
{
op = QueryOperator.Exists;
}
else
{
op = ParseOperator();
EatWhitespace();
EnsureLength("Path ended with open query.");
value = ParseValue();
EatWhitespace();
EnsureLength("Path ended with open query.");
}
BooleanQueryExpression booleanExpression = new BooleanQueryExpression
{
Path = expressionPath,
Operator = op,
Value = (op != QueryOperator.Exists) ? new JValue(value) : null
};
if (_expression[_currentIndex] == ')')
{
if (parentExpression != null)
{
parentExpression.Expressions.Add(booleanExpression);
return rootExpression;
}
return booleanExpression;
}
if (_expression[_currentIndex] == '&' && Match("&&"))
{
if (parentExpression == null || parentExpression.Operator != QueryOperator.And)
{
CompositeExpression andExpression = new CompositeExpression { Operator = QueryOperator.And };
if (parentExpression != null)
parentExpression.Expressions.Add(andExpression);
parentExpression = andExpression;
if (rootExpression == null)
rootExpression = parentExpression;
}
parentExpression.Expressions.Add(booleanExpression);
}
if (_expression[_currentIndex] == '|' && Match("||"))
{
if (parentExpression == null || parentExpression.Operator != QueryOperator.Or)
{
CompositeExpression orExpression = new CompositeExpression { Operator = QueryOperator.Or };
if (parentExpression != null)
parentExpression.Expressions.Add(orExpression);
parentExpression = orExpression;
if (rootExpression == null)
rootExpression = parentExpression;
}
parentExpression.Expressions.Add(booleanExpression);
}
}
throw new JsonException("Path ended with open query.");
}
