Revise the ItByRef, set up more tests for the ref cases

Author: bclothier

Rubberduck.Main/ComClientLibrary/UnitTesting/Mocks/IComMock.cs

@@ -17,7 +17,7 @@ public interface IComMock
         object Object { [return: MarshalAs(UnmanagedType.IDispatch)] get; }
 
         [DispId(2)]
-        void SetupWithReturns(string Name, object Value, [Optional, MarshalAs(UnmanagedType.Struct)] object Args);
+        void SetupWithReturns(string Name, [MarshalAs(UnmanagedType.Struct)] object Value, [Optional, MarshalAs(UnmanagedType.Struct)] object Args);
 
         [DispId(3)]
         void SetupWithCallback(string Name, [MarshalAs(UnmanagedType.FunctionPtr)] Action Callback, [Optional, MarshalAs(UnmanagedType.Struct)] object Args);

Rubberduck.Main/ComClientLibrary/UnitTesting/Mocks/ItByRef.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using Moq;
-
-namespace Rubberduck.ComClientLibrary.UnitTesting.Mocks
+namespace Rubberduck.ComClientLibrary.UnitTesting.Mocks
 {
     public class ItByRef<T>
     {

Rubberduck.Main/ComClientLibrary/UnitTesting/Mocks/ItByRefReflection.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Reflection;
+using ExpressiveReflection;
+
+namespace Rubberduck.ComClientLibrary.UnitTesting.Mocks
+{
+    public class ItByRefMemberInfos
+    {
+        public static Type ItByRef(Type type)
+        {
+            return typeof(ItByRef<>).MakeGenericType(type);
+        }
+
+        public static MethodInfo Is(Type type)
+        {
+            return Reflection.GetMethodExt(ItByRef(type), nameof(ItByRef<object>.Is), type);
+        }
+
+        public static FieldInfo Value(Type type)
+        {
+            return ItByRef(type).GetField(nameof(ItByRef<object>.Value));
+        }
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Mocks/SetupArgumentResolver.cs

@@ -236,7 +236,7 @@ private Expression BuildPassByValueArgumentExpression(int index, SetupArgumentDe
 
         private Expression BuildPassByRefArgumentExpression(int index, SetupArgumentDefinition definition, Type refType, Type elementType, ref Dictionary<ParameterExpression, object> forwardedArgs)
         {
-            ParameterExpression parameterExpression;
+            Expression parameterExpression;
             switch (definition.Type)
             {
                 case SetupArgumentType.Is:
@@ -259,19 +259,11 @@ public void Test()
                     // TODO: need to take care that the args passed into DynamicInvoke do not need to be ref'd - it should be
                     // TODO: passed in as values then made ref within the expression tree.
                     var name = $"p{index:00}";
-                /*
-                    var forwardedArgExpression = Expression.Parameter(elementType, name);
-                    // forwardedArgs.Add(forwardedArgExpression, definition.Values[0]);
-
-                    var conditionExpression = Expression.Lambda();
-                    var itByRefType = typeof(ItByRef<>).MakeGenericType(elementType);
-                    var itMemberInfo = Reflection.GetMethodExt(itByRefType, nameof(ItByRef<object>.Is));
-                    var itByRefExpression = Expression.Call(itMemberInfo, forwardedArgExpression, null);
-
-                    parameterExpression = Expression.Field();
+                    var itByRef = ItByRefMemberInfos.Is(elementType).Invoke(null, new [] {definition.Values[0]});
+                    var forwardedArgExpression = Expression.Parameter(itByRef.GetType(), name);
+                    forwardedArgs.Add(forwardedArgExpression, itByRef);
+                    parameterExpression = Expression.Field(forwardedArgExpression, ItByRefMemberInfos.Value(elementType));
                     return parameterExpression;
-                */
-                    return null;
                 case SetupArgumentType.IsAny:
                     var itRefType = typeof(It.Ref<>).MakeGenericType(elementType);
                     var itFieldInfo = itRefType.GetField(nameof(It.IsAny));

RubberduckTests/ComMock/ItByRefTests.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using Moq;
 using NUnit.Framework;
 using Rubberduck.ComClientLibrary.UnitTesting.Mocks;
@@ -76,5 +78,60 @@ public void Basic_Ref_Setup_Returns()
             Assert.AreEqual(0, negativeActual);
         }
 
+        [Test]
+        public void ItByRefMemberInfos_Is()
+        {
+            Assert.IsNotNull(ItByRefMemberInfos.Is(typeof(int)));
+        }
+
+        [Test]
+        [TestCase(nameof(ITestRef.DoInt), 1)]
+        [TestCase(nameof(ITestRef.DoString), "abc")]
+        public void Test_ByRef_Setup(string memberName, object value)
+        {
+            var definitions = new SetupArgumentDefinitions
+            {
+                SetupArgumentDefinition.CreateIs(value)
+            };
+            var resolver = new SetupArgumentResolver();
+            var builder = new SetupExpressionBuilder(typeof(ITestRef), new List<Type>(), resolver);
+            
+            var mock = new Mock<ITestRef>();
+            var setupDatas = builder.CreateExpression(memberName, definitions);
+            var setupData = setupDatas.First();
+
+            var called = false;
+            void Action()
+            {
+                called = true;
+            }
+
+            MockExpressionBuilder.Create(mock)
+                .As(typeof(ITestRef))
+                .Setup(setupData.SetupExpression, setupData.Args)
+                .Callback(Action)
+                .Execute();
+
+            object refParam = null;
+            switch (memberName)
+            {
+                case nameof(ITestRef.DoInt):
+                    var refInt = (int) value;
+                    mock.Object.DoInt(ref refInt);
+                    refParam = refInt;
+                    break;
+                case nameof(ITestRef.DoString):
+                    var refString = (string) value;
+                    mock.Object.DoString(ref refString);
+                    refParam = refString;
+                    break;
+                default:
+                    Assert.Fail("Missing case for a member call");
+                    return;
+            }
+            
+            Assert.AreEqual(true, called);
+            Assert.AreEqual(value, refParam);
+        }
     }
 }