public void GetHashCode_DifferentOptions_Hook()
        {
            IProxyGenerationHook hook = new LogHook(typeof(object), true);

            _options1.Hook = hook;

            Assert.AreNotEqual(_options1.GetHashCode(), _options2.GetHashCode());
        }
        public void Equals_DifferentOptions_Hook()
        {
            IProxyGenerationHook hook = new LogHook(typeof(object), true);

            _options1.Hook = hook;

            Assert.AreNotEqual(_options1, _options2);
        }
        public void Hook_can_see_Equals_method()
        {
            var hook = new LogHook(typeof(EmptyClass));

            generator.CreateClassProxy(typeof(EmptyClass), new ProxyGenerationOptions(hook));

            var equals = typeof(EmptyClass).GetMethod("Equals");

            CollectionAssert.Contains(hook.AskedMembers, equals);
        }
        public void Hook_can_see_GetHashCode_method()
        {
            var hook = new LogHook(typeof(EmptyClass));

            generator.CreateClassProxy(typeof(EmptyClass), new ProxyGenerationOptions(hook));

            var getHashCode = typeof(EmptyClass).GetMethod("GetHashCode");

            CollectionAssert.Contains(hook.AskedMembers, getHashCode);
        }
        public void Hook_can_NOT_see_MemberwiseClone_method()
        {
            var hook = new LogHook(typeof(EmptyClass));

            generator.CreateClassProxy(typeof(EmptyClass), new ProxyGenerationOptions(hook));

            var memberwiseClone = typeof(EmptyClass).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);

            CollectionAssert.DoesNotContain(hook.AskedMembers, memberwiseClone);
            CollectionAssert.DoesNotContain(hook.NonVirtualMembers, memberwiseClone);
        }
        public void Hook_can_NOT_see_GetType_method()
        {
            var hook = new LogHook(typeof(EmptyClass));

            generator.CreateClassProxy(typeof(EmptyClass), new ProxyGenerationOptions(hook));

            var getType = typeof(EmptyClass).GetMethod("GetType");

            CollectionAssert.DoesNotContain(hook.AskedMembers, getType);
            CollectionAssert.DoesNotContain(hook.NonVirtualMembers, getType);
        }
        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 HookIsUsedForInterfaceProxy()
        {
            var logger = new LogInvocationInterceptor();
            var hook   = new LogHook(typeof(IService));

            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);
        }