public void CreateProxyFromInterfaceWithGenericArrayParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<IGenericArrayParameter>(Type.EmptyTypes, invocationHandler);

            proxy.Method(new[] { "Two" });

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new[] { "Two" }));
        }
        public void CreateProxyFromAbstractClassWithStringArrayParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<StringArrayParameterBase>(Type.EmptyTypes, invocationHandler);

            proxy.Method(new[] { "2" });

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new[] { "2" }));
        }
        public void CreateProxyFromDelegateWithStructParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<Action<StructType>>(Type.EmptyTypes, invocationHandler);

            proxy(new StructType { Integer = 2, String = "2" });

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new StructType { Integer = 2, String = "2" }));
        }
        public void CreateProxyFromInterfaceWithStructRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<IStructRefParameter>(Type.EmptyTypes, invocationHandler);
            var value = new StructType { Integer = 2, String = "2" };

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new StructType { Integer = 2, String = "2" }));
        }
        public void CreateProxyFromDelegateWithStringParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<Action<string>>(Type.EmptyTypes, invocationHandler);

            proxy("2");

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo("2"));
        }
        public void CreateProxyFromInterfaceWithEnumRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<IEnumRefParameter>(Type.EmptyTypes, invocationHandler);
            var value = EnumType.Two;

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(EnumType.Two));
        }
        public void CreateProxyFromClassWithStringRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<StringRefParameter>(Type.EmptyTypes, invocationHandler);
            var value = "2";

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo("2"));
        }
        public void CreateProxyFromDelegateWithIntArrayParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<Action<int[]>>(Type.EmptyTypes, invocationHandler);

            proxy(new[] { 2 });

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new[] { 2 }));
        }
        public void CreateProxyFromClassWithGenericListRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<GenericListRefParameter>(Type.EmptyTypes, invocationHandler);
            var value = new List<string> { "Two" };

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new List<string> { "Two" }));
        }
        public void CreateProxyFromClassWithStructArrayParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<StructArrayParameter>(Type.EmptyTypes, invocationHandler);

            proxy.Method(new[] { new StructType { Integer = 2, String = "2" } });

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new[] { new StructType { Integer = 2, String = "2" } }));
        }
        public void CreateProxyFromClassWithIntParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<IntParameter>(Type.EmptyTypes, invocationHandler);

            proxy.Method(2);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(2));
        }
        public void CreateProxyFromAbstractClassWithIntRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<IntRefParameterBase>(Type.EmptyTypes, invocationHandler);
            var value = 2;

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(2));
        }
        public void CreateProxyFromAbstractClassWithGenericJaggedArrayRefParameterTest()
        {
            // Arrange
            var invocationHandler = new GetParametersInvocationHandler();

            // Act
            var proxy = _proxyFactory.CreateProxy<GenericJaggedArrayRefParameterBase>(Type.EmptyTypes, invocationHandler);
            var value = new[] { new[] { "Two" } };

            proxy.Method(ref value);

            // Assert
            Assert.That(invocationHandler.Parameters[0], Is.EqualTo(new[] { new[] { "Two" } }));
        }