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); }