public void ChangingInvocationTargetSucceeds() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); IService service = (IService) generator.CreateInterfaceProxyWithTargetInterface( typeof(IService), new AlwaysThrowsServiceImpl(), new ChangeTargetInterceptor(new ServiceImpl()), logger); Assert.AreEqual(20, service.Sum(10, 10)); }
public void VirtualMethodCallsFromTheConstructor() { var logging = new LogInvocationInterceptor(); var o = (MakeVirtualCallFromCtor)generator.CreateClassProxy( typeof(MakeVirtualCallFromCtor), new Type[0], logging ); Assert.AreEqual(1, logging.Invocations.Count); Assert.IsNotNull(o); }
public void ProxyInternalMethod() { var logging = new LogInvocationInterceptor(); var o = (WithInternalMethod)generator.CreateClassProxy( typeof(WithInternalMethod), new Type[0], logging ); o.Foo(); Assert.AreEqual("Foo ", logging.LogContents); }
public void ProtectedMethods() { var logger = new LogInvocationInterceptor(); var proxy = (NonPublicMethodsClass) generator.CreateClassProxy(typeof(NonPublicMethodsClass), logger); proxy.DoSomething(); Assert.AreEqual(2, logger.Invocations.Count); Assert.AreEqual("DoSomething", logger.Invocations[0]); Assert.AreEqual("DoOtherThing", logger.Invocations[1]); }
public void BasicInterfaceProxyWithValidTarget2() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); IService2 service = (IService2) generator.CreateInterfaceProxyWithTarget( typeof(IService2), new Service2(), logger); service.DoOperation2(); Assert.AreEqual("DoOperation2 ", logger.LogContents); }
public void InterfaceInheritance() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); IService service = (IExtendedService) generator.CreateInterfaceProxyWithTarget( typeof(IExtendedService), new ServiceImpl(), logger); Assert.AreEqual(3, service.Sum(1, 2)); Assert.AreEqual("Sum ", logger.LogContents); }
public void Indexer() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); InterfaceWithIndexer service = (InterfaceWithIndexer) generator.CreateInterfaceProxyWithTarget( typeof(InterfaceWithIndexer), new ClassWithIndexer(), logger); Assert.AreEqual(1, service[1]); Assert.AreEqual("get_Item ", logger.LogContents); }
public void GenericClassWithGenericMethod() { var logger = new LogInvocationInterceptor(); var proxy = (IDoubleGeneric <int>)generator.CreateInterfaceProxyWithTarget( typeof(IDoubleGeneric <int>), new DoubleGenericImpl <int>(), logger ); proxy.Call(1, ""); Assert.AreEqual("Call", logger.Invocations[0]); }
public void InterfaceTargetTypeProducesInvocationsThatCanChangeTarget() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); AssertCanChangeTargetInterceptor invocationChecker = new AssertCanChangeTargetInterceptor(); IService2 service = (IService2) generator.CreateInterfaceProxyWithTargetInterface( typeof(IService2), new Service2(), invocationChecker, logger); service.DoOperation2(); Assert.AreEqual("DoOperation2 ", logger.LogContents); }
public void Mixin_same_as_proxied_class_forwards_to_base() { var interceptor = new LogInvocationInterceptor(); var mixin = new ClassImplementingISimpleMixin(); object proxy = generator.CreateClassProxy( typeof(SimpleMixin), MixIn(mixin), interceptor ); Assert.AreEqual(1, (proxy as ISimpleMixin).DoSomething()); Assert.IsEmpty(interceptor.Invocations); }
public void InternalClassWithInternalMethodAndProperty() { var logging = new LogInvocationInterceptor(); var o = (InternalClassWithInternalMembers)generator.CreateClassProxy(typeof(InternalClassWithInternalMembers), new Type[0], logging); Assert.IsNotNull(o); o.TestMethod(); Assert.AreEqual(1, logging.Invocations.Count); var t = o.TestProperty; Assert.AreEqual(2, logging.Invocations.Count); }
public void Mixin_with_derived_base_forwards_to_mixin() { var interceptor = new LogInvocationInterceptor(); var mixin = new ClassImplementingIDerivedSimpleMixin(); object proxy = generator.CreateClassProxy( typeof(SimpleMixin), new[] { typeof(IDerivedSimpleMixin) }, MixIn(mixin), interceptor ); Assert.AreEqual(2, (proxy as IDerivedSimpleMixin).DoSomethingDerived()); Assert.IsNotEmpty(interceptor.Invocations); }
public void ProxyInternalMethod() { var logging = new LogInvocationInterceptor(); var o = (WithInternalMethod)generator.CreateClassProxy(typeof(WithInternalMethod), new Type[0], logging); o.Foo(); #if SILVERLIGHT Assert.IsNullOrEmpty(logging.LogContents); #else Assert.AreEqual("Foo ", logging.LogContents); #endif }
public void ClassWithDifferentAccessLevelOnProperties() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); object proxy = generator.CreateClassProxy(typeof(DiffAccessLevelOnProperties), logger); Assert.IsNotNull(proxy); Assert.IsInstanceOf(typeof(DiffAccessLevelOnProperties), proxy); DiffAccessLevelOnProperties type = (DiffAccessLevelOnProperties)proxy; type.SetProperties(); Assert.AreEqual("10 11 12 13 name", type.ToString()); }
public void UsingEvents_Class() { var logger = new LogInvocationInterceptor(); var proxy = (FakeWithEvents)generator.CreateClassProxy( typeof(FakeWithEvents), ProxyGenerationOptions.Default, logger); Assert.IsNotNull(proxy); proxy.Foo += null; proxy.Foo -= null; Assert.AreEqual(2, logger.Invocations.Count); }
public void UsingEvents_Interface() { var logger = new LogInvocationInterceptor(); var proxy = (IWithEvents)generator.CreateInterfaceProxyWithTarget(typeof(IWithEvents), new FakeWithEvents(), logger); Assert.IsNotNull(proxy); proxy.Foo += null; proxy.Foo -= null; Assert.AreEqual(2, logger.Invocations.Count); }
public void ProxyTypeWithMultiDimentionalArrayAsParameters() { LogInvocationInterceptor log = new LogInvocationInterceptor(); ClassWithMultiDimentionalArray proxy = generator.CreateClassProxy <ClassWithMultiDimentionalArray>(log); int[,] x = new int[1, 2]; proxy.Do(new int[] { 1 }); proxy.Do2(x); proxy.Do3(new string[] { "1", "2" }); Assert.AreEqual("Do Do2 Do3 ", log.LogContents); }
public void ClassWithInheritance() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); object proxy = generator.CreateClassProxy(typeof(ExtendedServiceClass), logger); Assert.IsNotNull(proxy); ExtendedServiceClass extended = (ExtendedServiceClass)proxy; extended.Sum2(1, 2); extended.Sum(1, 2); Assert.AreEqual("Sum2 Sum ", logger.LogContents); }
public void ExplicitInterfaceMethods_AreIgnored_OnClassProxy() { LogInvocationInterceptor interceptor = new LogInvocationInterceptor(); ClassWithExplicitInterface instance = generator.CreateClassProxy <ClassWithExplicitInterface>(interceptor); instance.DoVirtual(); int result = ((ISimpleInterface)instance).Do(); instance.DoVirtual(); Assert.AreEqual(2, interceptor.Invocations.Count); Assert.AreEqual("DoVirtual", interceptor.Invocations[0]); Assert.AreEqual("DoVirtual", interceptor.Invocations[1]); Assert.AreEqual(5, result); }
public void ProxyForClassWithIndexer() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); object proxy = generator.CreateClassProxy(typeof(ClassWithIndexer), logger); Assert.IsNotNull(proxy); Assert.IsInstanceOf(typeof(ClassWithIndexer), proxy); ClassWithIndexer type = (ClassWithIndexer)proxy; type["name"] = 10; Assert.AreEqual(10, type["name"]); Assert.AreEqual("set_Item get_Item ", logger.LogContents); }
public void HookIsUsedForConcreteClassProxy() { var logger = new LogInvocationInterceptor(); var hook = new LogHook(typeof(ServiceClass), true); var options = new ProxyGenerationOptions(hook); var proxy = (ServiceClass)generator.CreateClassProxy(typeof(ServiceClass), options, logger); Assert.IsTrue(hook.Completed); Assert.AreEqual(13, hook.AskedMembers.Count, "Asked members"); Assert.AreEqual(2, hook.NonVirtualMembers.Count, "Non-virtual members"); proxy.Sum(1, 2); Assert.IsFalse(proxy.Valid); Assert.AreEqual("get_Valid ", logger.LogContents); }
public void HookIsUsedForConcreteClassProxy() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); LogHook hook = new LogHook(typeof(ServiceClass), true); ProxyGenerationOptions options = new ProxyGenerationOptions(hook); ServiceClass proxy = (ServiceClass)generator.CreateClassProxy(typeof(ServiceClass), options, logger); Assert.IsTrue(hook.Completed); Assert.AreEqual(10, hook.AskedMembers.Count, "Asked members"); Assert.AreEqual(2, hook.NonVirtualMembers.Count, "Non-virtual members"); // <-- this would fail due to superfulous method check proxy.Sum(1, 2); Assert.IsFalse(proxy.Valid); Assert.AreEqual("get_Valid ", logger.LogContents); }
public void HookIsUsedForInterfaceProxy() { var logger = new LogInvocationInterceptor(); var hook = new LogHook(typeof(IService), false); var options = new ProxyGenerationOptions(hook); var proxy = (IService) generator.CreateInterfaceProxyWithTarget( typeof(IService), new ServiceImpl(), options, logger); Assert.IsTrue(hook.Completed); Assert.AreEqual(10, hook.AskedMembers.Count); Assert.AreEqual(0, hook.NonVirtualMembers.Count); Assert.AreEqual(3, proxy.Sum(1, 2)); Assert.IsFalse(proxy.Valid); Assert.AreEqual("Sum get_Valid ", logger.LogContents); }
public void HookDetectsNonVirtualAlthoughInterfaceImplementation() { var logger = new LogInvocationInterceptor(); var hook = new LogHook(typeof(ServiceImpl), true); var options = new ProxyGenerationOptions(hook); // we are creating a class proxy although the creation of an interface proxy is possible too... // since the members of our implementation are not explicitly marked as virtual, the runtime // marks them as virtual but final --> not good for us, but intended by .net :-( // // see: https://msdn.microsoft.com/library/system.reflection.methodbase.isvirtual // // thus, a non virtual notification for this particular situation is appropriate generator.CreateClassProxy(typeof(ServiceImpl), options, logger); Assert.IsTrue(hook.Completed); Assert.AreEqual(3, hook.AskedMembers.Count); Assert.AreEqual(11, hook.NonVirtualMembers.Count); }
public void ProtectedMethods() { LogInvocationInterceptor logger = new LogInvocationInterceptor(); NonPublicMethodsClass proxy = (NonPublicMethodsClass) generator.CreateClassProxy(typeof(NonPublicMethodsClass), logger); try { proxy.DoSomething(); } catch (Exception e) { Console.WriteLine(e); } Assert.AreEqual(2, logger.Invocations.Count); Assert.AreEqual("DoSomething", logger.Invocations[0]); Assert.AreEqual("DoOtherThing", logger.Invocations[1]); }
public void ExplicitInterface_AsAdditionalInterfaceToProxy_OnClassProxy_WithoutBaseCalls() { LogInvocationInterceptor interceptor = new LogInvocationInterceptor(); interceptor.Proceed = false; ClassWithExplicitInterface instance = (ClassWithExplicitInterface)generator.CreateClassProxy(typeof(ClassWithExplicitInterface), new[] { typeof(ISimpleInterface) }, interceptor); instance.DoVirtual(); int result = ((ISimpleInterface)instance).Do(); instance.DoVirtual(); Assert.AreEqual(3, interceptor.Invocations.Count); Assert.AreEqual("DoVirtual", interceptor.Invocations[0]); Assert.AreEqual("Do", interceptor.Invocations[1]); Assert.AreEqual("DoVirtual", interceptor.Invocations[2]); Assert.AreEqual(0, result); // indicates that original method was not called }
public override void Init() { base.Init(); interceptor = new LogInvocationInterceptor(); }
public void Mixin_same_as_proxied_class_and_additional_interface_forwards_to_base_interceptable() { var interceptor = new LogInvocationInterceptor(); var mixin = new ClassImplementingISimpleMixin(); object proxy = generator.CreateClassProxy(typeof(SimpleMixin), new[] { typeof(ISimpleMixin) }, MixIn(mixin), interceptor); Assert.AreEqual(1, (proxy as ISimpleMixin).DoSomething()); Assert.IsNotEmpty(interceptor.Invocations); }
public void Mixin_with_derived_base_forwards_to_mixin() { var interceptor = new LogInvocationInterceptor(); var mixin = new ClassImplementingIDerivedSimpleMixin(); object proxy = generator.CreateClassProxy(typeof(SimpleMixin), new[] { typeof(IDerivedSimpleMixin) }, MixIn(mixin), interceptor); Assert.AreEqual(2, (proxy as IDerivedSimpleMixin).DoSomethingDerived()); Assert.IsNotEmpty(interceptor.Invocations); }
public void Init() { LogInvocationInterceptor.Clear(); }