public void Contains_NonGenericIList()
{
IList list = new List <Cook> ();
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select list.Contains(s)));
var queryModel = QueryParser.GetParsedQuery(expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <bool>)));
Assert.That(queryModel.SelectClause.Selector, Is.TypeOf(typeof(SubQueryExpression)));
var subQueryModel = ((SubQueryExpression)queryModel.SelectClause.Selector).QueryModel;
Assert.That(subQueryModel.ResultOperators.Count, Is.EqualTo(1));
Assert.That(subQueryModel.ResultOperators[0], Is.InstanceOf(typeof(ContainsResultOperator)));
var exoectedItemExpression = new QuerySourceReferenceExpression(queryModel.MainFromClause);
ExpressionTreeComparer.CheckAreEqualTrees(exoectedItemExpression, ((ContainsResultOperator)subQueryModel.ResultOperators[0]).Item);
}
public void Transform_InnerLambdaExpression_WrappedInTrivialConvert()
{
// Input: ((Func<double, double, string>) ((p1, p2) => (p1 + p2).ToString())) (1.0, 2.0)
Expression <Func <double, double, string> > innerExpression = (p1, p2) => (p1 + p2).ToString();
var invokeExpression = Expression.Invoke(
Expression.Convert(innerExpression, innerExpression.Type),
Expression.Constant(1.0),
Expression.Constant(2.0));
var result = _transformer.Transform(invokeExpression);
// Output: (1.0 + 2.0).ToString()
var expectedExpression = Expression.Call(
Expression.Add(
Expression.Constant(1.0),
Expression.Constant(2.0)),
typeof(double).GetMethod("ToString", Type.EmptyTypes));
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void CreateProxy_CopiesAccessibleInstanceConstructors_WithPublicVisibility()
{
var result = _factory.CreateProxy(_domainType, ProxyKind.AssembledType).Type;
Assert.That(result.AddedConstructors, Has.Count.EqualTo(1));
var ctor = result.AddedConstructors.Single();
Assert.That(ctor.IsStatic, Is.False);
Assert.That(ctor.IsPublic, Is.True, "Changed from 'family or assembly'.");
Assert.That(ctor.IsHideBySig, Is.True);
var parameter = ctor.GetParameters().Single();
CustomParameterInfoTest.CheckParameter(parameter, ctor, 0, "i", typeof(int).MakeByRefType(), ParameterAttributes.Out);
var baseCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainType(out Dev <int> .Dummy));
var expectedBody = Expression.Call(
new ThisExpression(result), NonVirtualCallMethodInfoAdapter.Adapt(baseCtor), ctor.ParameterExpressions.Cast <Expression>());
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, ctor.Body);
}
public void CheckAreEqualTrees_WithNestedExpressionAndValuesNotEqual_Throws()
{
Expression expected = Expression.Equal(Expression.Constant("a"), Expression.Constant("b"));
Expression actual = Expression.Equal(Expression.Constant("b"), Expression.Constant("a"));
Assert.That(
() => ExpressionTreeComparer.CheckAreEqualTrees(expected, actual),
Throws.InvalidOperationException.With.Message.EqualTo(
"Trees are not equal: Property 'Value'\n"
#if !NET_3_5
+ "Node 1: \"b\"\nNode 2: \"a\"\n"
#else
+ "Node 1: \"a\"\nNode 2: \"b\"\n"
#endif
#if !NET_3_5
+ "Tree 1: (\"a\" == \"b\")\nTree 2: (\"b\" == \"a\")"
#else
+ "Tree 1: (\"a\" = \"b\")\nTree 2: (\"b\" = \"a\")"
#endif
));
}
public void Apply()
{
var sourceQueryModel = _nodeWithElementSelector.Source.Apply(QueryModel, ClauseGenerationContext);
Assert.That(sourceQueryModel, Is.SameAs(QueryModel));
var result = _nodeWithElementSelector.Apply(sourceQueryModel, ClauseGenerationContext);
Assert.That(result, Is.Not.SameAs(QueryModel));
var expectedFromExpression = new SubQueryExpression(sourceQueryModel);
ExpressionTreeComparer.CheckAreEqualTrees(expectedFromExpression, result.MainFromClause.FromExpression);
var expectedSelectClause =
ExpressionHelper.Resolve <IGrouping <short, string>, Tuple <short, int> > (result.MainFromClause, g => Tuple.Create(g.Key, g.Count()));
ExpressionTreeComparer.CheckAreEqualTrees(expectedSelectClause, result.SelectClause.Selector);
Assert.That(result.ResultTypeOverride, Is.EqualTo(typeof(IEnumerable <Tuple <short, int> >)));
}
public void VisitMainFromClause_AlsoFlattens()
{
var mainFromSubQuery = from sd in _detailSource
where sd.Name == "Maths"
select sd.Cook;
var parsedMainFromSubQuery = ExpressionHelper.ParseQuery(mainFromSubQuery);
var query = from s in ExpressionHelper.CreateQueryable <Cook>()
select s.FirstName;
var parsedQuery = ExpressionHelper.ParseQuery(query);
parsedQuery.MainFromClause.FromExpression = new SubQueryExpression(parsedMainFromSubQuery);
parsedQuery.Accept(_visitor);
var expectedSelector = ExpressionHelper.Resolve <Kitchen, string> (parsedQuery.MainFromClause, sd => sd.Cook.FirstName);
Assert.That(parsedQuery.MainFromClause.FromExpression, Is.Not.InstanceOf(typeof(SubQueryExpression)));
Assert.That(parsedQuery.BodyClauses.Count, Is.EqualTo(1));
ExpressionTreeComparer.CheckAreEqualTrees(expectedSelector, parsedQuery.SelectClause.Selector);
}
public void SimpleNewExpression()
{
// new AnonymousType (get_a = _searchedExpression, get_b = 1)
var fullExpression = Expression.New(
_anonymousTypeCtorWithArgs,
new[] { _searchedExpression, Expression.Constant(1) },
_anonymousTypeAGetter,
_anonymousTypeBGetter);
var result = AccessorFindingExpressionVisitor.FindAccessorLambda(_searchedExpression, fullExpression, _simpleInputParameter);
var inputParameter = Expression.Parameter(typeof(AnonymousType), "input");
var expectedResult = Expression.Lambda(
#if !NET_3_5
Expression.MakeMemberAccess(inputParameter, _anonymousTypeAProperty),
#else
Expression.Call(inputParameter, _anonymousTypeAGetter),
#endif
inputParameter);
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void Apply()
{
var result = _node.Apply(QueryModel, ClauseGenerationContext);
Assert.That(result, Is.SameAs(QueryModel));
var clause = (GroupJoinClause)QueryModel.BodyClauses[0];
Assert.That(clause.ItemName, Is.EqualTo("into"));
Assert.That(clause.ItemType, Is.SameAs(typeof(IEnumerable <string>)));
Assert.That(clause.JoinClause.ItemName, Is.EqualTo("i"));
Assert.That(clause.JoinClause.ItemType, Is.SameAs(typeof(string)));
Assert.That(clause.JoinClause.InnerSequence, Is.SameAs(_innerSequence));
var expectedOuterKeySelector = ExpressionHelper.Resolve(SourceClause, _outerKeySelector);
ExpressionTreeComparer.CheckAreEqualTrees(expectedOuterKeySelector, clause.JoinClause.OuterKeySelector);
var expectedInnerKeySelector = ExpressionHelper.Resolve(clause.JoinClause, _innerKeySelector);
ExpressionTreeComparer.CheckAreEqualTrees(expectedInnerKeySelector, clause.JoinClause.InnerKeySelector);
}
public void EvaluateIndependentSubtrees_WithFilter_IsEvaluatable_ReturnsEvaluatedExpression()
{
var left = Expression.Constant(1);
var right = Expression.Constant(2);
var expression = Expression.MakeBinary(ExpressionType.Add, left, right);
var expectedExpression = Expression.Constant(3);
var filterMock = MockRepository.GenerateStrictMock <IEvaluatableExpressionFilter>();
filterMock.Expect(_ => _.IsEvaluatableBinary(expression)).Return(true);
filterMock.Expect(_ => _.IsEvaluatableConstant(left)).Return(true);
filterMock.Expect(_ => _.IsEvaluatableConstant(right)).Return(true);
filterMock.Expect(_ => _.IsEvaluatableConstant(Arg <ConstantExpression> .Matches(e => ((int)e.Value) == 3))).Return(true);
filterMock.Replay();
var result = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(expression, filterMock);
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
filterMock.VerifyAllExpectations();
}
public void CreateInstanceInitializationMembers()
{
_mutableType.AddInitialization(ctx => Expression.Constant("blub"));
_mutableType.AddInitialization(ctx => ctx.InitializationSemantics);
var result = _builder.CreateInitializationMembers(_mutableType);
var counter = (MutableFieldInfo)result.Item1;
var initMethod = (MutableMethodInfo)result.Item2;
// Interface added.
Assert.That(_mutableType.AddedInterfaces, Is.EqualTo(new[] { typeof(IInitializableObject) }));
// Field added.
Assert.That(_mutableType.AddedFields, Is.EqualTo(new[] { counter }));
Assert.That(counter.Name, Is.EqualTo("<tp>_ctorRunCounter"));
Assert.That(counter.FieldType, Is.SameAs(typeof(int)));
Assert.That(counter.AddedCustomAttributes.Single().Type, Is.SameAs(typeof(NonSerializedAttribute)));
// Initialization method added.
var methodAttributes = MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig;
Assert.That(_mutableType.AddedMethods, Is.EqualTo(new[] { initMethod }));
Assert.That(initMethod.DeclaringType, Is.SameAs(_mutableType));
Assert.That(initMethod.Name, Is.EqualTo("Remotion.TypePipe.Implementation.IInitializableObject.Initialize"));
Assert.That(initMethod.Attributes, Is.EqualTo(methodAttributes));
Assert.That(initMethod.ReturnType, Is.SameAs(typeof(void)));
var parameters = initMethod.GetParameters();
Assert.That(parameters, Has.Length.EqualTo(1));
Assert.That(parameters[0].ParameterType, Is.SameAs(typeof(InitializationSemantics)));
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IInitializableObject obj) => obj.Initialize(0));
Assert.That(initMethod.AddedExplicitBaseDefinitions, Is.EqualTo(new[] { interfaceMethod }));
var expectedBody = Expression.Block(typeof(void), Expression.Constant("blub"), initMethod.ParameterExpressions[0]);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, initMethod.Body);
}
public void NestedMemberBindingExpression()
{
var outerAnonymousTypeCtor = typeof(AnonymousType <int, AnonymousType>).GetConstructor(Type.EmptyTypes);
var outerAnonymousTypeAProperty = typeof(AnonymousType <int, AnonymousType>).GetProperty("a");
var outerAnonymousTypeBProperty = typeof(AnonymousType <int, AnonymousType>).GetProperty("b");
// new AnonymousType() { a = 2, b = new AnonymousType() { a = _searchedExpression, b = 1 } }
var innerExpression = Expression.MemberInit(
Expression.New(_anonymousTypeCtorWithoutArgs),
Expression.Bind(_anonymousTypeAProperty, _searchedExpression),
Expression.Bind(_anonymousTypeBProperty, Expression.Constant(1)));
var fullExpression = Expression.MemberInit(
Expression.New(outerAnonymousTypeCtor),
Expression.Bind(outerAnonymousTypeAProperty, Expression.Constant(2)),
Expression.Bind(outerAnonymousTypeBProperty, innerExpression));
var result = AccessorFindingExpressionTreeVisitor.FindAccessorLambda(_searchedExpression, fullExpression, _nestedInputParameter);
Expression <Func <AnonymousType <int, AnonymousType>, int> > expectedResult = input => input.b.a;
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GetExpressionsFromTuple_TwoExpressions()
{
var expression1 = Expression.Constant("expr1");
var expression2 = Expression.Constant("expr2");
var tupleCtor = typeof(KeyValuePair <string, string>).GetConstructor(new[] { typeof(string), typeof(string) });
var tupleExpression = Expression.New(
tupleCtor,
new[] { expression1, expression2 },
tupleCtor.DeclaringType.GetMethod("get_Key"),
tupleCtor.DeclaringType.GetMethod("get_Value"));
var result = TupleExpressionBuilder.GetExpressionsFromTuple(tupleExpression);
var enumerator = result.GetEnumerator();
enumerator.MoveNext();
ExpressionTreeComparer.CheckAreEqualTrees(
enumerator.Current, MemberExpression.MakeMemberAccess(tupleExpression, tupleCtor.DeclaringType.GetProperty("Key")));
enumerator.MoveNext();
ExpressionTreeComparer.CheckAreEqualTrees(
enumerator.Current, MemberExpression.MakeMemberAccess(tupleExpression, tupleCtor.DeclaringType.GetProperty("Value")));
}
public void CreateConstructor()
{
var attributes = MethodAttributes.Public;
var parameters =
new[]
{
ParameterDeclarationObjectMother.Create(typeof(string), "param1"),
ParameterDeclarationObjectMother.Create(typeof(int), "param2")
};
var fakeBody = ExpressionTreeObjectMother.GetSomeExpression(typeof(object));
Func <ConstructorBodyCreationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.This.Type, Is.SameAs(_mutableType));
Assert.That(ctx.IsStatic, Is.False);
Assert.That(ctx.Parameters.Select(p => p.Type), Is.EqualTo(new[] { typeof(string), typeof(int) }));
Assert.That(ctx.Parameters.Select(p => p.Name), Is.EqualTo(new[] { "param1", "param2" }));
return(fakeBody);
};
var ctor = _factory.CreateConstructor(_mutableType, attributes, parameters.AsOneTime(), bodyProvider);
Assert.That(ctor.DeclaringType, Is.SameAs(_mutableType));
Assert.That(ctor.Name, Is.EqualTo(".ctor"));
Assert.That(ctor.Attributes, Is.EqualTo(attributes | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName));
var expectedParameterInfos =
new[]
{
new { ParameterType = parameters[0].Type },
new { ParameterType = parameters[1].Type }
};
var actualParameterInfos = ctor.GetParameters().Select(pi => new { pi.ParameterType });
Assert.That(actualParameterInfos, Is.EqualTo(expectedParameterInfos));
var expectedBody = Expression.Block(typeof(void), fakeBody);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, ctor.Body);
}
public void NestedMemberBindingExpressionWithDerivedType()
{
var outerTypeCtor = typeof(Result <BaseValue>).GetConstructor(Type.EmptyTypes);
var outerTypeValueProperty = typeof(Result <BaseValue>).GetProperty("Value");
var innerTypeCtor = typeof(DerivedValue).GetConstructor(Type.EmptyTypes);
var innerTypeStringValueProperty = typeof(DerivedValue).GetProperty("StringValue");
var searchedExpression = Expression.Constant("a");
var nestedInputParameter = Expression.Parameter(typeof(Result <BaseValue>), "input");
// new Result<BaseValue>() { Value = new DerivedValue() { StringValue = _searchedExpression } }
var innerExpression = Expression.MemberInit(
Expression.New(innerTypeCtor),
Expression.Bind(innerTypeStringValueProperty, searchedExpression));
var fullExpression = Expression.MemberInit(
Expression.New(outerTypeCtor),
Expression.Bind(outerTypeValueProperty, innerExpression));
var result = AccessorFindingExpressionVisitor.FindAccessorLambda(searchedExpression, fullExpression, nestedInputParameter);
Expression <Func <Result <BaseValue>, string> > expectedResult = input => ((DerivedValue)input.Value).StringValue;
ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void Aggregate_NoSeed()
{
var expression = ExpressionHelper.MakeExpression(() => (from s in QuerySource
select s.Name).Aggregate((allNames, name) => allNames + " " + name));
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(AggregateResultOperator)));
var resultOperator = (AggregateResultOperator)queryModel.ResultOperators[0];
var expectedFunc = ExpressionHelper.ResolveLambdaParameter <string, Cook, string> (
1,
queryModel.MainFromClause,
(allNames, student) => allNames + " " + student.Name);
ExpressionTreeComparer.CheckAreEqualTrees(expectedFunc, resultOperator.Func);
}
public void MakeSerializable_SerializableWithDeserializationCallbackType_WithInitializations()
{
StubFilterWithNoSerializedFields();
var initMethod = CreateInitializationMethod(_serializableInterfaceWithDeserializationCallbackProxy);
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((SerializableWithDeserializationCallbackType obj) => obj.OnDeserialization(null));
_enabler.MakeSerializable(_serializableInterfaceWithDeserializationCallbackProxy, initMethod);
Assert.That(_serializableInterfaceWithDeserializationCallbackProxy.AddedMethods, Has.Count.EqualTo(1));
var method = _serializableInterfaceWithDeserializationCallbackProxy.AddedMethods.Single();
var expectedBody = Expression.Block(
typeof(void),
Expression.Call(
new ThisExpression(_serializableInterfaceWithDeserializationCallbackProxy),
new NonVirtualCallMethodInfoAdapter(baseMethod),
method.ParameterExpressions.Cast <Expression>()),
Expression.Call(
new ThisExpression(_serializableInterfaceWithDeserializationCallbackProxy),
initMethod,
Expression.Constant(InitializationSemantics.Deserialization)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
public void Transform_Tuple3_ValueCtor()
{
var expression = Expression.New(
typeof(Tuple <string, int, bool>).GetConstructor(new[] { typeof(string), typeof(int), typeof(bool) }),
Expression.Constant("test"),
Expression.Constant(0),
Expression.Constant(true));
var result = _transformer.Transform(expression);
if (Environment.Version.Major == 2)
{
var expectedExpression35 = Expression.New(
typeof(Tuple <string, int, bool>).GetConstructor(new[] { typeof(string), typeof(int), typeof(bool) }),
new Expression[] { Expression.Constant("test"), Expression.Constant(0), Expression.Constant(true) },
new MemberInfo[]
{
typeof(Tuple <string, int, bool>).GetMethod("get_Item1"),
typeof(Tuple <string, int, bool>).GetMethod("get_Item2"),
typeof(Tuple <string, int, bool>).GetMethod("get_Item3")
});
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression35, result);
}
else
{
var expectedExpression40 = Expression.New(
typeof(Tuple <string, int, bool>).GetConstructor(new[] { typeof(string), typeof(int), typeof(bool) }),
new Expression[] { Expression.Constant("test"), Expression.Constant(0), Expression.Constant(true) },
new MemberInfo[]
{
typeof(Tuple <string, int, bool>).GetProperty("Item1"),
typeof(Tuple <string, int, bool>).GetProperty("Item2"),
typeof(Tuple <string, int, bool>).GetProperty("Item3")
});
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression40, result);
}
}
protected void CheckResolvedExpression <TParameter1, TParameter2, TResult> (Expression expressionToCheck, IQuerySource clauseToReference1, IQuerySource clauseToReference2, Expression <Func <TParameter1, TParameter2, TResult> > expectedUnresolvedExpression)
{
var expectedPredicate = ExpressionHelper.Resolve(clauseToReference1, clauseToReference2, expectedUnresolvedExpression);
ExpressionTreeComparer.CheckAreEqualTrees(expectedPredicate, expressionToCheck);
}
public void GetOrCreateOverride_BaseMethod_ImplicitOverride_Generic()
{
var baseDefinition = typeof(DomainType).GetMethod("GenericMethod");
var inputMethod = baseDefinition;
var baseMethod = baseDefinition;
_relatedMethodFinderMock.Expect(mock => mock.GetOverride(baseDefinition, _mutableType.AddedMethods)).Return(null);
_relatedMethodFinderMock.Expect(mock => mock.GetMostDerivedOverride(baseDefinition, _mutableType.BaseType)).Return(baseMethod);
_relatedMethodFinderMock
.Expect(mock => mock.IsShadowed(Arg.Is(baseDefinition), Arg <IEnumerable <MethodInfo> > .List.Equivalent(_mutableType.GetAllMethods())))
.Return(false);
var fakeResult = CreateFakeGenericMethod();
_methodFactoryMock
.Expect(
mock =>
mock.CreateMethod(
Arg.Is(_mutableType),
Arg.Is("GenericMethod"),
Arg.Is(MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot | MethodAttributes.HideBySig),
Arg <IEnumerable <GenericParameterDeclaration> > .Is.Anything,
Arg <Func <GenericParameterContext, Type> > .Is.Anything,
Arg <Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > > .Is.Anything,
Arg <Func <MethodBodyCreationContext, Expression> > .Is.Anything))
.Return(fakeResult)
.WhenCalled(
mi =>
{
var fakeGenericParameter = typeof(TypeThatCompliesWithConstraints);
var genericParameterContext = new GenericParameterContext(new[] { fakeGenericParameter });
var genericParameters = (IEnumerable <GenericParameterDeclaration>)mi.Arguments[3];
var returnType = ((Func <GenericParameterContext, Type>)mi.Arguments[4])(genericParameterContext);
var parameters = ((Func <GenericParameterContext, IEnumerable <ParameterDeclaration> >)mi.Arguments[5])(genericParameterContext).ToList();
var genericParameter = genericParameters.Single();
Assert.That(genericParameter.Name, Is.EqualTo("TPar"));
Assert.That(genericParameter.Attributes, Is.EqualTo(GenericParameterAttributes.DefaultConstructorConstraint));
Assert.That(genericParameter.ConstraintProvider(genericParameterContext), Is.EqualTo(new[] { typeof(DomainType), typeof(IDisposable) }));
Assert.That(returnType, Is.SameAs(fakeGenericParameter));
ParameterDeclarationTest.CheckParameter(parameters[0], typeof(int), "arg1", ParameterAttributes.None);
ParameterDeclarationTest.CheckParameter(parameters[1], fakeGenericParameter, "arg2", ParameterAttributes.None);
var parameterExpressions = parameters.Select(p => p.Expression).ToList();
var bodyContext = new MethodBodyCreationContext(
_mutableType, false, parameterExpressions, new[] { fakeGenericParameter }, returnType, baseMethod);
var body = ((Func <MethodBodyCreationContext, Expression>)mi.Arguments[6])(bodyContext);
var expectedBody = Expression.Call(
bodyContext.This, baseMethod.MakeTypePipeGenericMethod(fakeGenericParameter), parameterExpressions.Cast <Expression>());
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, body);
});
var result = _factory.GetOrCreateOverride(_mutableType, inputMethod, out _isNewlyCreated);
_relatedMethodFinderMock.VerifyAllExpectations();
_methodFactoryMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
Assert.That(_isNewlyCreated, Is.True);
}
public void CreateMethod()
{
var name = "Method";
var attributes = MethodAttributes.Public;
var baseConstraint = ReflectionObjectMother.GetSomeClassType();
var interfaceConstraint = ReflectionObjectMother.GetSomeInterfaceType();
GenericParameterContext genericParameterContext = null;
Type firstGenericParameter = null;
Func <GenericParameterContext, IEnumerable <Type> > constraintProvider = ctx =>
{
genericParameterContext = ctx;
Assert.That(ctx.GenericParameters, Has.Count.EqualTo(2));
Assert.That(ctx.GenericParameters[1].GenericParameterPosition, Is.EqualTo(1));
firstGenericParameter = ctx.GenericParameters[0];
Assert.That(firstGenericParameter.DeclaringMethod, Is.Null);
Assert.That(firstGenericParameter.GenericParameterPosition, Is.EqualTo(0));
Assert.That(firstGenericParameter.Name, Is.EqualTo("T1"));
Assert.That(firstGenericParameter.Namespace, Is.EqualTo(_mutableType.Namespace));
Assert.That(firstGenericParameter.GenericParameterAttributes, Is.EqualTo(GenericParameterAttributes.Covariant));
return(new[] { baseConstraint, interfaceConstraint }.AsOneTime());
};
var genericParameters =
new[]
{
GenericParameterDeclarationObjectMother.Create("T1", GenericParameterAttributes.Covariant, constraintProvider),
GenericParameterDeclarationObjectMother.Create()
};
var returnType = typeof(IComparable);
Func <GenericParameterContext, Type> returnTypeProvider = ctx =>
{
Assert.That(ctx, Is.Not.Null.And.SameAs(genericParameterContext));
return(returnType);
};
var parameter = ParameterDeclarationObjectMother.Create(name: "paramName");
Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > parameterProvider = ctx =>
{
Assert.That(ctx, Is.Not.Null.And.SameAs(genericParameterContext));
return(new[] { parameter }.AsOneTime());
};
var fakeBody = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
Func <MethodBodyCreationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.This.Type, Is.SameAs(_mutableType));
Assert.That(ctx.Parameters.Single().Name, Is.EqualTo("paramName"));
Assert.That(ctx.IsStatic, Is.False);
Assert.That(ctx.GenericParameters, Is.EqualTo(genericParameterContext.GenericParameters));
Assert.That(ctx.ReturnType, Is.SameAs(returnType));
Assert.That(ctx.HasBaseMethod, Is.False);
return(fakeBody);
};
var method = _factory.CreateMethod(
_mutableType, name, attributes, genericParameters.AsOneTime(), returnTypeProvider, parameterProvider, bodyProvider);
Assert.That(method.DeclaringType, Is.SameAs(_mutableType));
Assert.That(method.Name, Is.EqualTo(name));
Assert.That(method.Attributes, Is.EqualTo(attributes));
Assert.That(method.ReturnType, Is.SameAs(returnType));
Assert.That(method.BaseMethod, Is.Null);
var returnParameter = method.ReturnParameter;
Assertion.IsNotNull(returnParameter);
Assert.That(returnParameter.Position, Is.EqualTo(-1));
Assert.That(returnParameter.Name, Is.Null);
Assert.That(returnParameter.ParameterType, Is.SameAs(returnType));
Assert.That(returnParameter.Attributes, Is.EqualTo(ParameterAttributes.None));
Assert.That(method.GetGenericArguments(), Has.Length.EqualTo(2));
var actualFirstGenericParameter = method.GetGenericArguments()[0];
Assert.That(actualFirstGenericParameter, Is.SameAs(firstGenericParameter));
Assert.That(actualFirstGenericParameter.DeclaringMethod, Is.SameAs(method));
Assert.That(actualFirstGenericParameter.GetGenericParameterConstraints(), Is.EqualTo(new[] { baseConstraint, interfaceConstraint }));
Assert.That(method.GetParameters().Single().Name, Is.EqualTo(parameter.Name));
var expectedBody = Expression.Convert(fakeBody, returnType);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
private void CheckConstructorCall(ConstructorInfo expectedConstructor, Expression[] arguments, MethodCallExpression actualCall)
{
var expected = Expression.Call(new ThisExpression(_declaringType), NonVirtualCallMethodInfoAdapter.Adapt(expectedConstructor), arguments);
ExpressionTreeComparer.CheckAreEqualTrees(expected, actualCall);
}
public void GetOrCreateOverride_BaseMethod_ImplicitOverride_Generic()
{
var baseDefinition = typeof(DomainType).GetMethod("GenericMethod");
var inputMethod = baseDefinition;
var baseMethod = baseDefinition;
_relatedMethodFinderMock
.Setup(mock => mock.GetOverride(baseDefinition, _mutableType.AddedMethods)).Returns((MutableMethodInfo)null).Verifiable();
_relatedMethodFinderMock
.Setup(mock => mock.GetMostDerivedOverride(baseDefinition, _mutableType.BaseType)).Returns(baseMethod).Verifiable();
_relatedMethodFinderMock
.Setup(
mock => mock.IsShadowed(
baseDefinition,
It.Is <IEnumerable <MethodInfo> > (shadowingCandidates => shadowingCandidates.IsEquivalent(_mutableType.GetAllMethods()))))
.Returns(false)
.Verifiable();
var fakeResult = CreateFakeGenericMethod();
_methodFactoryMock
.Setup(
mock =>
mock.CreateMethod(
_mutableType,
"GenericMethod",
MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot | MethodAttributes.HideBySig,
It.IsAny <IEnumerable <GenericParameterDeclaration> >(),
It.IsAny <Func <GenericParameterContext, Type> >(),
It.IsAny <Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > >(),
It.IsAny <Func <MethodBodyCreationContext, Expression> >()))
.Returns(fakeResult)
.Callback(
(
MutableType declaringType,
string name,
MethodAttributes attributes,
IEnumerable <GenericParameterDeclaration> genericParameters,
Func <GenericParameterContext, Type> returnTypeProvider,
Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > parameterProvider,
Func <MethodBodyCreationContext, Expression> bodyProvider) =>
{
var fakeGenericParameter = typeof(TypeThatCompliesWithConstraints);
var genericParameterContext = new GenericParameterContext(new[] { fakeGenericParameter });
var returnType = returnTypeProvider(genericParameterContext);
var parameters = parameterProvider(genericParameterContext).ToList();
var genericParameter = genericParameters.Single();
Assert.That(genericParameter.Name, Is.EqualTo("TPar"));
Assert.That(genericParameter.Attributes, Is.EqualTo(GenericParameterAttributes.DefaultConstructorConstraint));
Assert.That(
genericParameter.ConstraintProvider(genericParameterContext),
Is.EqualTo(new[] { typeof(DomainType), typeof(IDisposable) }));
Assert.That(returnType, Is.SameAs(fakeGenericParameter));
ParameterDeclarationTest.CheckParameter(parameters[0], typeof(int), "arg1", ParameterAttributes.None);
ParameterDeclarationTest.CheckParameter(parameters[1], fakeGenericParameter, "arg2", ParameterAttributes.None);
var parameterExpressions = parameters.Select(p => p.Expression).ToList();
var bodyContext = new MethodBodyCreationContext(
_mutableType,
false,
parameterExpressions,
new[] { fakeGenericParameter },
returnType,
baseMethod);
var body = bodyProvider(bodyContext);
var expectedBody = Expression.Call(
bodyContext.This,
baseMethod.MakeTypePipeGenericMethod(fakeGenericParameter),
parameterExpressions);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, body);
})
.Verifiable();
var result = _factory.GetOrCreateOverride(_mutableType, inputMethod, out _isNewlyCreated);
_relatedMethodFinderMock.Verify();
_methodFactoryMock.Verify();
Assert.That(result, Is.SameAs(fakeResult));
Assert.That(_isNewlyCreated, Is.True);
}
