public void EnsureCorrectType_SafeValueConversion()
{
var expression = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
var expectedType = typeof(long);
ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
}
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 ReplaceParameters_WrongArgumentType()
{
var arg1 = ExpressionTreeObjectMother.GetSomeExpression(typeof(string));
var arg2 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[1].Type);
CallReplaceParameters(arg1, arg2);
}
public void SetUp()
{
_operand = ExpressionTreeObjectMother.GetSomeExpression();
_type = ReflectionObjectMother.GetSomeType();
_expression = new BoxAndCastExpression(_operand, _type);
}
public void EnsureCorrectType_UnsafeCastRequired()
{
var expression = ExpressionTreeObjectMother.GetSomeExpression(typeof(object));
var expectedType = typeof(string);
ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
}
public void CreateProperty_Providers_WriteOnly()
{
var type = ReflectionObjectMother.GetSomeType();
Func <MethodBodyCreationContext, Expression> setBodyProvider = ctx => ExpressionTreeObjectMother.GetSomeExpression(typeof(void));
var fakeSetMethod = MutableMethodInfoObjectMother.Create(parameters: new[] { ParameterDeclarationObjectMother.Create(type) });
_methodFactoryMock
.Setup(
stub => stub.CreateMethod(
It.IsAny <MutableType>(),
"set_Property",
It.IsAny <MethodAttributes>(),
It.IsAny <IEnumerable <GenericParameterDeclaration> >(),
It.IsAny <Func <GenericParameterContext, Type> >(),
It.IsAny <Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > >(),
It.IsAny <Func <MethodBodyCreationContext, Expression> >()))
.Returns(fakeSetMethod);
var result = _factory.CreateProperty(
_mutableType,
"Property",
type,
ParameterDeclaration.None,
0,
getBodyProvider: null,
setBodyProvider: setBodyProvider);
Assert.That(result.MutableGetMethod, Is.Null);
}
public void Initialization()
{
var declaringType = MutableTypeObjectMother.Create();
var attributes = (MethodAttributes)7 | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
var parameters = ParameterDeclarationObjectMother.CreateMultiple(2);
var body = ExpressionTreeObjectMother.GetSomeExpression(typeof(void));
var ctor = new MutableConstructorInfo(declaringType, attributes, parameters.AsOneTime(), body);
Assert.That(ctor.DeclaringType, Is.SameAs(declaringType));
Assert.That(ctor.MutableDeclaringType, Is.SameAs(declaringType));
Assert.That(ctor.Name, Is.EqualTo(".ctor"));
var actualParameters = ctor.GetParameters();
Assert.That(actualParameters, Has.Length.EqualTo(2));
CustomParameterInfoTest.CheckParameter(actualParameters[0], ctor, 0, parameters[0].Name, parameters[0].Type, parameters[0].Attributes);
CustomParameterInfoTest.CheckParameter(actualParameters[1], ctor, 1, parameters[1].Name, parameters[1].Type, parameters[1].Attributes);
Assert.That(ctor.MutableParameters, Is.EqualTo(actualParameters));
var paramExpressions = ctor.ParameterExpressions;
Assert.That(paramExpressions, Has.Count.EqualTo(2));
Assert.That(paramExpressions[0], Has.Property("Name").EqualTo(parameters[0].Name).And.Property("Type").SameAs(parameters[0].Type));
Assert.That(paramExpressions[1], Has.Property("Name").EqualTo(parameters[1].Name).And.Property("Type").SameAs(parameters[1].Type));
Assert.That(ctor.Body, Is.SameAs(body));
}
public void SetUp()
{
_operand = ExpressionTreeObjectMother.GetSomeExpression();
_type = ReflectionObjectMother.GetSomeType();
_expressionPartialMock = MockRepository.GeneratePartialMock <UnaryExpressionBase> (_operand, _type);
}
public void Initialization_StaticMethodRequiresNullTarget()
{
var method = ReflectionObjectMother.GetSomeStaticMethod();
var target = ExpressionTreeObjectMother.GetSomeExpression(method.DeclaringType);
new NewDelegateExpression(typeof(Action), target, method);
}
public void EnsureCorrectType_CompletelyUnrelated()
{
var expression = ExpressionTreeObjectMother.GetSomeExpression(typeof(string));
var expectedType = typeof(List <int>);
ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
}
public void Initialization_MethodSignatureMustMatchDelegateType()
{
var delegateType = typeof(Action <string>);
var target = ExpressionTreeObjectMother.GetSomeExpression(typeof(DomainType));
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
new NewDelegateExpression(delegateType, target, method);
}
public void SetUp()
{
_nonVirtualInstanceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => Method(7, null));
_delegateType = typeof(Func <int, object, string>);
_target = ExpressionTreeObjectMother.GetSomeExpression(_nonVirtualInstanceMethod.DeclaringType);
_expression = new NewDelegateExpression(_delegateType, _target, _nonVirtualInstanceMethod);
}
public void EnsureCorrectType_BoxingConvertibleToInterface()
{
var expression = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
var expectedType = typeof(IComparable);
var result = ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
CheckExpressionIsConverted(expression, expectedType, result);
}
public void EnsureCorrectType_ReferenceAssignable()
{
var expression = ExpressionTreeObjectMother.GetSomeExpression(typeof(string));
var expectedType = typeof(object);
var result = ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
Assert.That(result, Is.SameAs(expression));
}
public void EnsureCorrectType_Exact_ValueTypes()
{
var expectedType = typeof(int);
var expression = ExpressionTreeObjectMother.GetSomeExpression(expectedType);
var result = ExpressionTypeUtility.EnsureCorrectType(expression, expectedType);
Assert.That(result, Is.SameAs(expression));
}
public void SetUp()
{
_operand = ExpressionTreeObjectMother.GetSomeExpression();
_type = ReflectionObjectMother.GetSomeType();
_expressionPartialMock = new Mock <UnaryExpressionBase> (_operand, _type)
{
CallBase = true
};
}
public void BlockOrEmpty_NonEmpty()
{
var expressions = new[] { ExpressionTreeObjectMother.GetSomeExpression() };
var result = Expression.BlockOrEmpty(expressions.AsOneTime());
var block = (BlockExpression)result;
Assert.That(block.Expressions, Is.EqualTo(expressions));
}
public void GetFlattenedExpressionForSerialization_ProviderReturnsNonFlatValue()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { "abc" });
var nonFlatValueExpression = ExpressionTreeObjectMother.GetSomeExpression();
_identifierProviderMock.Stub(_ => _.GetFlatValueExpressionForSerialization("abc")).Return(nonFlatValueExpression);
_provider.GetAssembledTypeIDDataExpression(typeID);
}
public void CreateSimiliar()
{
var newOperand = ExpressionTreeObjectMother.GetSomeExpression();
var result = _expression.Invoke <UnaryExpressionBase> ("CreateSimiliar", newOperand);
Assert.That(result, Is.TypeOf <BoxAndCastExpression>());
Assert.That(result.Type, Is.SameAs(_expression.Type));
Assert.That(result.Operand, Is.SameAs((newOperand)));
}
public void InvokePreviousBodyWithArguments_Params()
{
var arg1 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[0].Type);
var arg2 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[1].Type);
var invokedBody = _context.InvokePreviousBodyWithArguments(arg1, arg2);
var expectedBody = Expression.Block(arg1, arg2);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, invokedBody);
}
public void Update_WithChanges()
{
var newOperand = ExpressionTreeObjectMother.GetSomeExpression();
var fakeResult = MockRepository.GenerateStrictMock <UnaryExpressionBase>(_operand, _type);
_expressionPartialMock.Expect(mock => mock.Invoke("CreateSimiliar", newOperand)).Return(fakeResult);
var result = _expressionPartialMock.Update(newOperand);
Assert.That(result, Is.SameAs(fakeResult));
}
public void Initialization_StaticMethodRequiresNullTarget()
{
var method = ReflectionObjectMother.GetSomeStaticMethod();
var target = ExpressionTreeObjectMother.GetSomeExpression(method.DeclaringType);
Assert.That(
() => new NewDelegateExpression(typeof(Action), target, method),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo(
"Static method must not have target.", "target"));
}
public void GetTypedBody_BoxingConversion()
{
var body = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
var bodyProvider = CreateBodyProvider(body);
var result = BodyProviderUtility.GetTypedBody(typeof(object), bodyProvider, _context);
var expectedBody = Expression.Convert(body, typeof(object));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, result);
}
public void ReplaceParameters()
{
var arg1 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[0].Type);
var arg2 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[1].Type);
var invokedBody = CallReplaceParameters(arg1, arg2);
var expectedBody = Expression.Block(arg1, arg2);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, invokedBody);
}
public void SetBody_Static()
{
var method = MutableMethodInfoObjectMother.Create(attributes: MethodAttributes.Static);
Func <MethodBodyModificationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.IsStatic, Is.True);
return(ExpressionTreeObjectMother.GetSomeExpression(method.ReturnType));
};
method.SetBody(bodyProvider);
}
public void ReplaceParameters_ConvertibleArgumentType()
{
var arg1 = ExpressionTreeObjectMother.GetSomeExpression(_parameters[0].Type);
var arg2 = ExpressionTreeObjectMother.GetSomeExpression(typeof(int)); // convert from int to object
var invokedBody = CallReplaceParameters(arg1, arg2);
var expectedBody = Expression.Block(arg1, Expression.Convert(arg2, typeof(object)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, invokedBody);
}
public void VisitThis()
{
var expression = ExpressionTreeObjectMother.GetSomeThisExpression();
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Ldarg_0)).Verifiable();
var result = _emitter.VisitThis(expression);
_ilGeneratorMock.Verify();
Assert.That(result, Is.SameAs(expression));
}
public void SetUp()
{
_enabler = new ComplexSerializationEnabler();
_participantConfigurationID = "configID";
_assembledTypeIdentifierProviderStub = new Mock <IAssembledTypeIdentifierProvider>();
_typeID = AssembledTypeIDObjectMother.Create();
_assembledTypeIDData = ExpressionTreeObjectMother.GetSomeExpression();
_assembledTypeIdentifierProviderStub
.Setup(_ => _.GetAssembledTypeIDDataExpression(It.Is <AssembledTypeID> (id => id.Equals(_typeID))))
.Returns(_assembledTypeIDData);
}
public void Accept_CodeGenerationExpressionVisitor()
{
var expressionVisitorMock = MockRepository.GenerateStrictMock <IPrimitiveTypePipeExpressionVisitor, ICodeGenerationExpressionVisitor>();
var fakeExpression = ExpressionTreeObjectMother.GetSomeExpression();
_expressionPartialMock.Expect(mock => mock.Accept(expressionVisitorMock)).Return(fakeExpression);
var result = _expressionPartialMock.Accept(expressionVisitorMock);
_expressionPartialMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeExpression));
}
public void VisitAccept_PrimitiveTypePipeExpressionVisitor()
{
var expressionVisitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor, IPrimitiveTypePipeExpressionVisitor>();
var expectedResult = ExpressionTreeObjectMother.GetSomeExpression();
_expressionPartialMock.Expect(mock => mock.Accept((IPrimitiveTypePipeExpressionVisitor)expressionVisitorMock)).Return(expectedResult);
var result = _expressionPartialMock.Invoke("Accept", expressionVisitorMock);
_expressionPartialMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(expectedResult));
}
