public void Single_greater_comparison_with_constant_is_parsed_into_LessExpression_with_property_name_and_value()
{
var expression = _parser.Parse <Book>(x => x.PageCount > 500);
var expectedExpression = new GreaterExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(500));
Assert.AreEqual(expectedExpression, expression);
}
public bool GreaterBoolean(GreaterExpression node, List <object> parameters)
{
ExpressionNode lhs = node.Children[0];
ExpressionNode rhs = node.Children[1];
double lhsValue = _interpreter.DispatchReal(lhs, parameters);
double rhsValue = _interpreter.DispatchReal(rhs, parameters);
return(lhsValue > rhsValue);
}
public void GreaterBoolean_Real_CorrectValuesReturned(double lhsValue, double rhsValue, bool expected)
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
var expression = new GreaterExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchReal(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchReal(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.GreaterBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public void GreaterBoolean_Real_CheckParametersPassedDown()
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new GreaterExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
parent.DispatchReal(lhs, Arg.Do <List <object> >(x => lhsParams = x));
parent.DispatchReal(rhs, Arg.Do <List <object> >(x => rhsParams = x));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.GreaterBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}
/// <summary>
/// Converts the parts of an expression into a FastDAO IExpression.
/// Supported operators: gt, lt, ge, le, eq
/// </summary>
/// <param name="expressionParts">IDictionary with the following keys:
/// "a" for the Attribute name
/// "o" for the Operator
/// "v" for the Value</param>
/// <returns>A FastDAO IExpression</returns>
private static IExpression DictionaryToExpression(IDictionary <string, object> expressionParts)
{
if (expressionParts == null)
{
throw new ArgumentNullException("expressionParts", "Cannot convert null to SQL expression");
}
if (!expressionParts.ContainsKey(ATTRIBUTE_KEY))
{
throw new ArgumentException("Missing the [" + ATTRIBUTE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
if (!expressionParts.ContainsKey(OPERATOR_KEY))
{
throw new ArgumentException("Missing the [" + OPERATOR_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
if (!expressionParts.ContainsKey(VALUE_KEY))
{
throw new ArgumentException("Missing the [" + VALUE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
IExpression retVal;
string attr = (string)expressionParts[ATTRIBUTE_KEY];
string oper = (string)expressionParts[OPERATOR_KEY];
object val = expressionParts[VALUE_KEY];
// Supported Operator Values: gt, lt, ge, le, eq, lk
switch (oper)
{
case "eq":
if (val is IList)
{
retVal = new PropertyInListExpression(attr, (IEnumerable)val);
}
else
{
retVal = new EqualExpression(attr, val);
}
break;
case "gt":
retVal = new GreaterExpression(attr, val);
break;
case "lt":
retVal = new LesserExpression(attr, val);
break;
case "ge":
retVal = new LesserExpression(attr, val, false);
break;
case "le":
retVal = new GreaterExpression(attr, val, false);
break;
case "lk":
retVal = new LikeExpression(attr, "%" + val + "%");
break;
default:
throw new ArgumentException("Cannot convert unsupported operator to SQL expression: " + oper);
}
return(retVal);
}
public void Single_greater_comparison_with_constant_is_parsed_into_LessExpression_with_property_name_and_value()
{
var expression = _parser.Parse<Book>(x => x.PageCount > 500);
var expectedExpression = new GreaterExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(500));
Assert.AreEqual(expectedExpression, expression);
}
public void Visit(GreaterExpression expression)
{
VisitBinaryComparisonExpression(expression, ">");
}
public void TestGreaterExpression()
{
var e = new GreaterExpression(new ConstantExpression(15), new ConstantExpression(7));
e.Execute(_context, _stack);
Assert.AreEqual(true, _stack.Pop());
Assert.IsFalse(_stack.Any());
var e2 = new GreaterExpression(new ConstantExpression(9), new ConstantExpression(9));
e2.Execute(_context, _stack);
Assert.AreEqual(false, _stack.Pop());
Assert.IsFalse(_stack.Any());
}
public override void Visit(GreaterExpression node)
{
Visit((BinaryExpression)node);
}
public override void Visit(GreaterExpression node)
{
unfinishedClone = new GreaterExpression(GetCloneOf(node.Left), GetCloneOf(node.Right));
base.Visit(node);
}
public void Visit(GreaterExpression expression)
{
MatchCompareValues(expression.PropertyExpression.PropertyName, expression.ValueExpression.Value, 1);
}
public override void Visit(GreaterExpression node)
{
UpdateType(node, TypeCalculator.GetType(node));
}
public void Visit(GreaterExpression expression)
{
MatchCompareValues(expression.PropertyExpression.PropertyName, expression.ValueExpression.Value, 1);
}
public override void Visit(GreaterExpression node)
{
AssignToImplicitReturn(node);
}
public void SetUp(List <string> args)
{
if (verbose)
{
Console.WriteLine("import path:");
foreach (string directory in pathResolver.Directories)
{
Console.WriteLine(" " + directory);
}
}
AppDomain domain = Thread.GetDomain();
rootModule = new Module(null, null);
foreach (Assembly assembly in domain.GetAssemblies())
{
AssemblyLoaded(assembly);
}
domain.AssemblyLoad += OnDomainAssemblyLoad;
rootModule.SetName("null", null);
rootModule.SetName("true", true);
rootModule.SetName("false", false);
rootModule.SetName("args", args);
DefaultWhitespace.SetUp(rootModule, grammar);
LineComment.SetUp(rootModule, grammar);
BlockComment.SetUp(rootModule, grammar);
Whitespace.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Number.SetUp(rootModule, grammar);
Base.String.SetUp(rootModule, grammar);
Expression.SetUp(rootModule, grammar);
ValueExpression.SetUp(rootModule, grammar);
NameExpression.SetUp(rootModule, grammar);
ParenExpression.SetUp(rootModule, grammar);
MemberExpression.SetUp(rootModule, grammar);
CallExpression.SetUp(rootModule, grammar);
CallInParentScopeExpression.SetUp(rootModule, grammar);
NewExpression.SetUp(rootModule, grammar);
TypeExpression.SetUp(rootModule, grammar);
IsExpression.SetUp(rootModule, grammar);
AsExpression.SetUp(rootModule, grammar);
UnaryExpression.SetUp(rootModule, grammar);
NotExpression.SetUp(rootModule, grammar);
MultiplicativeExpression.SetUp(rootModule, grammar);
MultiplyExpression.SetUp(rootModule, grammar);
DivideExpression.SetUp(rootModule, grammar);
AdditiveExpression.SetUp(rootModule, grammar);
AddExpression.SetUp(rootModule, grammar);
SubtractExpression.SetUp(rootModule, grammar);
ComparisonExpression.SetUp(rootModule, grammar);
LessExpression.SetUp(rootModule, grammar);
LessOrEqualExpression.SetUp(rootModule, grammar);
EqualityExpression.SetUp(rootModule, grammar);
InequalityExpression.SetUp(rootModule, grammar);
GreaterExpression.SetUp(rootModule, grammar);
GreaterOrEqualExpression.SetUp(rootModule, grammar);
JunctionExpression.SetUp(rootModule, grammar);
AndExpression.SetUp(rootModule, grammar);
AssignmentExpression.SetUp(rootModule, grammar);
AssignExpression.SetUp(rootModule, grammar);
/*
* NameExpression = ValueExpression
* ParenExpression = ValueExpression
*
* CallExpression < ValueExpression
* CallInParentScopeExpression = CallExpression
* MemberExpression = CallExpression
*
* NewExpression < CallExpression
* TypeExpression < NewExpression
* UnaryExpression < TypeExpression
* MultiplicativeExpression < UnaryExpression
* AdditiveExpression < MultiplicativeExpression
* ComparisonExpression < AdditiveExpression
* JunctionExpression < ComparisonExpression
* AssignmentExpression < JunctionExpression
*/
Precedence.SetPrecedence(NameExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(CallExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(MemberExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(NewExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(TypeExpression.pattern.Precedence,
NewExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(UnaryExpression.pattern.Precedence,
TypeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence,
UnaryExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence,
MultiplicativeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence,
AdditiveExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(JunctionExpression.pattern.Precedence,
ComparisonExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence,
JunctionExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ValueExpression.pattern,
NameExpression.pattern,
ParenExpression.pattern,
MemberExpression.pattern,
CallExpression.pattern,
NewExpression.pattern,
TypeExpression.pattern,
UnaryExpression.pattern,
MultiplicativeExpression.pattern,
AdditiveExpression.pattern,
ComparisonExpression.pattern,
JunctionExpression.pattern,
AssignmentExpression.pattern);
PatternExpression.SetUp(rootModule, grammar);
ReferencePatternExpression.SetUp(rootModule, grammar);
AnyPatternExpression.SetUp(rootModule, grammar);
TextPatternExpression.SetUp(rootModule, grammar);
Option.SetUp(rootModule, grammar);
BlockPatternExpression.SetUp(rootModule, grammar);
ParenPatternExpression.SetUp(rootModule, grammar);
TokenPatternExpression.SetUp(rootModule, grammar);
RangePatternExpression.SetUp(rootModule, grammar);
RepeatPatternExpression.SetUp(rootModule, grammar);
AndPatternExpression.SetUp(rootModule, grammar);
NotPatternExpression.SetUp(rootModule, grammar);
LabelPatternExpression.SetUp(rootModule, grammar);
SequencePatternExpression.SetUp(rootModule, grammar);
AltPatternExpression.SetUp(rootModule, grammar);
/*
* EndPatternExpression = ReferencePatternExpression
* AnyPatternExpression = ReferencePatternExpression
* TextPatternExpression = ReferencePatternExpression
* BlockPatternExpression = ReferencePatternExpression
* ParenPatternExpression = ReferencePatternExpression
* TokenPatternExpression = ReferencePatternExpression
*
* RangePatternExpression < ReferencePatternExpression
*
* AndPatternExpression < RangePatternExpression
* NotPatternExpression = AndPatternExpression
* RepeatPatternExpression = AndPatternExpression
*
* LabelPatternExpression < AndPatternExpression
* SequencePatternExpression < LabelPatternExpression
* AltPatternExpression < SequencePatternExpression
*/
Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence,
RangePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence,
LabelPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence,
SequencePatternExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ReferencePatternExpression.pattern,
AnyPatternExpression.pattern,
TextPatternExpression.pattern,
BlockPatternExpression.pattern,
ParenPatternExpression.pattern,
TokenPatternExpression.pattern,
RangePatternExpression.pattern,
RepeatPatternExpression.pattern,
AndPatternExpression.pattern,
NotPatternExpression.pattern,
LabelPatternExpression.pattern,
SequencePatternExpression.pattern,
AltPatternExpression.pattern);
Statement.SetUp(rootModule, grammar);
ExpressionStatement.SetUp(rootModule, grammar);
CompoundStatement.SetUp(rootModule, grammar);
PrintStatement.SetUp(rootModule, grammar);
IfStatement.SetUp(rootModule, grammar);
WhileStatement.SetUp(rootModule, grammar);
ReturnStatement.SetUp(rootModule, grammar);
ThrowStatement.SetUp(rootModule, grammar);
TryStatement.SetUp(rootModule, grammar);
ModuleStatement.SetUp(rootModule, grammar);
FunctionStatement.SetUp(rootModule, grammar);
Member.SetUp(rootModule, grammar);
PatternMember.SetUp(rootModule, grammar);
FieldMember.SetUp(rootModule, grammar);
ConstructorMember.SetUp(rootModule, grammar);
MethodMember.SetUp(rootModule, grammar);
ClassStatement.SetUp(rootModule, grammar);
SetPrecedenceStatement.SetUp(rootModule, grammar);
UsingStatement.SetUp(rootModule, grammar);
ImportStatement.SetUp(rootModule, grammar);
TopLevelStatement.SetUp(rootModule, grammar);
Program.SetUp(rootModule, grammar);
Grammar.PatternChanged(Member.pattern, Statement.pattern);
grammar.RootPattern = Program.pattern;
hasBeenSetUp = true;
}
