public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionOnLeftSideWithTwoPropertyInfoMembers_NotEqual()
{
var leftArgumentExpression1 = Expression.Constant(1);
var leftArgumentExpression2 = Expression.Constant(2);
var leftArgumentMemberInfo1 = typeof(TypeForNewExpression).GetProperty("A");
var leftArgumentMemberInfo2 = typeof(TypeForNewExpression).GetProperty("B");
var leftExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int), typeof(int)),
new[] { leftArgumentExpression1, leftArgumentExpression2 },
leftArgumentMemberInfo1,
leftArgumentMemberInfo2);
var rightExpression = new CustomExpression(typeof(TypeForNewExpression));
var expression = Expression.NotEqual(leftExpression, rightExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
var expectedResult =
Expression.OrElse(
Expression.NotEqual(
leftArgumentExpression1, Expression.MakeMemberAccess(rightExpression, typeof(TypeForNewExpression).GetProperty("A"))),
Expression.NotEqual(
leftArgumentExpression2, Expression.MakeMemberAccess(rightExpression, typeof(TypeForNewExpression).GetProperty("B"))));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedCorrectly()
{
var innerExpression = new NamedExpression("m0", Expression.Constant(0));
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { innerExpression });
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression);
Assert.That(result, Is.SameAs(expression));
}
public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionOnRightSideWithoutMembers_ThrowsException()
{
var rightArgumentExpression = Expression.Constant(1);
var rightExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), rightArgumentExpression);
var newConstantExpression = Expression.Constant(new TypeForNewExpression(0));
var expression = Expression.Equal(newConstantExpression, rightExpression);
_compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedCorrectly_WithGetters()
{
var innerExpression = new NamedExpression("A", Expression.Constant(0));
var memberInfo = (MemberInfo)typeof(TypeForNewExpression).GetProperty("A").GetGetMethod();
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { innerExpression }, memberInfo);
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression);
Assert.That(result, Is.SameAs(expression));
}
public void SplitPotentialCompoundComparison_SqlIsNotNullExpression_ExpandsNewExpression_ByCheckingAllArguments_ZeroArguments()
{
var newExpression = Expression.New(TypeForNewExpression.GetConstructor());
var sqlIsNotNullExpression = new SqlIsNotNullExpression(newExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(sqlIsNotNullExpression);
var expected = Expression.Constant(true);
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void GenerateSql_VistNewExpression()
{
var expression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new[] { Expression.Constant(0) },
(MemberInfo)typeof(TypeForNewExpression).GetProperty("A"));
SqlGeneratingExpressionVisitor.GenerateSql(expression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("@1"));
Assert.That(_commandBuilder.GetCommandParameters()[0].Value, Is.EqualTo(0));
}
public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionsWithDifferentCtors_ThrowsException()
{
var leftArgumentExpression = Expression.Constant(1);
var rightArgumentExpression1 = Expression.Constant(1);
var rightArgumentExpression2 = Expression.Constant(2);
var leftExpression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), leftArgumentExpression);
var rightExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int), typeof(int)), rightArgumentExpression1, rightArgumentExpression2);
var expression = Expression.Equal(leftExpression, rightExpression);
_compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
}
public void SplitPotentialCompoundComparison_SqlIsNotNullExpression_ExpandsNewExpression_ByCheckingAllArguments_OnlyOneArgument()
{
var arg1 = Expression.Constant(1);
var newExpression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { arg1 });
var sqlIsNotNullExpression = new SqlIsNotNullExpression(newExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(sqlIsNotNullExpression);
var expected = new SqlIsNotNullExpression(arg1);
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedWithDifferentName()
{
var innerExpression = new NamedExpression("test", Expression.Constant(0));
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { innerExpression });
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression);
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("m0", innerExpression) });
Assert.That(result, Is.Not.SameAs(expression));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void VisitNewExpression_NoMembers()
{
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { Expression.Constant(0) });
var result = SqlPreparationExpressionVisitor.TranslateExpression(expression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf(typeof(NewExpression)));
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(((NewExpression)result).Arguments.Count, Is.EqualTo(1));
Assert.That(((NewExpression)result).Arguments[0], Is.TypeOf(typeof(NamedExpression)));
Assert.That(((NewExpression)result).Members, Is.Null);
Assert.That(((NamedExpression)((NewExpression)result).Arguments[0]).Name, Is.EqualTo("m0"));
}
public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionWithOneArgument_ReturnsBinaryExpressionSequence()
{
var leftArgumentExpression = Expression.Constant(1);
var rightArgumentExpression = Expression.Constant(1);
var leftExpression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), leftArgumentExpression);
var rightExpression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), rightArgumentExpression);
var expression = Expression.Equal(leftExpression, rightExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
var expectedResult = Expression.Equal(leftArgumentExpression, rightArgumentExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void ResolveMemberAccess_OnNewExpression_NoMembers()
{
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
var newExpression = Expression.New(
constructorInfo,
new[] { new NamedExpression("value", new SqlLiteralExpression(1)), new NamedExpression("value", new SqlLiteralExpression(2)) });
MemberAccessResolver.ResolveMemberAccess(
newExpression,
typeof(TypeForNewExpression).GetField("C"),
_resolverMock,
_stageMock,
_mappingResolutionContext);
}
public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionOnRightSideWithOnePropertyInfoMember()
{
var rightArgumentExpression = Expression.Constant(1);
var rightArgumentMemberInfo = typeof(TypeForNewExpression).GetProperty("A");
var rightExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { rightArgumentExpression }, rightArgumentMemberInfo);
var leftExpression = new CustomExpression(typeof(TypeForNewExpression));
var expression = Expression.Equal(leftExpression, rightExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
var expectedResult = Expression.Equal(rightArgumentExpression, Expression.MakeMemberAccess(leftExpression, typeof(TypeForNewExpression).GetProperty("A")));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CreateNewExpressionWithNamedArguments_DedicatedArguments()
{
var memberInfo = (MemberInfo)typeof(TypeForNewExpression).GetProperty("A");
var originalArgument = ExpressionHelper.CreateExpression(typeof(int));
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { originalArgument }, memberInfo);
var processedArgument = ExpressionHelper.CreateExpression(typeof(int));
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression, new[] { processedArgument });
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("A", processedArgument) }, memberInfo);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CreateNewExpressionWithNamedArguments_WithPropertyCalledGet()
{
var innerExpression = Expression.Constant(0);
var memberInfo = (MemberInfo)typeof(TypeForNewExpression).GetProperty("get_");
var expression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new[] { innerExpression },
memberInfo);
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression);
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("get_", innerExpression) }, memberInfo);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void ResolveMemberAccess_OnNewExpression_FieldInfo()
{
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
var newExpression = Expression.New(
constructorInfo,
new[] { new NamedExpression("value", new SqlLiteralExpression(1)), new NamedExpression("value", new SqlLiteralExpression(2)) },
typeof(TypeForNewExpression).GetField("C"), typeof(TypeForNewExpression).GetMethod("get_B"));
var result = MemberAccessResolver.ResolveMemberAccess(
newExpression,
typeof(TypeForNewExpression).GetField("C"),
_resolverMock,
_stageMock,
_mappingResolutionContext);
Assert.That(result, Is.SameAs(((NamedExpression)newExpression.Arguments[0]).Expression));
}
public void NestedSelectProjection_MemberAccess_ToANewExpression_WithMemberNotInitialized()
{
var mainFromClause = new MainFromClause("k", typeof(Kitchen), Expression.Constant(Kitchens));
var querySourceReferenceExpression = new QuerySourceReferenceExpression(mainFromClause);
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
Trace.Assert(constructorInfo != null);
var newExpression = Expression.New(
constructorInfo,
new[] { MemberExpression.MakeMemberAccess(querySourceReferenceExpression, typeof(Kitchen).GetProperty("ID")),
MemberExpression.MakeMemberAccess(querySourceReferenceExpression, typeof(Kitchen).GetProperty("RoomNumber")) },
new MemberInfo[] { typeof(TypeForNewExpression).GetProperty("A"), typeof(TypeForNewExpression).GetProperty("B") });
var selectClause = new SelectClause(MemberExpression.MakeMemberAccess(newExpression, typeof(TypeForNewExpression).GetField("C")));
var queryModel = new QueryModel(mainFromClause, selectClause);
CheckQuery(queryModel, "");
}
public void ResolveSubStatementReferenceExpression_CreatesNewExpressionWithReferences_ForNewExpressions_WithoutMembers()
{
var newExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new[] { new NamedExpression("const", Expression.Constant(0)) });
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(newExpression);
var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement);
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(newExpression, tableInfo, sqlTable, _context);
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new Expression[] { new NamedExpression("m0", new SqlColumnDefinitionExpression(typeof(int), "q0", "const", false)) });
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void SplitPotentialCompoundComparison_BinaryExpression_NewExpressionWithTwoArguments_Equal_ReturnsBinaryExpressionSequence()
{
var leftArgumentExpression1 = Expression.Constant(1);
var leftArgumentExpression2 = Expression.Constant(2);
var rightArgumentExpression1 = Expression.Constant(1);
var rightArgumentExpression2 = Expression.Constant(2);
var leftExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int), typeof(int)), leftArgumentExpression1, leftArgumentExpression2);
var rightExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int), typeof(int)), rightArgumentExpression1, rightArgumentExpression2);
var expression = Expression.MakeBinary(ExpressionType.Equal, leftExpression, rightExpression);
var result = _compoundExpressionComparisonSplitter.SplitPotentialCompoundComparison(expression);
var expectedLeftSideExpression = Expression.Equal(leftArgumentExpression1, rightArgumentExpression1);
var expectedRightSideExpression = Expression.Equal(leftArgumentExpression2, rightArgumentExpression2);
var expectedResult = Expression.AndAlso(expectedLeftSideExpression, expectedRightSideExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void SetUp()
{
_context = new MappingResolutionContext();
_typeForNewExpressionConstructor = TypeForNewExpression.GetConstructor(typeof(int));
_namedExpressionCombiner = new NamedExpressionCombiner(_context);
}
