public IValue Visit(NotEqualExpression expression, TypeEnvironment environment)
{
return(expression.LeftExpression
.Accept(this, environment)
.Equals(expression.RightExpression.Accept(this, environment))
.Not());
}
public bool NotEqualBoolean(NotEqualExpression node, List <object> parameters)
{
ExpressionNode lhs = node.Children[0];
ExpressionNode rhs = node.Children[1];
return(!IsEqual(lhs, rhs, node.Type, parameters));
}
public void NotEqualExpression()
{
var e = new NotEqualExpression(new Literal("13"), new Literal("37"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(13!=37)", e.ToString());
Assert.AreEqual("NotEqual", e.Name);
}
public static void TestEvaluate(object lhs, object rhs, object expectedValue)
{
var expression = new NotEqualExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == lhs),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == rhs),
new Context(ExpressiveOptions.None));
Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
}
public void Visit(NotEqualExpression expression)
{
var isColumnValueMatch = IsMatch(expression.PropertyExpression.PropertyName, expression.ValueExpression.Value);
if (isColumnValueMatch)
{
_isMatch = false;
}
}
public void TestRightNull()
{
var expression = new NotEqualExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)null),
ExpressiveOptions.None);
Assert.AreEqual(true, expression.Evaluate(null));
}
private string GetExpression(NotEqualExpression expression, ref List <OleDbParameter> parameters)
{
if ((expression.Children[1] is LiteralExpression) && ((expression.Children[1] as LiteralExpression).Value == null))
{
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " is not null ) ");
}
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " <> " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ");
}
public void Expression_with_not_equals_operator_yields_NotEqualsExpression()
{
var expression = _parser.Parse <User>(x => x.Username != "a username");
var expectedExpression = new NotEqualExpression(
new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void NotEqualBoolean_Bool_CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected)
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
var expression = new NotEqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Boolean;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.NotEqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public override AstNode VisitCompare([NotNull] QlParser.CompareContext context)
{
var op = context.op.Text;
BinaryExpression binExp = null;
var lhs = this.Visit(context.lhs) as Expression;
var rhs = this.Visit(context.rhs) as Expression;
switch (op)
{
case "<":
binExp = new LessThanExpression(lhs, rhs);
break;
case "<=":
binExp = new LessThanOrEqualExpression(lhs, rhs);
break;
case ">":
binExp = new GreaterThanExpression(lhs, rhs);
break;
case ">=":
binExp = new GreaterThanOrEqualExpression(lhs, rhs);
break;
case "==":
binExp = new EqualExpression(lhs, rhs);
break;
case "!=":
binExp = new NotEqualExpression(lhs, rhs);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), "Unsupported operator.");
}
return(binExp);
}
public void NotEqualBoolean_Bool_CheckParametersPassedDown()
{
var lhs = Utilities.GetBoolLitExpression();
var rhs = Utilities.GetBoolLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new NotEqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Boolean;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
parent.DispatchBoolean(lhs, Arg.Do <List <object> >(x => lhsParams = x));
parent.DispatchBoolean(rhs, Arg.Do <List <object> >(x => rhsParams = x));
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.NotEqualBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}
public ICoreObjectCollection ListAllControllerTarget()
{
try
{
var typeIterator = new TypeIterator(ControllerTargetTypeInfo, true, false);
var selectClause = new ObjectReferenceExpression(typeIterator, CoreAttributeSetInfo);
var name =
new NotEqualExpression(
new AttributeReferenceExpression(CoreContext, typeof(ICoreAttributes), "Name", typeIterator),
new ConstantExpression(string.Empty)
);
var whereClause = new FilterCondition(CoreContext, name);
var query = CoreContext.CreateObjectQuery(selectClause, typeIterator,
whereClause,
SortCondition.Empty);
var objectCollection =
CoreContext.GetCoreObjectCollection(query, CollectionFlag.SnapShot);
return(objectCollection);
} catch (Exception ex)
{
return(null);
}
}
public override void Visit(NotEqualExpression node)
{
unfinishedClone = new NotEqualExpression(GetCloneOf(node.Left), GetCloneOf(node.Right));
base.Visit(node);
}
public void Expression_with_not_equals_operator_yields_NotEqualsExpression()
{
var expression = _parser.Parse<User>(x => x.Username != "a username");
var expectedExpression = new NotEqualExpression(
new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public virtual void VisitNotEqualExpression(NotEqualExpression notEqualExpression)
{
DefaultVisit(notEqualExpression);
}
private string GetExpression(NotEqualExpression expression, ref List<OleDbParameter> parameters)
{
if ((expression.Children[1] is LiteralExpression) && ((expression.Children[1] as LiteralExpression).Value == null))
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " is not null ) ";
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " <> " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
public override void Visit(NotEqualExpression node)
{
AssignToImplicitReturn(node);
}
public ValueType Visit(NotEqualExpression expression, ITypeEnvironment environment)
{
return(this.CheckBinaryComparisonExpression(expression, environment));
}
public void Visit(NotEqualExpression expression)
{
VisitBinaryComparisonExpression(expression, "<>");
}
public void Visit(NotEqualExpression expression)
{
DoBoolean(expression, CodeBinaryOperatorType.IdentityInequality);
}
public virtual TResult Visit(NotEqualExpression expression, TEnvironment environment)
{
return(this.Visit((BinaryExpression)expression, environment));
}
public void Visit(NotEqualExpression expression)
{
var isColumnValueMatch = IsMatch(expression.PropertyExpression.PropertyName, expression.ValueExpression.Value);
if (isColumnValueMatch)
_isMatch = false;
}
public override void Visit(NotEqualExpression node)
{
UpdateType(node, TypeCalculator.GetType(node));
}
public void Visit(NotEqualExpression expression, CommonTree tree)
{
SetLine(expression, tree);
Parent(tree).Children.Add(expression);
VisitChildren(tree);
}
public override void Visit(NotEqualExpression node)
{
Visit((BinaryExpression)node);
}
