Exemple #1
0
        public void TestII0()
        {
            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var original = new ClassMockII0();
            var proxy = constructor.CreateProxy<IClassMockII0, ClassMockII0>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute)
                );

            {
                var originalImplementInterface = original.GetType().GetInterface(typeof(IDisposable).Name) != null;
                var proxyImplementInterface = proxy.GetType().GetInterface(typeof(IDisposable).Name) != null;

                Assert.IsTrue(originalImplementInterface);
                Assert.IsTrue(proxyImplementInterface);
            }

            {
                var originalImplementInterface = original.GetType().GetInterface(typeof(IClassMockII0).Name) != null;
                var proxyImplementInterface = proxy.GetType().GetInterface(typeof(IClassMockII0).Name) != null;

                Assert.IsTrue(originalImplementInterface);
                Assert.IsTrue(proxyImplementInterface);
            }
        }
        public void TestGeneric0()
        {
            var setExceptionFlag = false;
            var dispose = false;
            var ok = false;

            var payloadFactory = new MockPayloadFactory(
                (excp) =>
                {
                    setExceptionFlag = true;
                },
                () =>
                {
                    dispose = true;
                });

            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock13, ClassMock13>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action<int>((int x) =>
                {
                    ok = true;
                }));

            Assert.IsNotNull(proxy);

            proxy.X1(new List<int>());

            Assert.IsTrue(ok);
            Assert.IsFalse(setExceptionFlag);
            Assert.IsTrue(dispose);
        }
Exemple #3
0
        public void TestInvalidClass()
        {
            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            constructor.CreateProxy<IClassMock1, IClassMock0>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute)
                );
        }
Exemple #4
0
        public void TestNestedClasses()
        {
            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock2, ClassMock2>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute)
                );

            Assert.IsNotNull(proxy);
        }
Exemple #5
0
        public void Test0WithProperties()
        {
            var payloadFactory = new MockPayloadFactory();

            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock13, ClassMock13>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                }),
                new Action(() =>
                {
                }));

            Assert.IsNotNull(proxy);

        }
        public void Test2Constructors0()
        {
            var ok = false;

            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock11, ClassMock11>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                    ok = true;
                }));

            Assert.IsNotNull(proxy);

            proxy.X1();

            Assert.IsTrue(ok);
        }
        public void TestGeneric0()
        {
            var setExceptionFlag = false;
            var dispose = false;
            var ok = false;

            var payloadFactory = new MockPayloadFactory(
                (excp) =>
                {
                    setExceptionFlag = true;
                },
                () =>
                {
                    dispose = true;
                });

            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock21, ClassMock21>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new  Func<Dictionary<string, int>>(() =>
                {
                    ok = true;
                    return 
                        new Dictionary<string, int>();
                }));

            Assert.IsNotNull(proxy);

            Dictionary<string, List<int>> xl;
            var result0 = proxy.X2(out xl);
            var result1 = proxy.X1(ref xl);

            Assert.IsTrue(ok);
            Assert.IsFalse(setExceptionFlag);
            Assert.IsTrue(dispose);
        }
        public void TestNestedNestedClass8()
        {
            var ok = false;

            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<I8.IClassMock8, ClassMock8>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                    ok = true;
                }));

            Assert.IsNotNull(proxy);

            I8 a = null;
            proxy.X(ref a);

            Assert.IsTrue(ok);
        }
        public void TestDerivativeInterfaces()
        {
            var ok = false;

            var payloadFactory = new MockPayloadFactory();
            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock10_1, ClassMock10>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                    ok = true;
                }));

            Assert.IsNotNull(proxy);

            int a = 1;
            long b = 2;
            proxy.X0(ref a, out b);

            Assert.IsTrue(ok);
        }
        public void TestPayload1()
        {
            var setExceptionFlag = false;
            var dispose = false;
            var ok = false;

            var payloadFactory = new MockPayloadFactory(
                (excp) =>
                {
                    setExceptionFlag = true;
                },
                () =>
                {
                    dispose = true;
                });

            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock12, ClassMock12>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                    ok = true;
                    throw new Exception("а мы сломались!");
                }));

            Assert.IsNotNull(proxy);

            try
            {
                proxy.X1();
            }
            catch
            {
            }

            Assert.IsTrue(ok);
            Assert.IsTrue(setExceptionFlag);
            Assert.IsTrue(dispose);
        }
        public void TestPayload2()
        {
            var setExceptionFlag = false;
            var dispose = false;
            var ok = false;

            var payloadFactory = new MockPayloadFactory(
                (excp) =>
                {
                    setExceptionFlag = true;
                },
                () =>
                {
                    dispose = true;
                });

            var generator = new ProxyTypeGenerator();
            var constructor = new StandaloneProxyConstructor(generator);

            var proxy = constructor.CreateProxy<IClassMock12, ClassMock12>(
                payloadFactory,
                typeof(TestWrapWithProxyAttribute),
                new Action(() =>
                {
                    throw new Exception("здесь мы ваще не должны были оказаться");
                }),
                new Action(() =>
                {
                    ok = true;
                }));

            Assert.IsNotNull(proxy);

            proxy.X2();

            Assert.IsTrue(ok);
            Assert.IsFalse(setExceptionFlag);
            Assert.IsFalse(dispose);
        }