Develop a working version of ItByRef class. The idea was correct but the setup can be flawed if not executed in correct sequence. Wrote tests to assert the behaviors on how Setup works only specific values passed by ref.

Author: bclothier

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

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Moq;
 
 namespace Rubberduck.ComClientLibrary.UnitTesting.Mocks
 {
@@ -7,16 +9,24 @@ public class ItByRef<T>
         // Only a field of a class can be passed by-ref.
         public T Value;
 
-        public static ItByRef<T> Is(T input, Func<T, bool> condition)
+        public delegate void ByRefCallback(ref T input);
+
+        public ByRefCallback Callback { get; }
+
+        public static ItByRef<T> Is(T initialValue)
+        {
+            return Is(initialValue, null);
+        }
+
+        public static ItByRef<T> Is(T initialValue, ByRefCallback action)
         {
-            return condition(input) 
-                ? new ItByRef<T>(input) 
-                : new ItByRef<T>(default);
+            return new ItByRef<T>(initialValue, action);
         }
 
-        private ItByRef(T input)
+        private ItByRef(T initialValue, ByRefCallback callback)
         {
-            Value = input;
+            Value = initialValue;
+            Callback = callback;
         }
     }
 }

RubberduckTests/ComMock/ItByRefTests.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Moq;
+using NUnit.Framework;
+using Rubberduck.ComClientLibrary.UnitTesting.Mocks;
+
+namespace RubberduckTests.ComMock
+{
+    [TestFixture]
+    [Category("ComMock.ItByRef")]
+    public class ItByRefTests
+    {
+        [Test]
+        public void Basic_Ref_Setup()
+        {
+            var mock = new Mock<ITestRef>();
+            var byRef = ItByRef<int>.Is(1, (ref int x) => x = 2);
+            mock.Setup(x => x.DoInt(ref byRef.Value)).Callback(byRef.Callback);
+            var obj = mock.Object;
+            obj.DoInt(ref byRef.Value);
+
+            Assert.AreEqual(2, byRef.Value);
+            mock.Verify(x => x.DoInt(ref byRef.Value), Times.Once);
+        }
+
+        [Test]
+        public void Multiple_Ref_Setup()
+        {
+            var mock = new Mock<ITestRef>();
+            var byRef1 = ItByRef<int>.Is(1, (ref int x) => x = 2);
+            var byRef2 = ItByRef<int>.Is(3, (ref int x) => x = 5);
+            mock.Setup(x => x.DoInt(ref byRef1.Value)).Callback(byRef1.Callback);
+            mock.Setup(x => x.DoInt(ref byRef2.Value)).Callback(byRef2.Callback);
+
+            var obj = mock.Object;
+            obj.DoInt(ref byRef1.Value);
+            obj.DoInt(ref byRef2.Value);
+
+            Assert.AreEqual(2, byRef1.Value);
+            Assert.AreEqual(5, byRef2.Value);
+            mock.Verify(x => x.DoInt(ref byRef1.Value), Times.Once);
+            mock.Verify(x => x.DoInt(ref byRef2.Value), Times.Once);
+        }
+
+        [Test]
+        public void Null_Ref_Setup()
+        {
+            var mock = new Mock<ITestRef>();
+            var byRef = ItByRef<string>.Is(null, (ref string x) => x = string.Empty);
+            mock.Setup(x => x.DoString(ref byRef.Value)).Callback(byRef.Callback);
+            var obj = mock.Object;
+            obj.DoString(ref byRef.Value);
+
+            var testString = "abc";
+            obj.DoString(ref testString);
+
+            Assert.AreEqual(string.Empty, byRef.Value);
+            Assert.AreEqual("abc", testString);
+
+            mock.Verify(x => x.DoString(ref byRef.Value), Times.Once);
+        }
+
+        [Test]
+        public void Basic_Ref_Setup_Returns()
+        {
+            var mock = new Mock<ITestRef>();
+            var byRef = ItByRef<int>.Is(1);
+            mock.Setup(x => x.ReturnInt(ref byRef.Value)).Returns(2);
+            var obj = mock.Object;
+            var actual = obj.ReturnInt(ref byRef.Value);
+
+            var negativeRef = 0;
+            var negativeActual = obj.ReturnInt(ref negativeRef);
+
+            Assert.AreEqual(2, actual);
+            Assert.AreEqual(0, negativeActual);
+        }
+
+    }
+}

RubberduckTests/ComMock/MockProviderTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using Moq;
 using NUnit.Framework;
@@ -538,83 +537,6 @@ public void Mock_Setup_Property_Specified_Args_Returns_Specified_Value(string II
             }
         }
 
-        [Test]
-        [TestCase("abc", "abc", true)]
-        [TestCase("abc", "def", false)]
-        [TestCase("abc", "", false)]
-        [TestCase("", "abc", false)]
-        [TestCase("", "", true)]
-        [TestCase("", null, false)]
-        [TestCase(1, 1, true)]
-        [TestCase(1, 2, false)]
-        [TestCase(1, null, false)]
-
-        // For null as expected, any values will be true
-        [TestCase(null, "", true)]
-        [TestCase(null, 1, true)]
-        public void Test_ItByRef_Value_Is<T>(T expected, T input, bool areEqual)
-        {
-            Test_ItByRef_Is(expected, input, areEqual);
-        }
-
-        [Test]
-        public void Test_ItByRef_Object_Is_NotSame()
-        {
-            var obj1 = new Mock<object>();
-            obj1.As<ITest1>();
-            var obj2 = new Mock<object>();
-            obj2.As<ITest1>();
-
-            Test_ItByRef_Is(obj1.Object, obj2.Object, false);
-        }
-
-        [Test]
-        public void Test_ItByRef_Object_Is_DifferentFace_Same()
-        {
-            var obj1 = new Mock<ITest1>();
-            var obj2 = obj1.As<ITest2>();
-
-            Test_ItByRef_Is((object)obj1.Object, (object)obj2.Object, true);
-        }
-
-        [Test]
-        public void Test_ItByRef_Object_Is_Null_NotSame()
-        {
-            var obj1 = new Mock<object>();
-            obj1.As<ITest1>();
-
-            Test_ItByRef_Is(obj1.Object, null, false);
-        }
-
-        [Test]
-        public void Test_ItByRef_Object_Is_Same()
-        {
-            var obj1 = new Mock<object>();
-            obj1.As<ITest1>();
-
-            Test_ItByRef_Is(obj1.Object, obj1.Object, true);
-        }
-
-        public void Test_ItByRef_Is<T>(T expected, T input, bool areEqual)
-        {
-            var actual = TestRef(ref ItByRef<T>.Is(input, x => EqualityComparer<T>.Default.Equals(x, expected)).Value);
-
-            var test = expected == null ? null : string.Concat("ref ", expected.ToString());
-            if (areEqual)
-            {
-                Assert.AreEqual(test, actual);
-            }
-            else
-            {
-                Assert.AreNotEqual(test, actual);
-            }
-        }
-        
-        private static string TestRef<T>(ref T refValue)
-        {
-            return refValue == null ? null : string.Concat("ref ", refValue.ToString());
-        }
-
         /* Commented to remove the PIA reference to Scripting library, but keeping code in one day they fix type equivalence?
         [Test]
         public void Type_From_ITypeInfo_Are_Equivalent()

RubberduckTests/ComMock/TypesForTesting.cs

@@ -21,6 +21,15 @@ public interface ITest3
         void DoObject(object something);
     }
 
+    public interface ITestRef
+    {
+        void DoInt(ref int something);
+        void DoString(ref string something);
+        void DoObject(ref object something);
+
+        int ReturnInt(ref int something);
+    }
+
     public class ConvertibleTest : IConvertible
     {
         private readonly TypeCode _code;