public void Can_Read_Negated_Expression()
{
var tokenizer = NewTokenizer("NOT ( A.Field = 1 OR A.Other IS NULL )");
tokenizer.ReadNextToken();
ExpressionParser parser = new ExpressionParser(tokenizer);
// exercise
Expression expression = parser.Execute();
// verify
Assert.IsNotNull(expression);
Assert.IsTrue(expression is NegationExpression);
NegationExpression negationExpression = (NegationExpression)expression;
Expression criteria = negationExpression.Expression;
Assert.IsTrue(criteria is NestedExpression);
NestedExpression nestedExpression = (NestedExpression)criteria;
Assert.IsTrue(nestedExpression.Expression is CriteriaExpression);
CriteriaExpression criteriaExpression = (CriteriaExpression)nestedExpression.Expression;
Assert.AreEqual("A.Field = 1", criteriaExpression.Left.Value);
Assert.AreEqual("OR", criteriaExpression.Operator);
Assert.AreEqual("A.Other IS NULL", criteriaExpression.Right.Value);
}
public void Can_Read_Negated_Expression_Without_Brackets()
{
var tokenizer = NewTokenizer("NOT EXISTS(SELECT 1 FROM dbo.Table)");
tokenizer.ReadNextToken();
ExpressionParser parser = new ExpressionParser(tokenizer);
// exercise
Expression expression = parser.Execute();
// verify
Assert.IsNotNull(expression);
Assert.IsTrue(expression is NegationExpression);
NegationExpression negationExpression = (NegationExpression)expression;
Expression criteria = negationExpression.Expression;
Assert.IsTrue(criteria is FunctionExpression);
FunctionExpression functionExpression = (FunctionExpression)criteria;
Assert.AreEqual(1, functionExpression.Arguments.Count);
Expression arg = functionExpression.Arguments.First();
Assert.IsTrue(arg is SelectExpression);
}
private Expression ReadFactor(Expression parent)
{
// nested expressions first
if (Tokenizer.IsNextToken(Constants.OpenBracket))
{
return(GetNestedExpression(parent));
}
else
{
if (Tokenizer.IsNextToken(Constants.Case))
{
return(GetCaseExpression(parent));
}
if (Tokenizer.IsNextToken(Constants.Select))
{
return(GetSelectExpression());
}
if (Tokenizer.HasMoreTokens && Tokenizer.Current.Type == TokenType.String)
{
return(ReadString(parent));
}
if (Tokenizer.IsNextToken(Constants.Not))
{
ReadNextToken();
NegationExpression negationExpression = new NegationExpression(parent);
var result = ReadCriteriaList(negationExpression);
negationExpression.Expression = result;
return(negationExpression);
}
if (Tokenizer.Current != (Token)null && !Tokenizer.Current.IsTypeIn(
TokenType.SingleQuote, TokenType.Variable, TokenType.AlphaNumeric, TokenType.AlphaNumeric,
TokenType.Numeric, TokenType.Operator, TokenType.BlockedText)
)
{
throw new SyntaxException("expected alpha, numeric, or variable, found " + Tokenizer.Current.Value);
}
// get (possibly dot notated) identifier next
string token = GetDotNotationIdentifier();
// check for an open bracket, indicating that the previous identifier is actually a function
if (Tokenizer.IsNextToken(Constants.OpenBracket))
{
return(GetFunction(parent, token));
}
else
{
return(new IdentifierExpression(token, parent));
}
}
}
public void ParseBooleanNegation()
{
Parser parser = new Parser("!a");
var expected = new NegationExpression(new NameExpression("a"));
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseExpression());
}
public void Equals()
{
NegationExpression expr1 = new NegationExpression(new ConstantExpression(1));
NegationExpression expr2 = new NegationExpression(new ConstantExpression(2));
NegationExpression expr3 = new NegationExpression(new ConstantExpression(1));
Assert.IsTrue(expr1.Equals(expr3));
Assert.IsTrue(expr3.Equals(expr1));
Assert.AreEqual(expr1.GetHashCode(), expr3.GetHashCode());
Assert.IsFalse(expr1.Equals(null));
Assert.IsFalse(expr1.Equals("foo"));
Assert.IsFalse(expr1.Equals(expr2));
Assert.IsFalse(expr2.Equals(expr1));
}
private IExpression ParseTerm()
{
IExpression expression = null;
if (this.TryParseToken(TokenType.Operator, "-"))
{
expression = new NegativeExpression(this.ParseTerm());
}
else if (this.TryParseToken(TokenType.Operator, "+"))
{
expression = this.ParseTerm();
}
else if (this.TryParseToken(TokenType.Operator, "!"))
{
expression = new NegationExpression(this.ParseTerm());
}
else
{
expression = this.ParseSimpleTerm();
}
if (expression == null)
{
return(null);
}
while (true)
{
if (this.TryParseToken(TokenType.Separator, "."))
{
string name = this.ParseName();
if (this.TryParseToken(TokenType.Separator, "{"))
{
expression = new DotExpression(expression, name, new IExpression[] { this.ParseBlockExpression(true) });
}
else if (this.NextTokenStartsExpressionList())
{
expression = new DotExpression(expression, name, this.ParseExpressionList());
}
else
{
expression = new DotExpression(expression, name, new IExpression[0]);
}
continue;
}
if (this.TryParseToken(TokenType.Separator, "::"))
{
string name = this.ParseName();
expression = new DoubleColonExpression(expression, name);
continue;
}
if (this.TryParseToken(TokenType.Separator, "["))
{
IExpression indexexpr = this.ParseExpression();
this.ParseToken(TokenType.Separator, "]");
expression = new IndexedExpression(expression, indexexpr);
continue;
}
break;
}
return(expression);
}
public virtual void Visit(NegationExpression negationExpression)
{
Visit(negationExpression.E);
}
public string GenerateString(NegationExpression expression)
{
return(expression.tok.val + GenerateString(expression.E));
}
void UnaryExpression(out Expression e, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out e) != null); IToken/*!*/ x; e = dummyExpr;
if (la.kind == 128) {
Get();
x = t;
UnaryExpression(out e, allowSemi, allowLambda);
e = new NegationExpression(x, e);
} else if (la.kind == 121 || la.kind == 122) {
NegOp();
x = t;
UnaryExpression(out e, allowSemi, allowLambda);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Not, e);
} else if (IsMapDisplay()) {
Expect(17);
x = t;
MapDisplayExpr(x, true, out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (IsIMapDisplay()) {
Expect(18);
x = t;
MapDisplayExpr(x, false, out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (IsISetDisplay()) {
Expect(14);
x = t;
ISetDisplayExpr(x, false, out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (IsLambda(allowLambda)) {
LambdaExpression(out e, allowSemi);
} else if (StartOf(29)) {
EndlessExpression(out e, allowSemi, allowLambda);
} else if (la.kind == 1) {
NameSegment(out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (la.kind == 46 || la.kind == 48) {
DisplayExpr(out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (la.kind == 15) {
MultiSetExpr(out e);
while (IsSuffix()) {
Suffix(ref e);
}
} else if (StartOf(27)) {
ConstAtomExpression(out e, allowSemi, allowLambda);
while (IsSuffix()) {
Suffix(ref e);
}
} else SynErr(223);
}
public void MathExpression_Can_Evaluate_Negated_Expression()
{
var expression = new NegationExpression(new NumericExpression(42));
var visitor = new EvaluationVisitor();
Assert.AreEqual(-42, visitor.Evaluate(expression, new MathExpressionContext()));
}
public void NegationInteger()
{
NegationExpression expr = new NegationExpression(new ConstantExpression(123));
Assert.AreEqual(false, expr.Evaluate(null));
}
public void NegationString()
{
NegationExpression expr = new NegationExpression(new ConstantExpression("foo"));
Assert.AreEqual(false, expr.Evaluate(null));
}
public void NegationTrue()
{
NegationExpression expr = new NegationExpression(new ConstantExpression(true));
Assert.AreEqual(false, expr.Evaluate(null));
}
