public void Test_MethodOfDerivedClass() { var methodInformation = _resolver.GetMethodInformation(typeof(DerivedSecurableObject), "Show", MemberAffiliation.Instance); var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Show")); Assert.That(methodInformation, Is.Not.Null); Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation)); }
public void Test_OverriddenMethodFromBaseMethod() { var methodInformation = _resolver.GetMethodInformation(typeof(DerivedSecurableObject), "Record", MemberAffiliation.Instance); var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Record")); Assert.That(methodInformation, Is.Not.Null); Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation)); }
public void Test_OverloadedMethodWithOneAttribute() { var methodInformation = _resolver.GetMethodInformation(typeof(SecurableObject), "Delete", MemberAffiliation.Instance); var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Delete", new [] { typeof(int) })); Assert.That(methodInformation, Is.Not.Null); Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation)); }
public void GetSetMethod_PublicProperty() { var setMethod = _adapter.GetSetMethod(false); var expectedMethod = MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("set_NotVisibleAttributeScalar")); Assert.That(setMethod, Is.Not.Null); Assert.That(setMethod, Is.EqualTo(expectedMethod)); }
public void FindInterfaceDeclaration_NoImplementation() { var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("TestMethod"); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindInterfaceDeclarations(); Assert.That(result, Is.Empty); }
public void FindDeclaringProperty_PropertyFound() { var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindDeclaringProperty(); CheckProperty(TypeAdapter.Create(typeof(ClassWithReferenceType <object>)), "ImplicitInterfaceScalar", result); }
public void Equals() { Assert.That(_adapter.Equals(null), Is.False); Assert.That(_adapter.Equals("test"), Is.False); Assert.That(_adapter.Equals(MethodInfoAdapter.Create(typeof(ClassWithOverridingMember).GetMethod("BaseMethod"))), Is.False); Assert.That(_adapter.Equals(MethodInfoAdapter.Create(_method)), Is.True); Assert.That(_adapter.Equals(MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("TestMethod"))), Is.True); }
public void FilterMultipleAccessTypes() { IMethodInformation methodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Close")); var requiredAccessTypes = _permissionReflector.GetRequiredMethodPermissions(typeof(SecurableObject), methodInformation); Assert.That(requiredAccessTypes.Count, Is.EqualTo(2)); Assert.That(requiredAccessTypes, Has.Member(GeneralAccessTypes.Edit)); Assert.That(requiredAccessTypes, Has.Member(GeneralAccessTypes.Find)); }
public void GetHashcode() { Assert.That( _adapter.GetHashCode(), Is.EqualTo(MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("TestMethod")).GetHashCode())); Assert.That( MethodInfoAdapter.Create(typeof(int[]).GetMethod("ToString")).GetHashCode(), Is.EqualTo(MethodInfoAdapter.Create(typeof(int[]).GetMethod("ToString")).GetHashCode())); }
public void FindInterfaceImplementation_ImplementationIsNotAssignableToTheInterface() { var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindInterfaceImplementation(typeof(object)); Assert.That(result, Is.Null); }
public void CanBeSetFromOutside_IsBasedOnGetSetMethod_TrueForInterfaceImplementationPropertySetter() { var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString")); _implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(methodInfoAdapter); _declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(false)).Return(methodInfoAdapter); Assert.That(_mixinIntroducedPropertyInformation.CanBeSetFromOutside, Is.True); }
public void FindDeclaringProperty_NoPropertyCanBeFound() { var methodInfo = typeof(ClassWithBaseMember).GetMethod("BaseMethod"); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindDeclaringProperty(); Assert.That(result, Is.Null); }
public void Invoke() { var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString")); _declarationMethodInformationStub.Stub(stub => stub.Invoke("Test", new object[] { })).Return(methodInfoAdapter); var result = _mixinIntroducedMethodInformation.Invoke("Test", new object[] { }); Assert.That(result, Is.SameAs(methodInfoAdapter)); }
public void GetOriginalDeclaration_NoBaseDefinition() { var method = typeof(object).GetMethod("GetType"); var adapter = MethodInfoAdapter.Create(method); var result = adapter.GetOriginalDeclaration(); Assert.That(result, Is.TypeOf(typeof(MethodInfoAdapter))); CheckMethodInfo(method, (MethodInfoAdapter)result); }
public void GetSetMethod_PrivateProperty_NonPublicTrue() { var setMethod = _explicitInterfaceAdapter.GetSetMethod(true); var expectedMethod = MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod( "Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.set_ExplicitInterfaceScalar", BindingFlags.Instance | BindingFlags.NonPublic)); Assert.That(setMethod, Is.Not.Null); Assert.That(setMethod, Is.EqualTo(expectedMethod)); }
public void FindInterfaceDeclaration_ImplicitImplementation() { var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindInterfaceDeclarations(); var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar") }; CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ()); }
public void FindInterfaceImplementation_ImplicitImplementation() { var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var implementation = adapter.FindInterfaceImplementation(typeof(ClassWithReferenceType <object>)); var expectedPropertyGetter = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar"); CheckMethodInfo(expectedPropertyGetter, (MethodInfoAdapter)implementation); }
public override void SetUp() { base.SetUp(); _testHelper = new TestHelper(); _extension = new SecurityClientTransactionExtension(); _propertyInfo = typeof(SecurableObject).GetProperty("Parent"); _getMethodInformation = MethodInfoAdapter.Create(_propertyInfo.GetGetMethod()); _testHelper.SetupSecurityIoCConfiguration(); }
public void FindInterfaceDeclaration() { IMethodInformation methodInformation = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString")); _declarationMethodInformationStub .Stub(stub => stub.FindInterfaceDeclarations()) .Return(EnumerableUtility.Singleton(methodInformation).AsOneTime()); Assert.That(_mixinIntroducedMethodInformation.FindInterfaceDeclarations(), Is.EqualTo(new[] { _declarationMethodInformationStub })); Assert.That(_mixinIntroducedMethodInformation.FindInterfaceDeclarations(), Is.EqualTo(new[] { _declarationMethodInformationStub })); }
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_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 GetSetMethod() { var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString")); _implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(methodInfoAdapter); _declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(false)).Return(methodInfoAdapter); var result = _mixinIntroducedPropertyInformation.GetSetMethod(false); Assert.That(result, Is.TypeOf(typeof(MixinIntroducedMethodInformation))); Assert.That(result.Name, Is.EqualTo("ToString")); }
public void GetFastInvoker_PublicMethod() { var methodInfo = typeof(ClassWithReferenceType <string>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var instance = new ClassWithReferenceType <string>(); instance.ImplicitInterfaceScalar = "Test"; var result = adapter.GetFastInvoker <Func <ClassWithReferenceType <string>, string> >(); Assert.That(result(instance), Is.EqualTo("Test")); }
public void GetFastInvoker_PrivateMethod() { var methodInfo = typeof(ClassWithReferenceType <string>).GetMethod("get_PrivateProperty", BindingFlags.Instance | BindingFlags.NonPublic); var adapter = MethodInfoAdapter.Create(methodInfo); var instance = new ClassWithReferenceType <string>(); PrivateInvoke.SetNonPublicProperty(instance, "PrivateProperty", "Test"); var result = adapter.GetFastInvoker <Func <ClassWithReferenceType <string>, string> >(); Assert.That(result(instance), Is.EqualTo("Test")); }
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 override void SetUp() { base.SetUp(); _testHelper = new TestHelper(); _extension = new SecurityClientTransactionExtension(); _propertyInfo = typeof(SecurableObject).GetProperty("StringProperty"); _setMethodInformation = MethodInfoAdapter.Create(_propertyInfo.GetSetMethod()); _stringPropertyDefinition = PropertyDefinitionObjectMother.CreatePropertyDefinition(_propertyInfo); _testHelper.SetupSecurityIoCConfiguration(); }
public void FindInterfaceImplementation_ExplicitImplementation() { var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ExplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(methodInfo); var implementation = adapter.FindInterfaceImplementation(typeof(ClassWithReferenceType <object>)); var expectedPropertyGetter = typeof(ClassWithReferenceType <object>).GetMethod( "Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.get_ExplicitInterfaceScalar", BindingFlags.Instance | BindingFlags.NonPublic); CheckMethodInfo(expectedPropertyGetter, (MethodInfoAdapter)implementation); }
public void FindInterfaceDeclaration_ExplicitImplementation_FromBaseType() { var methodInfo = typeof(DerivedClassWithReferenceType <object>).GetMethod( "Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.get_ExplicitInterfaceScalar", BindingFlags.Instance | BindingFlags.NonPublic); var adapter = MethodInfoAdapter.Create(methodInfo); var result = adapter.FindInterfaceDeclarations(); var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ExplicitInterfaceScalar") }; CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ()); }
public void FindInterfaceDeclaration_ComparesMethodsWithoutReflectedTypes() { var methodInfo = typeof(DerivedClassWithReferenceType <object>).GetMethod("ImplicitInterfaceMethod"); var adapter = MethodInfoAdapter.Create(methodInfo); Assert.That(methodInfo.ReflectedType, Is.Not.SameAs(methodInfo.DeclaringType)); var result = adapter.FindInterfaceDeclarations(); var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("ImplicitInterfaceMethod") }; CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ()); }
public void GetOriginalDeclaration_WithBaseDefinition() { var method = typeof(DerivedClassWithReferenceType <SimpleReferenceType>).GetMethod("get_ImplicitInterfaceScalar"); var adapter = MethodInfoAdapter.Create(method); var result = adapter.GetOriginalDeclaration(); Assert.That(result, Is.TypeOf(typeof(MethodInfoAdapter))); var expectedMethodInfo = typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("get_ImplicitInterfaceScalar"); CheckMethodInfo(expectedMethodInfo, (MethodInfoAdapter)result); }