public void GetProperty_ImplicitInterfaceReadOnlyScalar_WithReadWriteImplementation() { var instance = ObjectFactory.Create <ClassWithReferenceType <SimpleReferenceType> > (ParamList.Empty); var value = new SimpleReferenceType(); instance.ImplicitInterfaceReadOnlyScalar = value; Assert.That(((IBusinessObject)instance).GetProperty("ImplicitInterfaceReadOnlyScalar"), Is.SameAs(value)); }
public void SetProperty_ExplicitInterfaceScalar() { var instance = ObjectFactory.Create <ClassWithReferenceType <SimpleReferenceType> > (ParamList.Empty); var value = new SimpleReferenceType(); ((IBusinessObject)instance).SetProperty("ExplicitInterfaceScalar", value); Assert.That(((IInterfaceWithReferenceType <SimpleReferenceType>)instance).ExplicitInterfaceScalar, Is.SameAs(value)); }
public void SetValue_ExplicitInterface_Integration() { IInterfaceWithReferenceType <SimpleReferenceType> instance = new ClassWithReferenceType <SimpleReferenceType>(); SimpleReferenceType value = new SimpleReferenceType(); _explicitInterfaceAdapter.SetValue(instance, value, null); Assert.That(instance.ExplicitInterfaceScalar, Is.SameAs(value)); }
public void InstanceMethodWithMultipleParameters( SimpleReferenceType referenceTypeValue, int valueTypeValue, int?nullableValueTypeValue, SimpleReferenceType staticReferenceTypeValue) { InstanceReferenceTypeValue = referenceTypeValue; InstanceValueTypeValue = valueTypeValue; InstanceNullableValueTypeValue = nullableValueTypeValue; StaticReferenceTypeValue = staticReferenceTypeValue; }
private void AssertCanNotSet(PropertyInfoAdapter adapter, object instance, SimpleReferenceType value) { try { adapter.SetValue(instance, value, null); } catch (ArgumentException ex) { Assert.That(ex.Message, Is.EqualTo("Property set method not found.")); } }
public void SetValue_WithIndexerProperty_WithOneParameter_IndexParameterArrayLengthMismatch() { var scalar = new SimpleReferenceType(); var instanceStub = MockRepository.GenerateStub <IInterfaceWithReferenceType <SimpleReferenceType> >(); var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) }); _implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty); _implicitInterfaceAdapter.SetValue(instanceStub, scalar, new object[0]); }
public void SetValue_ImplementationAddsSetAccessor() { var instance = new ClassWithReferenceType <SimpleReferenceType>(); var value = new SimpleReferenceType(); _declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(null); _implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return( MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("ImplicitInterfaceScalar").GetSetMethod(true))); _interfaceImplementationPropertyInformation.SetValue(instance, value, null); Assert.That(instance.ImplicitInterfaceScalar, Is.SameAs(value)); }
public void SetValue_WithIndexerProperty_WithTwoParameters_IndexParameterArrayNull() { var scalar = new SimpleReferenceType(); var instanceStub = MockRepository.GenerateStub <IInterfaceWithReferenceType <SimpleReferenceType> >(); var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>) .GetProperty("Item", new[] { typeof(int), typeof(DateTime) }); _implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty); _implicitInterfaceAdapter.SetValue(instanceStub, scalar, null); }
public void SetValue_ImplementationAddsSetAccessor_IndexedProperty() { var instance = new ClassWithReferenceType <SimpleReferenceType>(); var value = new SimpleReferenceType(); _declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(null); _implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return( MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) }).GetSetMethod(true))); _interfaceImplementationPropertyInformation.SetValue(instance, value, new object[] { 0 }); Assert.That(instance[0], Is.SameAs(value)); }
public void GetValue() { var instance = new ClassWithReferenceType <SimpleReferenceType>(); var value = new SimpleReferenceType(); instance.ImplicitInterfaceScalar = value; _declarationPropertyInformationStub.Stub(stub => stub.GetGetMethod(true)).Return(null); _implementationPropertyInformationStub.Stub(stub => stub.GetGetMethod(true)).Return( MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("ImplicitInterfaceScalar").GetGetMethod(true))); Assert.That(_mixinIntroducedPropertyInformation.GetValue(instance, null), Is.SameAs(value)); }
public void ConvertToNativePropertyType_Scalar() { PropertyBase property = new StubPropertyBase( CreateParameters( propertyInfo: GetPropertyInfo(typeof(ClassWithReferenceType <SimpleReferenceType>), "Scalar"), underlyingType: typeof(SimpleReferenceType), concreteType: typeof(SimpleReferenceType), listInfo: null, isRequired: false, isReadOnly: false)); var expected = new SimpleReferenceType(); Assert.That(property.ConvertToNativePropertyType(expected), Is.SameAs(expected)); }
public void SetValue_WithIndexerProperty_WithOneParameter() { var scalar = new SimpleReferenceType(); var instanceMock = MockRepository.GenerateMock <IInterfaceWithReferenceType <SimpleReferenceType> >(); instanceMock.Expect(mock => mock[10] = scalar); instanceMock.Replay(); var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) }); _implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty); _implicitInterfaceAdapter.SetValue(instanceMock, scalar, new object[] { 10 }); instanceMock.VerifyAllExpectations(); }
public void SetValue_WithIndexerProperty_WithThreeParameters() { SimpleReferenceType scalar = new SimpleReferenceType(); IInterfaceWithReferenceType <SimpleReferenceType> instanceMock = MockRepository.GenerateMock <IInterfaceWithReferenceType <SimpleReferenceType> >(); instanceMock.Expect(mock => mock[10, new DateTime(2000, 1, 1), "foo"] = scalar); instanceMock.Replay(); var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>) .GetProperty("Item", new[] { typeof(int), typeof(DateTime), typeof(string) }); _implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty); _implicitInterfaceAdapter.SetValue(instanceMock, scalar, new object[] { 10, new DateTime(2000, 1, 1), "foo" }); instanceMock.VerifyAllExpectations(); }
public void EmitMethodBody_ForClosedGeneric() { Type declaringType = typeof(ClassWithMethods); var methodInfo = declaringType.GetMethod("GenericInstanceMethod", BindingFlags.Public | BindingFlags.Instance) .MakeGenericMethod(typeof(SimpleReferenceType)); Type returnType = typeof(object); Type[] parameterTypes = new[] { typeof(object), typeof(object) }; var method = GetWrapperMethodFromEmitter(MethodInfo.GetCurrentMethod(), parameterTypes, returnType, methodInfo); var obj = new ClassWithMethods(); var value = new SimpleReferenceType(); Assert.That(BuildTypeAndInvokeMethod(method, obj, value), Is.SameAs(value)); }
public void EmitMethodBody_ForStaticMethodWithReferenceTypeParameter() { Type declaringType = typeof(ClassWithMethods); var methodInfo = declaringType.GetMethod("StaticMethodWithReferenceTypeParameter", BindingFlags.Public | BindingFlags.Static); Type returnType = typeof(void); Type[] parameterTypes = new[] { typeof(object), typeof(object) }; var method = GetWrapperMethodFromEmitter(MethodInfo.GetCurrentMethod(), parameterTypes, returnType, methodInfo); var value = new SimpleReferenceType(); BuildTypeAndInvokeMethod(method, new object[] { null, value }); Assert.That(ClassWithMethods.StaticReferenceTypeValue, Is.SameAs(value)); }
public void EmitMethodBody_ForInstanceMethodWithReferenceTypeParameter_ParameterTypesMatch() { Type declaringType = typeof(ClassWithMethods); var methodInfo = declaringType.GetMethod("InstanceMethodWithReferenceTypeParameter", BindingFlags.Public | BindingFlags.Instance); Type returnType = typeof(void); Type[] parameterTypes = new[] { typeof(object), typeof(SimpleReferenceType) }; var method = GetWrapperMethodFromEmitter(MethodInfo.GetCurrentMethod(), parameterTypes, returnType, methodInfo); var value = new SimpleReferenceType(); var obj = new ClassWithMethods(); BuildTypeAndInvokeMethod(method, obj, value); Assert.That(obj.InstanceReferenceTypeValue, Is.SameAs(value)); }
public void GetValue_WithIndexerProperty_ThreeParameters() { var scalar = new SimpleReferenceType(); var instanceMock = MockRepository.GenerateMock <IInterfaceWithReferenceType <SimpleReferenceType> >(); instanceMock.Expect(mock => mock[10, new DateTime(2000, 1, 1), "foo"]).Return(scalar); instanceMock.Replay(); var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>) .GetProperty("Item", new[] { typeof(int), typeof(DateTime), typeof(string) }); _implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty); object actualScalar = _implicitInterfaceAdapter.GetValue(instanceMock, new object[] { 10, new DateTime(2000, 1, 1), "foo" }); Assert.That(actualScalar, Is.SameAs(scalar)); instanceMock.VerifyAllExpectations(); }
public void SetValue_PrivateAccessor() { IPropertyInformation propertyInfo = GetPropertyInfo(typeof(ClassWithReferenceType <SimpleReferenceType>), "PrivateProperty"); PropertyBase propertyBase = new StubPropertyBase( CreateParameters( propertyInfo: propertyInfo, underlyingType: propertyInfo.PropertyType, concreteType: propertyInfo.PropertyType, listInfo: null, isRequired: true, isReadOnly: true)); var instance = ObjectFactory.Create <ClassWithReferenceType <SimpleReferenceType> > (ParamList.Empty); var value = new SimpleReferenceType(); propertyBase.SetValue((IBusinessObject)instance, value); Assert.That(PrivateInvoke.GetNonPublicProperty(instance, "PrivateProperty"), Is.SameAs(value)); }
public void GetValue() { IPropertyInformation propertyInfo = GetPropertyInfo(typeof(ClassWithReferenceType <SimpleReferenceType>), "Scalar"); PropertyBase propertyBase = new StubPropertyBase( CreateParameters( propertyInfo: propertyInfo, underlyingType: propertyInfo.PropertyType, concreteType: propertyInfo.PropertyType, listInfo: null, isRequired: true, isReadOnly: true)); var instance = ObjectFactory.Create <ClassWithReferenceType <SimpleReferenceType> > (ParamList.Empty); var value = new SimpleReferenceType(); instance.Scalar = value; Assert.That(propertyBase.GetValue(((IBusinessObject)instance)), Is.SameAs(value)); }
public void EmitMethodBody_ForInstanceMethodWithMultipleParameters() { Type declaringType = typeof(ClassWithMethods); var methodInfo = declaringType.GetMethod("InstanceMethodWithMultipleParameters", BindingFlags.Public | BindingFlags.Instance); Type returnType = typeof(void); Type[] parameterTypes = new[] { typeof(object), typeof(object), typeof(object), typeof(object), typeof(object) }; var method = GetWrapperMethodFromEmitter(MethodInfo.GetCurrentMethod(), parameterTypes, returnType, methodInfo); var instanceReferenceTypeValue = new SimpleReferenceType(); int instanceValueTypeValue = 100; int?instanceNullableValueTypeValue = 200; var staticReferenceTypeValue = new SimpleReferenceType(); var obj = new ClassWithMethods(); BuildTypeAndInvokeMethod( method, obj, instanceReferenceTypeValue, instanceValueTypeValue, instanceNullableValueTypeValue, staticReferenceTypeValue); Assert.That(obj.InstanceReferenceTypeValue, Is.SameAs(instanceReferenceTypeValue)); Assert.That(obj.InstanceValueTypeValue, Is.EqualTo(instanceValueTypeValue)); Assert.That(obj.InstanceNullableValueTypeValue, Is.EqualTo(instanceNullableValueTypeValue)); Assert.That(ClassWithMethods.StaticReferenceTypeValue, Is.SameAs(staticReferenceTypeValue)); }
public void EmitMethodBody_ForPrivatePropertyGetter_ForReferenceType() { Type declaringType = typeof(ClassWithReferenceTypeProperties); var propertyInfo = declaringType.GetProperty("PropertyWithPrivateGetterAndSetter", BindingFlags.NonPublic | BindingFlags.Instance); var methodInfo = propertyInfo.GetGetMethod(true); Type returnType = typeof(object); Type[] parameterTypes = new[] { typeof(object) }; var dynamicMethod = new DynamicMethod("", returnType, parameterTypes, declaringType, false); var ilGenerator = dynamicMethod.GetILGenerator(); var emitter = new MethodWrapperEmitter(ilGenerator, methodInfo, parameterTypes, returnType); emitter.EmitStaticMethodBody(); var propertyGetter = (Func <object, object>)dynamicMethod.CreateDelegate(typeof(Func <object, object>)); var expectedValue = new SimpleReferenceType(); var obj = new ClassWithReferenceTypeProperties(); obj.SetPropertyWithPrivateGetterAndSetter(expectedValue); Assert.That(propertyGetter(obj), Is.SameAs(expectedValue)); }
public void InstanceMethodWithOptionalParameter([Optional] SimpleReferenceType value) { }
public void InstanceMethodWithByRefParameter(ref SimpleReferenceType value) { value = InstanceReferenceTypeValue; }
public void InstanceMethodWithOutParameter(out SimpleReferenceType value) { value = InstanceReferenceTypeValue; }
public void SetPropertyWithPrivateGetterAndSetter(SimpleReferenceType value) { PropertyWithPrivateGetterAndSetter = value; }
public void InstanceMethodWithReferenceTypeParameter(SimpleReferenceType value) { InstanceReferenceTypeValue = value; }
public static void StaticMethodWithReferenceTypeParameter(SimpleReferenceType value) { StaticReferenceTypeValue = value; }
private void AssertCanSet(PropertyInfoAdapter adapter, object instance, SimpleReferenceType value) { adapter.SetValue(instance, value, null); Assert.That(adapter.GetValue(instance, null), Is.SameAs(value)); }