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 VisitAccept_StandardExpressionVisitor() { var expressionVisitorMock = MockRepository.GenerateStrictMock <ExpressionVisitor>(); var expectedResult = ExpressionTreeObjectMother.GetSomeExpression(); expressionVisitorMock.Expect(mock => mock.Invoke("VisitExtension", _expressionPartialMock)).Return(expectedResult); var result = _expressionPartialMock.Invoke("Accept", expressionVisitorMock); expressionVisitorMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(expectedResult)); }
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)); }