public void CreateQueryModel_WithSelectClauseBeforeAnotherClause()
{
IQueryable <int> value = new[] { 1, 2, 3 }.AsQueryable();
// ReSharper disable RedundantAnonymousTypePropertyName
var expressionTree = (MethodCallExpression)ExpressionHelper.MakeExpression(
() => value.Select(i => new AnonymousType {
a = i, b = i + 1
}).Where(trans => trans.a > 5));
// ReSharper restore RedundantAnonymousTypePropertyName
QueryModel queryModel = _queryParser.GetParsedQuery(expressionTree);
Assert.That(queryModel.BodyClauses.Count(), Is.EqualTo(1));
var whereClause = (WhereClause)(queryModel.BodyClauses[0]);
var selectClause = queryModel.SelectClause;
var expectedPredicate = ExpressionHelper.Resolve <int, bool> (queryModel.MainFromClause, i => i > 5);
ExpressionTreeComparer.CheckAreEqualTrees(expectedPredicate, whereClause.Predicate);
var expectedSelector = ExpressionHelper.Resolve <int, AnonymousType> (queryModel.MainFromClause, i => new AnonymousType {
a = i, b = i + 1
});
ExpressionTreeComparer.CheckAreEqualTrees(expectedSelector, selectClause.Selector);
}
public void MemberInitExpressionForDerivedTypeCanBeUsedWithPropertyTypedAsBaseType()
{
Expression <Func <Cook, Result <BaseValue> > > lambaExpression =
c => new Result <BaseValue> {
Value = new DerivedValue {
StringValue = c.FirstName
}
};
// new Result { ... }
var resultInitExpression = ((MemberInitExpression)lambaExpression.Body);
// BaseValue = new DerivedValue { ... }
var derivedValueMemberAssignment = ((MemberAssignment)resultInitExpression.Bindings[0]);
// new DerivedValue { ... }
var derivedValueInitExpression = (MemberInitExpression)(derivedValueMemberAssignment.Expression);
// StringValue = c.FirstName
var derivedValueStringValueMemberAssignment = ((MemberAssignment)derivedValueInitExpression.Bindings[0]);
// c.FirstName
var derivedValueStringValuePropertyExpression = (MemberExpression)derivedValueStringValueMemberAssignment.Expression;
var inputParameter = Expression.Parameter(typeof(Result <BaseValue>), "input");
var result = AccessorFindingExpressionVisitor.FindAccessorLambda(
searchedExpression: derivedValueStringValuePropertyExpression,
fullExpression: resultInitExpression,
inputParameter: inputParameter);
Expression <Func <Result <BaseValue>, string> > expectedResult = input => ((DerivedValue)input.Value).StringValue;
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void IntegrationTest_CreateQueryModel_WithResultOperator_BeforeWhere()
{
IQueryable <int> value = new[] { 1, 2, 3 }.AsQueryable();
// ReSharper disable RedundantAnonymousTypePropertyName
var expressionTree = (MethodCallExpression)ExpressionHelper.MakeExpression(() => value.Select(i => i + 1).Distinct().Where(i => i > 5));
// ReSharper restore RedundantAnonymousTypePropertyName
QueryModel queryModel = _queryParser.GetParsedQuery(expressionTree);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(0));
var selectClause = queryModel.SelectClause;
var expectedSelector = ExpressionHelper.Resolve <int, int> (queryModel.MainFromClause, i => i);
ExpressionTreeComparer.CheckAreEqualTrees(expectedSelector, selectClause.Selector);
var subQueryModel = ((SubQueryExpression)queryModel.MainFromClause.FromExpression).QueryModel;
var subSelectClause = subQueryModel.SelectClause;
var expectedSubSelector = ExpressionHelper.Resolve <int, int> (subQueryModel.MainFromClause, i => i + 1);
ExpressionTreeComparer.CheckAreEqualTrees(expectedSubSelector, subSelectClause.Selector);
Assert.That(subQueryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(DistinctResultOperator)));
}
public void NewExpressionForAnonymousType()
{
Expression <Func <Cook, dynamic> > lambaExpression = c => new { OuterValue = new { InnerValue = c.FirstName } };
// new OuterType (...)
var resultInitExpression = ((NewExpression)lambaExpression.Body);
// new InnerType (...)
var derivedValueInitExpression = (NewExpression)resultInitExpression.Arguments[0];
// c.FirstName
var derivedValueStringValuePropertyExpression = (MemberExpression)derivedValueInitExpression.Arguments[0];
var inputParameter = Expression.Parameter(resultInitExpression.Type, "input");
var result = AccessorFindingExpressionVisitor.FindAccessorLambda(
searchedExpression: derivedValueStringValuePropertyExpression,
fullExpression: resultInitExpression,
inputParameter: inputParameter);
// Expression<Func<dynamic, string>> input => input.OuterValue.InnerValue;
var expectedParameter = Expression.Parameter(resultInitExpression.Type, "input");
#if !NET_3_5
var expectedOuterProperty = Expression.Property(expectedParameter, "OuterValue");
var expectedInnerProperty = Expression.Property(expectedOuterProperty, "InnerValue");
var expectedResult = Expression.Lambda(expectedInnerProperty, expectedParameter);
#else
var expectedOuterGetter = Expression.Call(expectedParameter, "get_OuterValue", new Type[0]);
var expectedInnerGetter = Expression.Call(expectedOuterGetter, "get_InnerValue", new Type[0]);
var expectedResult = Expression.Lambda(expectedInnerGetter, expectedParameter);
#endif
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void MakeSerializable_SerializableType()
{
var proxyType = MutableTypeObjectMother.Create(typeof(SomeType), attributes: TypeAttributes.Serializable);
_enabler.MakeSerializable(proxyType, _participantConfigurationID, _assembledTypeIdentifierProviderStub.Object, _typeID);
Assert.That(proxyType.AddedInterfaces, Is.EqualTo(new[] { typeof(ISerializable) }));
Assert.That(proxyType.AddedConstructors, Is.Empty);
Assert.That(proxyType.AddedMethods, Has.Count.EqualTo(1));
var method = proxyType.AddedMethods.Single();
var serializationInfo = method.ParameterExpressions[0];
var expectedMethodBody = Expression.Block(
Expression.Block(
Expression.Call(
serializationInfo, "SetType", Type.EmptyTypes, Expression.Constant(typeof(ObjectWithoutDeserializationConstructorProxy))),
Expression.Call(
serializationInfo,
"AddValue",
Type.EmptyTypes,
Expression.Constant("<tp>participantConfigurationID"),
Expression.Constant(_participantConfigurationID)),
Expression.Call(serializationInfo, "AddValue", Type.EmptyTypes, Expression.Constant("<tp>assembledTypeIDData"), _assembledTypeIDData)),
Expression.Call(
typeof(ReflectionSerializationHelper), "AddFieldValues", Type.EmptyTypes, serializationInfo, new ThisExpression(proxyType)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedMethodBody, method.Body);
}
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 GetResolvedOuterKeySelector()
{
var resolvedExpression = _node.GetResolvedOuterKeySelector(ClauseGenerationContext);
var expectedExpression = ExpressionHelper.Resolve <string, string> (SourceClause, o => o.ToString());
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, resolvedExpression);
}
public void SetBody()
{
var declaringType = MutableTypeObjectMother.Create();
var attribtes = MethodAttributes.Virtual; // Methods which have a base method must be virtual.
var returnType = typeof(object);
var parameters = ParameterDeclarationObjectMother.CreateMultiple(2);
var baseMethod = ReflectionObjectMother.GetSomeVirtualMethod(); // Base method must be virtual.
var genericParameters = new[] { MutableGenericParameterObjectMother.Create() };
var method = MutableMethodInfoObjectMother.Create(
declaringType, "Method", attribtes, returnType, parameters, baseMethod, genericParameters: genericParameters);
var fakeBody = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
Func <MethodBodyModificationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.DeclaringType, Is.SameAs(declaringType));
Assert.That(ctx.IsStatic, Is.False);
Assert.That(ctx.Parameters, Is.EqualTo(method.ParameterExpressions).And.Not.Empty);
Assert.That(ctx.GenericParameters, Is.EqualTo(genericParameters));
Assert.That(ctx.ReturnType, Is.SameAs(returnType));
Assert.That(ctx.BaseMethod, Is.SameAs(baseMethod));
Assert.That(ctx.PreviousBody, Is.SameAs(method.Body));
return(fakeBody);
};
method.SetBody(bodyProvider);
var expectedBody = Expression.Convert(fakeBody, returnType);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
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 CreateBody_BuildsCorrectBody_UsingAbstractTemplateMembers()
{
var accessorImplementationMethod =
NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((PropertyAccessor a) => a.SetValue <object> (null));
var arguments = new Expression[] { Expression.Parameter(typeof(int), "param") };
var ctx = new MethodBodyModificationContext(_proxyType, false, new ParameterExpression[0], Type.EmptyTypes, typeof(int), null, null);
_interceptorPartialMock
.Stub(stub => PrivateInvoke.GetNonPublicProperty(stub, "AccessorImplementationMethod"))
.Return(accessorImplementationMethod);
_interceptorPartialMock
.Stub(stub => PrivateInvoke.InvokeNonPublicMethod(stub, "GetArguments", Arg <MethodBaseBodyContextBase> .Is.Anything))
.WhenCalled(mi => Assert.That(mi.Arguments[0], Is.SameAs(ctx)))
.Return(arguments);
var result = (Expression)PrivateInvoke.InvokeNonPublicMethod(_interceptorPartialMock, "CreateBody", ctx);
var expectedbody =
Expression.Call(
Expression.Call(
Expression.Property(
new ThisExpression(_proxyType),
typeof(DomainObject).GetProperty("Properties", BindingFlags.Instance | BindingFlags.NonPublic)),
"get_Item",
null,
Expression.Constant("abc")),
"SetValue",
new[] { typeof(int) },
arguments);
ExpressionTreeComparer.CheckAreEqualTrees(expectedbody, result);
}
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 Transform_DictionaryEntry_ValueCtor()
{
var expression = Expression.New(
typeof(DictionaryEntry).GetConstructor(new[] { typeof(object), typeof(object) }),
Expression.Constant("test"),
Expression.Constant("v"));
var result = _transformer.Transform(expression);
if (Environment.Version.Major == 2)
{
var expectedExpression35 = Expression.New(
typeof(DictionaryEntry).GetConstructor(new[] { typeof(object), typeof(object) }),
new Expression[] { Expression.Convert(Expression.Constant("test"), typeof(object)), Expression.Convert(Expression.Constant("v"), typeof(object)) },
new MemberInfo[] { typeof(DictionaryEntry).GetMethod("get_Key"), typeof(DictionaryEntry).GetMethod("get_Value") });
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression35, result);
}
else
{
var expectedExpression40 = Expression.New(
typeof(DictionaryEntry).GetConstructor(new[] { typeof(object), typeof(object) }),
new Expression[]
{ Expression.Convert(Expression.Constant("test"), typeof(object)), Expression.Convert(Expression.Constant("v"), typeof(object)) },
new MemberInfo[] { typeof(DictionaryEntry).GetProperty("Key"), typeof(DictionaryEntry).GetProperty("Value") });
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression40, result);
}
}
public void WireConstructorWithInitialization()
{
var counter = MutableFieldInfoObjectMother.Create(_mutableType, type: typeof(int));
var initMethod = MutableMethodInfoObjectMother.Create(
_mutableType, parameters: new[] { ParameterDeclarationObjectMother.Create(typeof(InitializationSemantics)) });
var initializationMembers = Tuple.Create <FieldInfo, MethodInfo> (counter, initMethod);
var constructor = MutableConstructorInfoObjectMother.Create(_mutableType);
var oldBody = constructor.Body;
_proxySerializationEnablerMock.Expect(mock => mock.IsDeserializationConstructor(constructor)).Return(false);
_builder.WireConstructorWithInitialization(constructor, initializationMembers, _proxySerializationEnablerMock);
_proxySerializationEnablerMock.VerifyAllExpectations();
var expectedBody = Expression.Block(
Expression.Assign(
Expression.Field(new ThisExpression(_mutableType), counter),
Expression.Add(Expression.Field(new ThisExpression(_mutableType), counter), Expression.Constant(1))),
oldBody,
Expression.Assign(
Expression.Field(new ThisExpression(_mutableType), counter),
Expression.Subtract(Expression.Field(new ThisExpression(_mutableType), counter), Expression.Constant(1))),
Expression.IfThen(
Expression.Equal(Expression.Field(new ThisExpression(_mutableType), counter), Expression.Constant(0)),
Expression.Call(new ThisExpression(_mutableType), initMethod, Expression.Constant(InitializationSemantics.Construction))));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, constructor.Body);
}
public void CheckAreEqualTrees_WithListValueAndEqualValues_DoesNotThrow()
{
Expression expected = Expression.Constant(new[] { "a" }, typeof(string[]));
Expression actual = Expression.Constant(new[] { "a" }, typeof(string[]));
Assert.That(() => ExpressionTreeComparer.CheckAreEqualTrees(expected, actual), Throws.Nothing);
}
public void ConstantReferenceToOtherQuery_IsInlined_AndPartiallyEvaluated()
{
var query1 = from c in QuerySource where 1.ToString () == "1" select c;
var query2 = from k in DetailQuerySource where query1.Contains(k.Cook) select k;
// Handle this as if someone had written: from k in DetailQuerySource where (from c in QuerySource select c).Contains (k.Cook) select k;
var queryModel = QueryParser.GetParsedQuery(query2.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
Assert.That(whereClause.Predicate, Is.TypeOf(typeof(SubQueryExpression)));
var subQuery = ((SubQueryExpression)whereClause.Predicate).QueryModel;
CheckConstantQuerySource(subQuery.MainFromClause.FromExpression, QuerySource);
CheckResolvedExpression <Cook, Cook> (subQuery.SelectClause.Selector, subQuery.MainFromClause, c => c);
var subQueryWhereClause = (WhereClause)subQuery.BodyClauses[0];
var expectedSubQueryWherePredicate = Expression.Constant(true);
ExpressionTreeComparer.CheckAreEqualTrees(expectedSubQueryWherePredicate, subQueryWhereClause.Predicate);
Assert.That(subQuery.ResultOperators.Count, Is.EqualTo(1));
Assert.That(subQuery.ResultOperators[0], Is.TypeOf(typeof(ContainsResultOperator)));
CheckResolvedExpression <Kitchen, Cook> (((ContainsResultOperator)subQuery.ResultOperators[0]).Item, queryModel.MainFromClause, k => k.Cook);
}
public void AggregateExpressionsIntoTuple_ThreeeExpressions()
{
var expression1 = Expression.Constant("expr1");
var expression2 = Expression.Constant("expr2");
var expression3 = Expression.Constant("expr3");
var result = TupleExpressionBuilder.AggregateExpressionsIntoTuple(new[] { expression1, expression2, expression3 });
var innerTupleCtor = typeof(KeyValuePair <string, string>).GetConstructor(new[] { typeof(string), typeof(string) });
var outerTupleCtor =
typeof(KeyValuePair <string, KeyValuePair <string, string> >).GetConstructor(
new[] { typeof(string), typeof(KeyValuePair <string, string>) });
var innerTupleKeyGetter = innerTupleCtor.DeclaringType.GetMethod("get_Key");
var innerTupleValueGetter = innerTupleCtor.DeclaringType.GetMethod("get_Value");
var outerTupleKeyGetter = outerTupleCtor.DeclaringType.GetMethod("get_Key");
var outerTupleValueGetter = outerTupleCtor.DeclaringType.GetMethod("get_Value");
var expectedResult = Expression.New(
outerTupleCtor,
new Expression[]
{
expression1,
Expression.New(innerTupleCtor, new[] { expression2, expression3 }, innerTupleKeyGetter, innerTupleValueGetter)
},
outerTupleKeyGetter,
outerTupleValueGetter);
ExpressionTreeComparer.CheckAreEqualTrees(result, expectedResult);
}
public void CheckAreEqualTrees_WithNestedExpressionAndEqualValues_DoesNotThrow()
{
Expression expected = Expression.Equal(Expression.Constant("a"), Expression.Constant("b"));
Expression actual = Expression.Equal(Expression.Constant("a"), Expression.Constant("b"));
Assert.That(() => ExpressionTreeComparer.CheckAreEqualTrees(expected, actual), Throws.Nothing);
}
public void Aggregate_Seed_WithResultSelector()
{
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s).Aggregate(0, (totalIDs, s) => totalIDs + s.ID, totalIDs => totalIDs.ToString()));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(string)));
CheckConstantQuerySource(queryModel.MainFromClause.FromExpression, QuerySource);
Assert.That(queryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(queryModel.ResultOperators[0], Is.InstanceOf(typeof(AggregateFromSeedResultOperator)));
var resultOperator = (AggregateFromSeedResultOperator)queryModel.ResultOperators[0];
Assert.That(resultOperator.GetConstantSeed <int> (), Is.EqualTo(0));
var expectedFunc = ExpressionHelper.ResolveLambdaParameter <int, Cook, int> (
1,
queryModel.MainFromClause,
(totalIDs, s) => totalIDs + s.ID);
ExpressionTreeComparer.CheckAreEqualTrees(expectedFunc, resultOperator.Func);
var expectedResultSelector = ExpressionHelper.CreateLambdaExpression <int, string> (totalIDs => totalIDs.ToString());
ExpressionTreeComparer.CheckAreEqualTrees(expectedResultSelector, resultOperator.OptionalResultSelector);
}
public void Resolve_ReplacesParameter_WithProjection()
{
var node = new SelectManyExpressionNode(
CreateParseInfo(),
_collectionSelector,
ExpressionHelper.CreateLambdaExpression <int, int, AnonymousType> ((a, b) => new AnonymousType(a, b)));
node.Apply(QueryModel, ClauseGenerationContext);
var clause = (FromClauseBase)QueryModel.BodyClauses[0];
var expression = ExpressionHelper.CreateLambdaExpression <AnonymousType, bool> (i => i.a > 5 && i.b > 6);
var result = node.Resolve(expression.Parameters[0], expression.Body, ClauseGenerationContext);
var selectManySourceReference = new QuerySourceReferenceExpression(clause);
// new AnonymousType (SourceReference, selectManySourceReference).a > 5 && new AnonymousType (SourceReference, selectManySourceReference).b > 6
var newAnonymousTypeExpression = Expression.New(
typeof(AnonymousType).GetConstructor(new[] { typeof(int), typeof(int) }), SourceReference, selectManySourceReference);
var anonymousTypeMemberAExpression = Expression.MakeMemberAccess(newAnonymousTypeExpression, typeof(AnonymousType).GetProperty("a"));
var anonymousTypeMemberBExpression = Expression.MakeMemberAccess(newAnonymousTypeExpression, typeof(AnonymousType).GetProperty("b"));
var expectedResult = Expression.MakeBinary(
ExpressionType.AndAlso,
Expression.MakeBinary(ExpressionType.GreaterThan, anonymousTypeMemberAExpression, Expression.Constant(5)),
Expression.MakeBinary(ExpressionType.GreaterThan, anonymousTypeMemberBExpression, Expression.Constant(6)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void MakeSerializable_SerializableInterfaceType()
{
var proxyType = MutableTypeObjectMother.Create(typeof(SerializableInterfaceType), attributes: TypeAttributes.Serializable);
_enabler.MakeSerializable(proxyType, _participantConfigurationID, _assembledTypeIdentifierProviderStub.Object, _typeID);
Assert.That(proxyType.AddedInterfaces, Is.Empty);
Assert.That(proxyType.AddedMethods, Has.Count.EqualTo(1));
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((SerializableInterfaceType o) => o.GetObjectData(null, new StreamingContext()));
var method = proxyType.AddedMethods.Single();
var serializationInfo = method.ParameterExpressions[0];
var expectedBody = Expression.Block(
Expression.Call(new ThisExpression(proxyType), new NonVirtualCallMethodInfoAdapter(baseMethod), method.ParameterExpressions.Cast <Expression>()),
Expression.Block(
Expression.Call(serializationInfo, "SetType", Type.EmptyTypes, Expression.Constant(typeof(ObjectWithDeserializationConstructorProxy))),
Expression.Call(
serializationInfo,
"AddValue",
Type.EmptyTypes,
Expression.Constant("<tp>participantConfigurationID"),
Expression.Constant(_participantConfigurationID)),
Expression.Call(serializationInfo, "AddValue", Type.EmptyTypes, Expression.Constant("<tp>assembledTypeIDData"), _assembledTypeIDData)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
public void Transform_Tuple2_ValueCtor()
{
var expression = Expression.New(
typeof(Tuple <string, int>).GetConstructor(new[] { typeof(string), typeof(int) }),
Expression.Constant("test"),
Expression.Constant(0));
var result = _transformer.Transform(expression);
if (Environment.Version.Major == 2)
{
var expectedExpression35 = Expression.New(
typeof(Tuple <string, int>).GetConstructor(new[] { typeof(string), typeof(int) }),
new Expression[] { Expression.Constant("test"), Expression.Constant(0) },
new MemberInfo[] { typeof(Tuple <string, int>).GetMethod("get_Item1"), typeof(Tuple <string, int>).GetMethod("get_Item2") });
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression35, result);
}
else
{
var expectedExpression40 = Expression.New(
typeof(Tuple <string, int>).GetConstructor(new[] { typeof(string), typeof(int) }),
new Expression[] { Expression.Constant("test"), Expression.Constant(0) },
new MemberInfo[] { typeof(Tuple <string, int>).GetProperty("Item1"), typeof(Tuple <string, int>).GetProperty("Item2") });
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression40, result);
}
}
public void NestedNewExpression()
{
var outerAnonymousTypeCtor = typeof(AnonymousType <int, AnonymousType>).GetConstructor(new[] { typeof(int), typeof(AnonymousType) });
var outerAnonymousTypeAGetter = typeof(AnonymousType <int, AnonymousType>).GetMethod("get_a");
var outerAnonymousTypeBGetter = typeof(AnonymousType <int, AnonymousType>).GetMethod("get_b");
var outerAnonymousTypeBProperty = typeof(AnonymousType <int, AnonymousType>).GetProperty("b");
// new AnonymousType (get_a = 2, get_b = new AnonymousType (get_a = _searchedExpression, get_b = 1))
var innerExpression = Expression.New(
_anonymousTypeCtorWithArgs,
new[] { _searchedExpression, Expression.Constant(1) },
_anonymousTypeAGetter,
_anonymousTypeBGetter);
var fullExpression = Expression.New(
outerAnonymousTypeCtor,
new Expression[] { Expression.Constant(2), innerExpression },
outerAnonymousTypeAGetter,
outerAnonymousTypeBGetter);
var result = AccessorFindingExpressionTreeVisitor.FindAccessorLambda(_searchedExpression, fullExpression, _nestedInputParameter);
var inputParameter = Expression.Parameter(typeof(AnonymousType <int, AnonymousType>), "input");
var expectedResult = Expression.Lambda(
Expression.MakeMemberAccess(Expression.MakeMemberAccess(inputParameter, outerAnonymousTypeBProperty), _anonymousTypeAProperty),
inputParameter); // input => input.get_b().get_a()
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void TrivialExpression()
{
var result = AccessorFindingExpressionTreeVisitor.FindAccessorLambda(_searchedExpression, _searchedExpression, _intInputParameter);
Expression <Func <int, int> > expectedResult = input => input;
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GetResolvedSelector()
{
var expectedResult = Expression.MakeBinary(ExpressionType.GreaterThan, SourceReference, Expression.Constant(5));
var result = _node.GetResolvedKeySelector(ClauseGenerationContext);
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GetResolvedCollectionSelector()
{
var expectedResult = Expression.NewArrayBounds(typeof(double), Expression.Constant(1));
var result = _nodeWithResultSelector.GetResolvedCollectionSelector(ClauseGenerationContext);
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CheckAreEqualTrees_WithDerivedExpressionAndBaseClassIsEqual_DoesNotThrow()
{
Expression expected = Expression.Call(Expression.Parameter(typeof(object), "o"), typeof(object).GetMethod("ToString"));
Expression <Func <object, string> > actualLamba = o => o.ToString();
Expression actual = actualLamba.Body;
Assert.That(() => ExpressionTreeComparer.CheckAreEqualTrees(expected, actual), Throws.Nothing);
}
public void GetResolvedExpression_RemovesTransparentIdentifiers()
{
var result = _expressionResolver.GetResolvedExpression(_unresolvedLambda.Body, _unresolvedLambda.Parameters[0], ClauseGenerationContext);
var expectedResult = Expression.MakeBinary(ExpressionType.GreaterThan, SourceReference, Expression.Constant(5));
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
private static void CheckTypeIDDataExpression(Expression result, Type requestedType, Expression idPartExpression)
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AssembledTypeIDData("name", null));
var expected = Expression.New(
constructor, Expression.Constant(requestedType.AssemblyQualifiedName), Expression.NewArrayInit(typeof(IFlatValue), idPartExpression));
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void InvokePreviousBodyWithArguments_Enumerable()
{
var invokedBody = _context.InvokePreviousBodyWithArguments(_parameters.Cast <Expression> ().AsOneTime());
var expectedBody = Expression.Block(_parameters[0], _parameters[1]);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, invokedBody);
}
public void GetResolvedFunc()
{
var expectedResult = Expression.Lambda(Expression.Add(_func.Parameters[0], SourceReference), _func.Parameters[0]);
var result = _nodeWithResultSelector.GetResolvedFunc(ClauseGenerationContext);
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
