public void VisitParameterExpression()
{
var expression = (ParameterExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Parameter);
var result = (ParameterExpression)InvokeAndCheckVisitExpression("VisitParameterExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitAndConvert_Single_ThrowsOnNull()
{
var expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.VisitExpression(expression)).Return(null);
InvokeAndCheckVisitAndConvertExpression(expression, "VisitMethod");
}
public void VisitUnaryExpression_Unchanges()
{
var expression = (UnaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.UnaryPlus);
Expression expectedNextVisit = expression.Operand;
Expect.Call(VisitorMock.VisitExpression(expectedNextVisit)).Return(expectedNextVisit);
Assert.That(InvokeAndCheckVisitExpression("VisitUnaryExpression", expression), Is.SameAs(expression));
}
public void VisitNewArrayExpression_Unchanged()
{
var expression = (NewArrayExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.NewArrayInit);
Expect.Call(VisitorMock.VisitAndConvert(expression.Expressions, "VisitNewArrayExpression")).Return(expression.Expressions);
var result = (NewArrayExpression)InvokeAndCheckVisitExpression("VisitNewArrayExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitTypeBinary_Unchanged()
{
var expression = (TypeBinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.TypeIs);
Expect.Call(VisitorMock.VisitExpression(expression.Expression)).Return(expression.Expression);
var result = (TypeBinaryExpression)InvokeAndCheckVisitExpression("VisitTypeBinaryExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitListInitExpression_Unchanged()
{
var expression = (ListInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.ListInit);
Expect.Call(VisitorMock.VisitExpression(expression.NewExpression)).Return(expression.NewExpression);
Expect.Call(InvokeVisitMethod("VisitElementInitList", expression.Initializers)).Return(expression.Initializers);
var result = (ListInitExpression)InvokeAndCheckVisitExpression("VisitListInitExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitLambdaExpression_Unchanged()
{
var expression = (LambdaExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Lambda);
Expect.Call(VisitorMock.VisitExpression(expression.Body)).Return(expression.Body);
Expect.Call(VisitorMock.VisitAndConvert(expression.Parameters, "VisitLambdaExpression")).Return(expression.Parameters);
var result = (LambdaExpression)InvokeAndCheckVisitExpression("VisitLambdaExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitInvocationExpression_Unchanged()
{
var expression = (InvocationExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Invoke);
Expect.Call(VisitorMock.VisitExpression(expression.Expression)).Return(expression.Expression);
Expect.Call(VisitorMock.VisitAndConvert(expression.Arguments, "VisitInvocationExpression")).Return(expression.Arguments);
var result = (InvocationExpression)InvokeAndCheckVisitExpression("VisitInvocationExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitAndConvert_Single_NoConvert()
{
var expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.VisitExpression(expression)).Return(expression);
var result = InvokeAndCheckVisitAndConvertExpression(expression, "Add");
Assert.That(result, Is.SameAs(expression));
}
public void VisitConditionalExpression_Unchanged()
{
var expression = (ConditionalExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Conditional);
Expect.Call(VisitorMock.VisitExpression(expression.Test)).Return(expression.Test);
Expect.Call(VisitorMock.VisitExpression(expression.IfFalse)).Return(expression.IfFalse);
Expect.Call(VisitorMock.VisitExpression(expression.IfTrue)).Return(expression.IfTrue);
var result = (ConditionalExpression)InvokeAndCheckVisitExpression("VisitConditionalExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitAndConvert_Collection_ExceptionUsesCallerName()
{
var constantExpression = Expression.Constant(1);
var expressions = new List <ConstantExpression> (new[] { constantExpression }).AsReadOnly();
var newExpression = (NewExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.New);
Expect.Call(VisitorMock.VisitExpression(constantExpression)).Return(newExpression);
VisitorMock.Replay();
VisitorMock.VisitAndConvert(expressions, "Whatever");
}
public void VisitMemberExpression_ChangedExpression()
{
var expression = (MemberExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.MemberAccess);
Expression newExpression = Expression.Constant(DateTime.Now);
Expect.Call(VisitorMock.VisitExpression(expression.Expression)).Return(newExpression);
var result = (MemberExpression)InvokeAndCheckVisitExpression("VisitMemberExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.MemberAccess));
Assert.That(result.Expression, Is.SameAs(newExpression));
}
public void VisitTypeBinary_Changed()
{
var expression = (TypeBinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.TypeIs);
Expression newExpression = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expression.Expression)).Return(newExpression);
var result = (TypeBinaryExpression)InvokeAndCheckVisitExpression("VisitTypeBinaryExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.TypeIs));
Assert.That(result.Expression, Is.SameAs(newExpression));
}
public void VisitBinaryExpression_Unchanged()
{
BinaryExpression expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.VisitExpression(expression.Left)).Return(expression.Left);
Expect.Call(VisitorMock.VisitExpression(expression.Right)).Return(expression.Right);
Expect.Call(VisitorMock.VisitExpression(expression.Conversion)).Return(expression.Conversion);
BinaryExpression result = (BinaryExpression)InvokeAndCheckVisitExpression("VisitBinaryExpression", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitUnaryExpression_Negate_Changes()
{
var expression = (UnaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Negate);
Expression expectedNextVisit = expression.Operand;
Expression newOperand = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expectedNextVisit)).Return(newOperand);
var result = (UnaryExpression)InvokeAndCheckVisitExpression("VisitUnaryExpression", expression);
Assert.That(result.Operand, Is.SameAs(newOperand));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Negate));
}
public void VisitNewArrayExpression_Bounds_Changed()
{
var expression = (NewArrayExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.NewArrayBounds);
ReadOnlyCollection <Expression> newExpressions = new List <Expression> (new Expression[] { Expression.Constant(214578) }).AsReadOnly();
Expect.Call(VisitorMock.VisitAndConvert(expression.Expressions, "VisitNewArrayExpression")).Return(newExpressions);
var result = (NewArrayExpression)InvokeAndCheckVisitExpression("VisitNewArrayExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.NewArrayBounds));
Assert.That(result.Expressions, Is.EqualTo(newExpressions));
Assert.That(result.Type, Is.EqualTo(typeof(int).MakeArrayType()));
}
public void VisitListInitExpression_ChangedNewExpression()
{
var expression = (ListInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.ListInit);
NewExpression newNewExpression = Expression.New(typeof(List <int>));
Expect.Call(VisitorMock.VisitExpression(expression.NewExpression)).Return(newNewExpression);
Expect.Call(InvokeVisitMethod("VisitElementInitList", expression.Initializers)).Return(expression.Initializers);
var result = (ListInitExpression)InvokeAndCheckVisitExpression("VisitListInitExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.ListInit));
Assert.That(result.NewExpression, Is.SameAs(newNewExpression));
Assert.That(result.Initializers, Is.SameAs(expression.Initializers));
}
public void VisitLambdaExpression_ChangedBody()
{
var expression = (LambdaExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Lambda);
Expression newBody = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expression.Body)).Return(newBody);
Expect.Call(VisitorMock.VisitAndConvert(expression.Parameters, "VisitLambdaExpression")).Return(expression.Parameters);
var result = (LambdaExpression)InvokeAndCheckVisitExpression("VisitLambdaExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Lambda));
Assert.That(result.Body, Is.SameAs(newBody));
Assert.That(result.Parameters, Is.SameAs(expression.Parameters));
}
public void VisitNewExpression_ChangedArguments()
{
var expression = (NewExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.New);
ReadOnlyCollection <Expression> newArguments = new List <Expression> {
Expression.Constant(214578)
}.AsReadOnly();
Expect.Call(VisitorMock.VisitAndConvert(expression.Arguments, "VisitNewExpression")).Return(newArguments);
var result = (NewExpression)InvokeAndCheckVisitExpression("VisitNewExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.New));
Assert.That(result.Arguments, Is.EqualTo(newArguments));
}
public void VisitMethodCallExpression_ChangedObject()
{
var expression = (MethodCallExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Call);
Expression newObject = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expression.Object)).Return(newObject);
Expect.Call(VisitorMock.VisitAndConvert(expression.Arguments, "VisitMethodCallExpression")).Return(expression.Arguments);
var result = (MethodCallExpression)InvokeAndCheckVisitExpression("VisitMethodCallExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Call));
Assert.That(result.Object, Is.SameAs(newObject));
Assert.That(result.Arguments, Is.SameAs(expression.Arguments));
}
public void VisitInvocationExpression_ChangedObject()
{
var expression = (InvocationExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Invoke);
Expression newExpression = Expression.Lambda(Expression.Constant(1), Expression.Parameter(typeof(int), "i"));
Expect.Call(VisitorMock.VisitExpression(expression.Expression)).Return(newExpression);
Expect.Call(VisitorMock.VisitAndConvert(expression.Arguments, "VisitInvocationExpression")).Return(expression.Arguments);
var result = (InvocationExpression)InvokeAndCheckVisitExpression("VisitInvocationExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Invoke));
Assert.That(result.Expression, Is.SameAs(newExpression));
Assert.That(result.Arguments, Is.SameAs(expression.Arguments));
}
public void VisitListInitExpression_ChangedInitializers()
{
var expression = (ListInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.ListInit);
ReadOnlyCollection <ElementInit> newInitializers =
new List <ElementInit> (new[] { Expression.ElementInit(typeof(List <int>).GetMethod("Add"), Expression.Constant(214578)) }).AsReadOnly();
Expect.Call(VisitorMock.VisitExpression(expression.NewExpression)).Return(expression.NewExpression);
Expect.Call(InvokeVisitMethod("VisitElementInitList", expression.Initializers)).Return(newInitializers);
var result = (ListInitExpression)InvokeAndCheckVisitExpression("VisitListInitExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.ListInit));
Assert.That(result.Initializers, Is.EqualTo(newInitializers));
Assert.That(result.NewExpression, Is.SameAs(expression.NewExpression));
}
public void VisitListInitExpression_InvalidNewExpression()
{
var expression = (ListInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.ListInit);
Expect.Call(VisitorMock.VisitExpression(expression.NewExpression)).Return(Expression.Constant(0));
Expect.Call(InvokeVisitMethod("VisitElementInitList", expression.Initializers)).Return(expression.Initializers);
try
{
InvokeAndCheckVisitExpression("VisitListInitExpression", expression);
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
}
public void VisitBinaryExpression_RightChanged()
{
BinaryExpression expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Subtract);
Expression newOperand = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expression.Left)).Return(expression.Left);
Expect.Call(VisitorMock.VisitExpression(expression.Right)).Return(newOperand);
Expect.Call(VisitorMock.VisitExpression(expression.Conversion)).Return(expression.Conversion);
BinaryExpression result = (BinaryExpression)InvokeAndCheckVisitExpression("VisitBinaryExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Subtract));
Assert.That(result.Left, Is.SameAs(expression.Left));
Assert.That(result.Right, Is.SameAs(newOperand));
}
public void VisitConditionalExpression_ChangedTrue()
{
var expression = (ConditionalExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Conditional);
Expression newTrue = Expression.Constant(1);
Expect.Call(VisitorMock.VisitExpression(expression.Test)).Return(expression.Test);
Expect.Call(VisitorMock.VisitExpression(expression.IfFalse)).Return(expression.IfFalse);
Expect.Call(VisitorMock.VisitExpression(expression.IfTrue)).Return(newTrue);
var result = (ConditionalExpression)InvokeAndCheckVisitExpression("VisitConditionalExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Conditional));
Assert.That(result.IfTrue, Is.SameAs(newTrue));
Assert.That(result.Test, Is.SameAs(expression.Test));
Assert.That(result.IfFalse, Is.SameAs(expression.IfFalse));
}
public void VisitLambdaExpression_ChangedParameters()
{
var expression = (LambdaExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Lambda);
ReadOnlyCollection <ParameterExpression> newParameters = new List <ParameterExpression> {
Expression.Parameter(typeof(int), "i")
}.AsReadOnly();
Expect.Call(VisitorMock.VisitExpression(expression.Body)).Return(expression.Body);
Expect.Call(VisitorMock.VisitAndConvert(expression.Parameters, "VisitLambdaExpression")).Return(newParameters);
var result = (LambdaExpression)InvokeAndCheckVisitExpression("VisitLambdaExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Lambda));
Assert.That(result.Parameters, Is.EqualTo(newParameters));
Assert.That(result.Body, Is.SameAs(expression.Body));
}
public void VisitMemberInitExpression_ChangedBindings()
{
var expression = (MemberInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.MemberInit);
var capacityProperty = expression.NewExpression.Constructor.DeclaringType.GetProperty("Capacity");
ReadOnlyCollection <MemberBinding> newBindings = new List <MemberBinding> {
Expression.Bind(capacityProperty, Expression.Constant(214578))
}.AsReadOnly();
Expect.Call(VisitorMock.VisitExpression(expression.NewExpression)).Return(expression.NewExpression);
Expect.Call(InvokeVisitMethod("VisitMemberBindingList", expression.Bindings)).Return(newBindings);
var result = (MemberInitExpression)InvokeAndCheckVisitExpression("VisitMemberInitExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.MemberInit));
Assert.That(result.Bindings, Is.EqualTo(newBindings));
Assert.That(result.NewExpression, Is.SameAs(expression.NewExpression));
}
public void IsSupportedStandardExpression_True()
{
var supportedExpressionTypeValues =
new[]
{
ExpressionType.ArrayLength, ExpressionType.Convert, ExpressionType.ConvertChecked, ExpressionType.Negate, ExpressionType.NegateChecked,
ExpressionType.Not, ExpressionType.Quote, ExpressionType.TypeAs, ExpressionType.UnaryPlus, ExpressionType.Add, ExpressionType.AddChecked,
ExpressionType.Divide, ExpressionType.Modulo, ExpressionType.Multiply, ExpressionType.MultiplyChecked, ExpressionType.Power,
ExpressionType.Subtract, ExpressionType.SubtractChecked, ExpressionType.And, ExpressionType.Or, ExpressionType.ExclusiveOr,
ExpressionType.LeftShift, ExpressionType.RightShift, ExpressionType.AndAlso, ExpressionType.OrElse, ExpressionType.Equal,
ExpressionType.NotEqual, ExpressionType.GreaterThanOrEqual, ExpressionType.GreaterThan, ExpressionType.LessThan,
ExpressionType.LessThanOrEqual, ExpressionType.Coalesce, ExpressionType.ArrayIndex, ExpressionType.Conditional, ExpressionType.Constant,
ExpressionType.Invoke, ExpressionType.Lambda, ExpressionType.MemberAccess, ExpressionType.Call, ExpressionType.New,
ExpressionType.NewArrayBounds, ExpressionType.NewArrayInit, ExpressionType.MemberInit, ExpressionType.ListInit, ExpressionType.Parameter,
ExpressionType.TypeIs,
};
var visitMethodExpressionTypes = new HashSet <Type> (
from m in typeof(ExpressionTreeVisitor).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
where m.Name.StartsWith("Visit")
let parameters = m.GetParameters()
where parameters.Length == 1
let expressionType = parameters.Single().ParameterType
where expressionType != typeof(Expression)
select expressionType);
Assert.That(visitMethodExpressionTypes.Count > 0);
foreach (var expressionType in supportedExpressionTypeValues)
{
var expressionInstance = ExpressionInstanceCreator.GetExpressionInstance(expressionType);
Assert.That(
visitMethodExpressionTypes.Any(t => t.IsAssignableFrom(expressionInstance.GetType())),
Is.True,
"Visit method for {0}",
expressionInstance.GetType());
Assert.That(ExpressionTreeVisitor.IsSupportedStandardExpression(expressionInstance), Is.True);
}
}
