public void VisitList_Changed_InvalidType()
{
Expression expr1 = Expression.Constant(1);
ReadOnlyCollection <Expression> expressions = new List <Expression> (new[] { expr1 }).AsReadOnly();
VisitorMock.VisitList(expressions, arg => null);
}
public void VisitNewExpression_ChangedArguments_WithMembers_AndConversionRequired()
{
NewExpression expression = Expression.New(
typeof(KeyValuePair <object, object>).GetConstructor(new[] { typeof(object), typeof(object) }),
new Expression[] { Expression.Constant(null), Expression.Constant(null) },
typeof(KeyValuePair <object, object>).GetProperty("Key"), typeof(KeyValuePair <object, object>).GetProperty("Value"));
var newArguments = new List <Expression> {
Expression.Constant("testKey"), Expression.Constant("testValue")
}.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.Count, Is.EqualTo(2));
var expectedArgument1 = Expression.Convert(newArguments[0], typeof(object));
ExpressionTreeComparer.CheckAreEqualTrees(expectedArgument1, result.Arguments[0]);
var expectedArgument2 = Expression.Convert(newArguments[1], typeof(object));
ExpressionTreeComparer.CheckAreEqualTrees(expectedArgument2, result.Arguments[1]);
Assert.That(result.Members, Is.SameAs(expression.Members));
}
public void VisitAndConvert_Single_ThrowsOnNull()
{
var expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.Visit(expression)).Return(null);
InvokeVisitAndConvert(expression, "VisitMethod");
}
public void VisitMemberAssignment_Unchanged()
{
MemberAssignment memberAssignment = ExpressionInstanceCreator.CreateMemberAssignment();
Expect.Call(VisitorMock.VisitExpression(memberAssignment.Expression)).Return(memberAssignment.Expression);
var result = (MemberAssignment)InvokeAndCheckVisitObject("VisitMemberAssignment", memberAssignment);
Assert.That(result, Is.SameAs(memberAssignment));
}
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 VisitAndConvert_Single_ThrowsOnInvalidType()
{
var expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
var newExpression = (NewExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.New);
Expect.Call(VisitorMock.VisitExpression(expression)).Return(newExpression);
InvokeAndCheckVisitAndConvertExpression(expression, "VisitMethod");
}
public void VisitMember_Unchanged()
{
var expression = (MemberExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.MemberAccess);
Expect.Call(VisitorMock.Visit(expression.Expression)).Return(expression.Expression);
var result = (MemberExpression)InvokeAndCheckVisit("VisitMember", expression);
Assert.That(result, 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 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 VisitNew_Unchanged()
{
var expression = (NewExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.New);
var argument = expression.Arguments.Single();
Expect.Call(VisitorMock.Visit(argument)).Return(argument);
var result = (NewExpression)InvokeAndCheckVisit("VisitNew", 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 VisitElementInit_Unchanged()
{
ElementInit elementInit = ExpressionInstanceCreator.CreateElementInit();
Expect.Call(VisitorMock.VisitAndConvert(elementInit.Arguments, "VisitElementInit")).Return(elementInit.Arguments);
var result = (ElementInit)InvokeAndCheckVisitObject("VisitElementInit", elementInit);
Assert.That(result, Is.SameAs(elementInit));
}
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 VisitAndConvert_Single_NoConvert()
{
var expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.Visit(expression)).Return(expression);
var result = InvokeVisitAndConvert(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 VisitLambda_Unchanged()
{
var expression = ExpressionInstanceCreator.CreateLambdaWithArguments();
var parameter = expression.Parameters.Single();
Expect.Call(VisitorMock.Visit(expression.Body)).Return(expression.Body);
Expect.Call(VisitorMock.Visit(parameter)).Return(parameter);
var result = (LambdaExpression)InvokeAndCheckVisit("VisitLambda", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitInvocation_Unchanged()
{
var expression = ExpressionInstanceCreator.CreateInvokeWithArguments();
var argument = expression.Arguments.Single();
Expect.Call(VisitorMock.Visit(expression.Expression)).Return(expression.Expression);
Expect.Call(VisitorMock.Visit(argument)).Return(argument);
var result = (InvocationExpression)InvokeAndCheckVisit("VisitInvocation", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitMemberInit_Unchanged()
{
var expression = (MemberInitExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.MemberInit);
var binding = expression.Bindings.Single();
Expect.Call(VisitorMock.Visit(expression.NewExpression)).Return(expression.NewExpression);
Expect.Call(InvokeVisitMethod("VisitMemberBinding", binding)).Return(binding);
var result = (MemberInitExpression)InvokeAndCheckVisit("VisitMemberInit", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitMemberAssignment_Changed()
{
MemberAssignment memberAssignment = ExpressionInstanceCreator.CreateMemberAssignment();
MemberAssignment newMemberAssignment = Expression.Bind(typeof(List <int>).GetProperty("Capacity"), Expression.Constant(2));
Expect.Call(VisitorMock.Visit(memberAssignment.Expression)).Return(newMemberAssignment.Expression);
var result = (MemberAssignment)InvokeAndCheckVisitObject("VisitMemberAssignment", memberAssignment);
Assert.That(result, Is.Not.SameAs(memberAssignment));
}
public void VisitBinary_Unchanged()
{
BinaryExpression expression = (BinaryExpression)ExpressionInstanceCreator.GetExpressionInstance(ExpressionType.Add);
Expect.Call(VisitorMock.Visit(expression.Left)).Return(expression.Left);
Expect.Call(VisitorMock.Visit(expression.Right)).Return(expression.Right);
BinaryExpression result = (BinaryExpression)InvokeAndCheckVisit("VisitBinary", expression);
Assert.That(result, Is.SameAs(expression));
}
public void VisitMemberAssignment_Changed()
{
MemberAssignment memberAssignment = ExpressionInstanceCreator.CreateMemberAssignment();
MemberAssignment newMemberAssignment = Expression.Bind(typeof(SimpleClass).GetField("Value"), Expression.Constant("2"));
Expect.Call(VisitorMock.VisitExpression(memberAssignment.Expression)).Return(newMemberAssignment.Expression);
var result = (MemberAssignment)InvokeAndCheckVisitObject("VisitMemberAssignment", memberAssignment);
Assert.That(result, Is.Not.SameAs(memberAssignment));
}
public void VisitList_Unchanged()
{
Expression expr1 = Expression.Constant(1);
ReadOnlyCollection <Expression> expressions = new List <Expression> (new[] { expr1 }).AsReadOnly();
Expect.Call(VisitorMock.Visit(expr1)).Return(expr1);
var result = ExpressionVisitor.Visit(expressions, arg => InvokeVisitAndConvert(expr1, "VisitAndConvert"));
Assert.That(result, Is.SameAs(expressions));
}
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.Visit(constantExpression)).Return(newExpression);
VisitorMock.Replay();
VisitorMock.VisitAndConvert(expressions, "Whatever");
}
public void VisitList_Changed()
{
Expression expr1 = Expression.Constant(1);
Expression expr2 = Expression.Constant(2);
ReadOnlyCollection <Expression> expressions = new List <Expression> (new[] { expr1 }).AsReadOnly();
Expect.Call(VisitorMock.VisitExpression(expr1)).Return(expr2);
var result = VisitorMock.VisitList(expressions, arg => InvokeAndCheckVisitAndConvertExpression(expr1, "VisitAndConvert"));
ReadOnlyCollection <Expression> conditionResult = new List <Expression> (new[] { expr2 }).AsReadOnly();
Assert.That(result, Is.EqualTo(conditionResult));
}
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 VisitAndConvert_Collection()
{
var expr1 = Expression.Constant(1);
var expressions = new List <ConstantExpression> (new[] { expr1 }).AsReadOnly();
Expect.Call(VisitorMock.Visit(expr1)).Return(expr1);
VisitorMock.Replay();
var result = VisitorMock.VisitAndConvert(expressions, "Whatever");
Assert.That(result, Is.SameAs(expressions));
VisitorMock.VerifyAllExpectations();
}
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 VisitElementInit_Changed()
{
ElementInit elementInit = ExpressionInstanceCreator.CreateElementInit();
ReadOnlyCollection <Expression> newArguments = new List <Expression> (new Expression[] { Expression.Constant(214578) }).AsReadOnly();
Expect.Call(VisitorMock.VisitAndConvert(elementInit.Arguments, "VisitElementInit")).Return(newArguments);
var result = (ElementInit)InvokeAndCheckVisitObject("VisitElementInit", elementInit);
Assert.That(result, Is.Not.SameAs(elementInit));
Assert.That(result.AddMethod, Is.SameAs(elementInit.AddMethod));
Assert.That(result.Arguments, Is.EqualTo(newArguments));
}
