public void VBStringComparison()
{
var parameterExpression = Expression.Parameter(typeof(Cook), "c");
var vbCompareStringExpression =
Expression.Equal(
Expression.Call(
typeof(Operators).GetMethod("CompareString"),
Expression.Constant("string1"),
Expression.MakeMemberAccess(parameterExpression, typeof(Cook).GetProperty("Name")),
Expression.Constant(true)),
Expression.Constant(0));
var query = QuerySource
.Where(Expression.Lambda <Func <Cook, bool> > (vbCompareStringExpression, parameterExpression))
.Select(c => c.Name);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
var expectedExpression = new VBStringComparisonExpression(
Expression.Equal(
Expression.Constant("string1"),
Expression.MakeMemberAccess(new QuerySourceReferenceExpression(queryModel.MainFromClause), typeof(Cook).GetProperty("Name"))),
true);
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, whereClause.Predicate);
}
public void Evaluate_VBStringComparisonExpression_IsNotPartiallyEvaluated()
{
var expression = new VBStringComparisonExpression(Expression.Equal(Expression.Constant("a"), Expression.Constant("b")), true);
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, new TestEvaluatableExpressionFilter());
ExpressionTreeComparer.CheckAreEqualTrees(new VBStringComparisonExpression(Expression.Constant(false), true), result);
}
public void Initialization_TypeComesFromComparison()
{
var boolExpression = new VBStringComparisonExpression(Expression.Equal(Expression.Constant("string1"), Expression.Constant("string2")), true);
var intExpression = new VBStringComparisonExpression(Expression.Constant(0), true);
Assert.That(boolExpression.Type, Is.SameAs(typeof(bool)));
Assert.That(intExpression.Type, Is.SameAs(typeof(int)));
}
public void VisitExtensionExpression_DescendsIntoChildren()
{
var tree = new VBStringComparisonExpression(_replacedNode, true);
var result = ReplacingExpressionVisitor.Replace(_replacedNode, _replacementNode, tree);
var expected = new VBStringComparisonExpression(_replacementNode, true);
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void VisitExtensionExpression_ChildrenAreEvaluated()
{
var subQuery = ExpressionHelper.MakeExpression(() => (from s in ExpressionHelper.CreateQueryable <Cook> () select s).Any());
var extensionExpression = new VBStringComparisonExpression(subQuery, true);
// evaluate the ExpressionHelper.CreateQueryable<Cook> () method
var inputExpression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(extensionExpression);
var result = SubQueryFindingExpressionTreeVisitor.Process(inputExpression, _methodInfoBasedNodeTypeRegistry);
Assert.That(((VBStringComparisonExpression)result).Comparison, Is.TypeOf(typeof(SubQueryExpression)));
}
public void VBStringComparison_WithParameterInsideComparison()
{
var predicateParameter = Expression.Parameter(typeof(Cook), "c");
var predicate = Expression.Lambda <Func <Cook, bool> > (
new VBStringComparisonExpression(Expression.Equal(predicateParameter, Expression.Constant(null)), true), predicateParameter);
var expression = (from s in QuerySource select s).Where(predicate).Expression;
var queryModel = QueryParser.GetParsedQuery(expression);
var expectedExpression = new VBStringComparisonExpression(
Expression.Equal(new QuerySourceReferenceExpression(queryModel.MainFromClause),
Expression.Constant(null)), true);
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, ((WhereClause)queryModel.BodyClauses[0]).Predicate);
}
private Expression GetExpressionForNodeType(
BinaryExpression expression, MethodCallExpression leftSideAsMethodCallExpression,
ConstantExpression leftSideArgument2AsConstantExpression)
{
BinaryExpression binaryExpression;
switch (expression.NodeType)
{
case ExpressionType.Equal:
binaryExpression = Expression.Equal(leftSideAsMethodCallExpression.Arguments[0],
leftSideAsMethodCallExpression.Arguments[1]);
return(new VBStringComparisonExpression(binaryExpression,
(bool)leftSideArgument2AsConstantExpression.Value));
case ExpressionType.NotEqual:
binaryExpression = Expression.NotEqual(leftSideAsMethodCallExpression.Arguments[0],
leftSideAsMethodCallExpression.Arguments[1]);
return(new VBStringComparisonExpression(binaryExpression,
(bool)leftSideArgument2AsConstantExpression.Value));
}
var methodCallExpression = Expression.Call(
leftSideAsMethodCallExpression.Arguments[0],
s_stringCompareToMethod, leftSideAsMethodCallExpression.Arguments[1]);
var vbExpression = new VBStringComparisonExpression(methodCallExpression,
(bool)leftSideArgument2AsConstantExpression.Value);
if (expression.NodeType == ExpressionType.GreaterThan)
{
return(Expression.GreaterThan(vbExpression, Expression.Constant(0)));
}
if (expression.NodeType == ExpressionType.GreaterThanOrEqual)
{
return(Expression.GreaterThanOrEqual(vbExpression, Expression.Constant(0)));
}
if (expression.NodeType == ExpressionType.LessThan)
{
return(Expression.LessThan(vbExpression, Expression.Constant(0)));
}
if (expression.NodeType == ExpressionType.LessThanOrEqual)
{
return(Expression.LessThanOrEqual(vbExpression, Expression.Constant(0)));
}
throw new NotSupportedException(
string.Format("Binary expression with node type '{0}' is not supported in a VB string comparison.",
expression.NodeType));
}
private HqlTreeNode VisitVBStringComparisonExpression(VBStringComparisonExpression expression)
{
// We ignore the case sensitivity flag in the same way that == does.
return(VisitExpression(expression.Comparison));
}
public void SetUp()
{
_comparisonExpression = Expression.Equal(Expression.Constant("string1"), Expression.Constant("string2"));
_expression = new VBStringComparisonExpression(_comparisonExpression, true);
}
