public void VisitChildren_ReturnsNewExpression()
{
var newExpression = Expression.Constant(5);
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor> ();
visitorMock
.Expect(mock => mock.Visit(_wrappedExpression))
.Return(newExpression);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_aggregationEpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_aggregationEpression));
Assert.That(((AggregationExpression)result).Expression, Is.SameAs(newExpression));
Assert.That(((AggregationExpression)result).AggregationModifier, Is.EqualTo(AggregationModifier.Max));
}
public void VisitChildren_SameOrderingExpressions()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionTreeVisitor> ();
visitorMock
.Expect(mock => mock.VisitExpression(_orderingExpression1))
.Return(_orderingExpression1);
visitorMock
.Expect(mock => mock.VisitExpression(_orderingExpression2))
.Return(_orderingExpression2);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_sqlRowNumberExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_sqlRowNumberExpression));
}
public void VisitExtension_NonReducibleExpression()
{
RelinqExpressionVisitor visitor = new TestThrowingConstantExpressionVisitor();
#if !NET_3_5
var nonReducibleExpression = MockRepository.GenerateStub <Expression>();
#else
var nonReducibleExpression = MockRepository.GenerateStub <ExtensionExpression> (typeof(int));
#endif
nonReducibleExpression
.Stub(stub => ExtensionExpressionTestHelper.CallAccept(stub, Arg <RelinqExpressionVisitor> .Is.Anything))
.WhenCalled(mi => PrivateInvoke.InvokeNonPublicMethod(mi.Arguments[0], "VisitExtension", nonReducibleExpression))
.Return(nonReducibleExpression);
nonReducibleExpression.Stub(stub => stub.CanReduce).Return(false);
nonReducibleExpression.Stub(stub => stub.ToString()).Return("Test");
visitor.Visit(nonReducibleExpression);
}
public void VisitChildren_ChangeAggregationExpression()
{
var newAggregationExpression = Expression.Constant("newAgg");
var visitorMock = MockRepository.GenerateMock <ExpressionVisitor>();
visitorMock.Expect(mock => mock.Visit(_keyExpression)).Return(_keyExpression);
visitorMock.Expect(mock => mock.Visit(_elementExpression)).Return(_elementExpression);
visitorMock.Expect(mock => mock.Visit(_sqlGroupingSelectExpression.AggregationExpressions[0])).Return(newAggregationExpression);
visitorMock.Replay();
var expression = ExtensionExpressionTestHelper.CallVisitChildren(_sqlGroupingSelectExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(expression, Is.Not.SameAs(_sqlGroupingSelectExpression));
Assert.That(expression, Is.TypeOf(typeof(SqlGroupingSelectExpression)));
Assert.That(((SqlGroupingSelectExpression)expression).AggregationExpressions, Is.EqualTo(new Expression[] { newAggregationExpression }));
}
public void VisitChildren_NewItems()
{
var newItem = Expression.Constant(14);
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor>();
visitorMock.Expect(mock => mock.Visit(_collectionExpression.Items[0])).Return(newItem);
visitorMock.Expect(mock => mock.Visit(_collectionExpression.Items[1])).Return(_collectionExpression.Items[1]);
var result = ExtensionExpressionTestHelper.CallVisitChildren(_collectionExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_collectionExpression));
Assert.That(result, Is.TypeOf <SqlCollectionExpression>());
Assert.That(result.Type, Is.SameAs(_collectionExpression.Type));
Assert.That(((SqlCollectionExpression)result).Items, Is.EqualTo(new[] { newItem, _collectionExpression.Items[1] }));
}
public void VisitChildren_ChangeColumn()
{
var newColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "o", "Test", false);
var visitorMock = MockRepository.GenerateMock <ExpressionVisitor>();
var expectedColumns = new[] { _columnExpression1, newColumnExpression, _columnExpression3 };
visitorMock.Expect(mock => mock.Visit(_originalColumnsReadonly[0])).Return(expectedColumns[0]);
visitorMock.Expect(mock => mock.Visit(_originalColumnsReadonly[1])).Return(expectedColumns[1]);
visitorMock.Expect(mock => mock.Visit(_originalColumnsReadonly[2])).Return(expectedColumns[2]);
visitorMock.Replay();
var expression = (SqlEntityExpression)ExtensionExpressionTestHelper.CallVisitChildren(_entityExpression, visitorMock);
Assert.That(expression, Is.Not.SameAs(_entityExpression));
Assert.That(expression.Type, Is.SameAs(_entityExpression.Type));
Assert.That(expression.Columns, Is.EqualTo(expectedColumns));
}
public void VisitChildren_NewArgs()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor> ();
var newArgs = new[] { Expression.Constant(1), Expression.Constant(8), Expression.Constant(9) };
visitorMock.Expect(mock => mock.Visit(_sqlFunctionExpression.Args[0])).Return(newArgs[0]);
visitorMock.Expect(mock => mock.Visit(_sqlFunctionExpression.Args[1])).Return(newArgs[1]);
visitorMock.Expect(mock => mock.Visit(_sqlFunctionExpression.Args[2])).Return(newArgs[2]);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_sqlFunctionExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_sqlFunctionExpression));
Assert.That(((SqlFunctionExpression)result).Args, Is.EqualTo(newArgs));
Assert.That(((SqlFunctionExpression)result).SqlFunctioName, Is.EqualTo("Test"));
}
public void VisitChildren_KeyExpressionChanged()
{
var newKeyExpression = Expression.Constant("newKey");
var visitorMock = MockRepository.GenerateMock <ExpressionTreeVisitor> ();
visitorMock.Expect(mock => mock.VisitExpression(_keyExpression)).Return(newKeyExpression);
visitorMock.Expect(mock => mock.VisitExpression(_elementExpression)).Return(_elementExpression);
visitorMock
.Expect(mock => mock.VisitAndConvert(Arg <ReadOnlyCollection <Expression> > .Is.Anything, Arg.Is("VisitChildren")))
.Return(null).WhenCalled(invocation => invocation.ReturnValue = invocation.Arguments[0]);
visitorMock.Replay();
var expression = ExtensionExpressionTestHelper.CallVisitChildren(_sqlGroupingSelectExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(expression, Is.Not.SameAs(_sqlGroupingSelectExpression));
Assert.That(((SqlGroupingSelectExpression)expression).KeyExpression, Is.SameAs(newKeyExpression));
Assert.That(((SqlGroupingSelectExpression)expression).ElementExpression, Is.SameAs(_elementExpression));
}
public void VisitChildren_VisitsIdentityExpression_Changed()
{
var newPrimaryKeyExpression = Expression.Constant(6);
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor> ();
visitorMock.Expect(mock => mock.Visit(_identityExpression)).Return(newPrimaryKeyExpression);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_expression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_expression));
Assert.That(result, Is.TypeOf <SqlEntityConstantExpression> ());
var newSqlEntityConstantExpression = ((SqlEntityConstantExpression)result);
Assert.That(newSqlEntityConstantExpression.IdentityExpression, Is.SameAs(newPrimaryKeyExpression));
Assert.That(newSqlEntityConstantExpression.Value, Is.SameAs(_expression.Value));
Assert.That(newSqlEntityConstantExpression.Type, Is.SameAs(_expression.Type));
}
public void VisitChildren_ReturnsSame()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor>();
visitorMock
.Expect(mock => mock.Visit(_likeExpression.Left))
.Return(_likeExpression.Left);
visitorMock
.Expect(mock => mock.Visit(_likeExpression.Right))
.Return(_likeExpression.Right);
visitorMock
.Expect(mock => mock.Visit(_likeExpression.EscapeExpression))
.Return(_likeExpression.EscapeExpression);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_likeExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_likeExpression));
}
public void VisitChildren_NewArgs()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionTreeVisitor> ();
var newArgs = new ReadOnlyCollection <Expression> (new List <Expression> {
Expression.Constant(1), Expression.Constant(2)
});
visitorMock
.Expect(mock => mock.VisitAndConvert(_sqlFunctionExpression.Args, "SqlFunctionExpression.VisitChildren"))
.Return(newArgs);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_sqlFunctionExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_sqlFunctionExpression));
Assert.That(((SqlFunctionExpression)result).Args, Is.EqualTo(newArgs));
Assert.That(((SqlFunctionExpression)result).SqlFunctioName, Is.EqualTo("Test"));
}
public void VisitChildren_ReturnsNewSqlInExpression()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor>();
var newLeftExpression = Expression.Constant(3);
var newRightExpression = Expression.Constant(4);
visitorMock
.Expect(mock => mock.Visit(_leftExpression))
.Return(newLeftExpression);
visitorMock
.Expect(mock => mock.Visit(_rightExpression))
.Return(newRightExpression);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_expression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_expression));
Assert.That(((SqlInExpression)result).LeftExpression, Is.SameAs(newLeftExpression));
Assert.That(((SqlInExpression)result).RightExpression, Is.SameAs(newRightExpression));
}
public void VisitChildren_ChangeAggregationExpression()
{
var newAggregationExpression = Expression.Constant("newAgg");
var expectedAggregationExpressions = new Expression[] { _aggregateExpression1, newAggregationExpression };
var visitorMock = MockRepository.GenerateMock <ExpressionTreeVisitor>();
visitorMock.Expect(mock => mock.VisitExpression(_keyExpression)).Return(_keyExpression);
visitorMock.Expect(mock => mock.VisitExpression(_elementExpression)).Return(_elementExpression);
visitorMock
.Expect(mock => mock.VisitAndConvert(Arg <ReadOnlyCollection <Expression> > .Is.Anything, Arg.Is("VisitChildren")))
.Return(Array.AsReadOnly(expectedAggregationExpressions));
visitorMock.Replay();
var expression = ExtensionExpressionTestHelper.CallVisitChildren(_sqlGroupingSelectExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(expression, Is.Not.SameAs(_sqlGroupingSelectExpression));
Assert.That(expression, Is.TypeOf(typeof(SqlGroupingSelectExpression)));
Assert.That(((SqlGroupingSelectExpression)expression).AggregationExpressions[0], Is.SameAs(_aggregateExpression1));
Assert.That(((SqlGroupingSelectExpression)expression).AggregationExpressions[1], Is.SameAs(newAggregationExpression));
}
public void VisitChildren_NoElse()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor> ();
visitorMock
.Expect(mock => mock.Visit(_predicate1))
.Return(_predicate1);
visitorMock
.Expect(mock => mock.Visit(_predicate2))
.Return(_predicate2);
visitorMock
.Expect(mock => mock.Visit(_nullableValue1))
.Return(_nullableValue1);
visitorMock
.Expect(mock => mock.Visit(_value2))
.Return(_value2);
var result = ExtensionExpressionTestHelper.CallVisitChildren(_caseExpressionWithoutElse, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_caseExpressionWithoutElse));
}
public void VisitChildren_NewOrderingExpressions()
{
var visitorMock = MockRepository.GenerateMock <ExpressionTreeVisitor> ();
var fakeResult = Expression.Constant(3);
visitorMock
.Expect(mock => mock.VisitExpression(_orderingExpression1))
.Return(fakeResult);
visitorMock
.Expect(mock => mock.VisitExpression(_orderingExpression2))
.Return(_orderingExpression2);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_sqlRowNumberExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_sqlRowNumberExpression));
Assert.That(((SqlRowNumberExpression)result).Orderings[0].Expression, Is.SameAs(fakeResult));
Assert.That(((SqlRowNumberExpression)result).Orderings[0].OrderingDirection, Is.EqualTo(OrderingDirection.Asc));
Assert.That(((SqlRowNumberExpression)result).Orderings[1].Expression, Is.SameAs(_orderingExpression2));
Assert.That(((SqlRowNumberExpression)result).Orderings[1].OrderingDirection, Is.EqualTo(OrderingDirection.Desc));
}
public void VisitChildren_ReturnsDifferentEscapeExpression()
{
var visitorMock = MockRepository.GenerateStrictMock <ExpressionTreeVisitor> ();
var newEscapeExpression = Expression.Constant(3);
visitorMock
.Expect(mock => mock.VisitExpression(_likeExpression.Left))
.Return(_likeExpression.Left);
visitorMock
.Expect(mock => mock.VisitExpression(_likeExpression.Right))
.Return(_likeExpression.Right);
visitorMock
.Expect(mock => mock.VisitExpression(_likeExpression.EscapeExpression))
.Return(newEscapeExpression);
visitorMock.Replay();
var result = ExtensionExpressionTestHelper.CallVisitChildren(_likeExpression, visitorMock);
visitorMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(_likeExpression));
Assert.That(((SqlLikeExpression)result).Left, Is.SameAs(_likeExpression.Left));
Assert.That(((SqlLikeExpression)result).Right, Is.SameAs(_likeExpression.Right));
Assert.That(((SqlLikeExpression)result).EscapeExpression, Is.SameAs(newEscapeExpression));
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlCollectionExpression, ISqlCollectionExpressionVisitor> (
_collectionExpression,
mock => mock.VisitSqlCollectionExpression(_collectionExpression));
}
public void Accept_VisitorNotSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorNotSupportingType(_sqlGroupingSelectExpression);
}
public void Accept_VisitorNotSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorNotSupportingType(_caseExpressionWithElse);
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlGroupingSelectExpression, ISqlGroupingSelectExpressionVisitor> (
_sqlGroupingSelectExpression,
mock => mock.VisitSqlGroupingSelect(_sqlGroupingSelectExpression));
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlEntityRefMemberExpression, ISqlEntityRefMemberExpressionVisitor> (
_expression,
mock => mock.VisitSqlEntityRefMember(_expression));
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlLengthExpression, ISqlSpecificExpressionVisitor> (
_lengthExpression,
mock => mock.VisitSqlLength(_lengthExpression));
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlEntityExpression, IResolvedSqlExpressionVisitor> (
_entityExpression,
mock => mock.VisitSqlEntityExpression(_entityExpression));
}
public void Accept_VisitorNotSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorNotSupportingType(_sqlConvertedBooleanExpression);
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType<SqlIsNotNullExpression, ISqlNullCheckExpressionVisitor> (
_sqlIsNotNullExpression,
mock => mock.VisitSqlIsNotNullExpression (_sqlIsNotNullExpression));
}
public void Accept_VisitorNotSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorNotSupportingType(_collectionExpression);
}
public void Accept_VisitorNotSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorNotSupportingType(_tableReferenceExpression);
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlTableReferenceExpression, ISqlTableReferenceExpressionVisitor> (
_tableReferenceExpression,
mock => mock.VisitSqlTableReferenceExpression(_tableReferenceExpression));
}
public void Accept_VisitorSupportingExpressionType_IResolvedSqlExpressionVisitor()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <SqlColumnReferenceExpression, IResolvedSqlExpressionVisitor> (
_columnExpression,
mock => mock.VisitSqlColumnExpression(_columnExpression));
}
public void Accept_VisitorSupportingExpressionType()
{
ExtensionExpressionTestHelper.CheckAcceptForVisitorSupportingType <NamedExpression, INamedExpressionVisitor> (
_namedExpression,
mock => mock.VisitNamedExpression(_namedExpression));
}
