Added (Always)ReturnRefCapt for forcing the capture of parameters by reference.

Author: FranckRJ

include/fakeit/StubbingProgress.hpp

@@ -117,6 +117,16 @@ namespace fakeit {
                     return std::forward<R>(*store);
                 });
             }
+
+            template<typename T>
+            MethodStubbingProgress<R, arglist...>& ReturnRefCapt(T&& r) {
+                return Return(std::forward<T>(r));
+            }
+
+            template<typename T>
+            MethodStubbingProgress<R, arglist...>& AlwaysReturnRefCapt(T&& r) {
+                return AlwaysReturn(std::forward<T>(r));
+            }
         };
 
         // If R is not a reference.
@@ -151,6 +161,18 @@ namespace fakeit {
             void AlwaysReturnValCapt(const R &r) {
                 return AlwaysReturn(r);
             }
+
+            template<typename T>
+            MethodStubbingProgress<R, arglist...>& ReturnRefCapt(T&& r) {
+                static_assert(std::is_lvalue_reference<T>::value, "ReturnRefCapt() cannot take an rvalue references because it would make it dangling, use ReturnValCapt() instead.");
+                return Do([&r](const typename fakeit::test_arg<arglist>::type...) -> R { return r; });
+            }
+
+            template<typename T>
+            MethodStubbingProgress<R, arglist...>& AlwaysReturnRefCapt(T&& r) {
+                static_assert(std::is_lvalue_reference<T>::value, "AlwaysReturnRefCapt() cannot take an rvalue references because it would make it dangling, use AlwaysReturnValCapt() instead.");
+                return AlwaysDo([&r](const typename fakeit::test_arg<arglist>::type...) -> R { return r; });
+            }
         };
 
         template<typename R, typename ... arglist>

tests/return_template_specialization.cpp

@@ -24,9 +24,11 @@ struct ReturnTemplateSpecializationTests : tpunit::TestFixture {
             TEST(ReturnTemplateSpecializationTests::return_default_from_same_type_variable),
             TEST(ReturnTemplateSpecializationTests::return_valspecialization_from_same_type_variable),
             TEST(ReturnTemplateSpecializationTests::return_valcapt_from_same_type_variable),
+            TEST(ReturnTemplateSpecializationTests::return_refcapt_from_same_type_variable),
             TEST(ReturnTemplateSpecializationTests::return_default_from_other_type_variable),
             TEST(ReturnTemplateSpecializationTests::return_valspecialization_from_other_type_variable),
             TEST(ReturnTemplateSpecializationTests::return_valcapt_from_other_type_variable),
+            TEST(ReturnTemplateSpecializationTests::return_refcapt_from_other_type_variable),
             TEST(ReturnTemplateSpecializationTests::always_return_default_from_same_type_temp),
             TEST(ReturnTemplateSpecializationTests::always_return_valspecialization_from_same_type_temp),
             TEST(ReturnTemplateSpecializationTests::always_return_valcapt_from_same_type_temp),
@@ -267,6 +269,34 @@ struct ReturnTemplateSpecializationTests : tpunit::TestFixture {
         }
     }
 
+    void return_refcapt_from_same_type_variable() {
+        Mock<SomeStruct> mock;
+
+        {
+            std::string something = "something";
+            MoveOnly mo = 5;
+
+            When(Method(mock, returnRef)).ReturnRefCapt(something);
+            something = "a different thing";
+            ASSERT_EQUAL(mock.get().returnRef(), "a different thing");
+            Verify(Method(mock, returnRef)).Once();
+
+            When(Method(mock, returnRefMo)).ReturnRefCapt(mo);
+            mo.i = 10;
+            ASSERT_EQUAL(mock.get().returnRefMo().i, 10);
+            Verify(Method(mock, returnRefMo)).Once();
+        }
+
+        {
+            std::string something = "something";
+
+            When(Method(mock, returnVal)).ReturnRefCapt(something);
+            something = "a different thing";
+            ASSERT_EQUAL(mock.get().returnVal(), "a different thing");
+            Verify(Method(mock, returnVal)).Once();
+        }
+    }
+
     void return_default_from_other_type_variable() {
         Mock<SomeStruct> mock;
 
@@ -354,6 +384,25 @@ struct ReturnTemplateSpecializationTests : tpunit::TestFixture {
         }
     }
 
+    void return_refcapt_from_other_type_variable() {
+        Mock<SomeStruct> mock;
+
+        {
+            const char* something = "something";
+            int num = 5;
+
+            When(Method(mock, returnVal)).ReturnRefCapt(something);
+            something = "a different thing";
+            ASSERT_EQUAL(mock.get().returnVal(), "a different thing");
+            Verify(Method(mock, returnVal)).Once();
+
+            When(Method(mock, returnValMo)).ReturnRefCapt(num);
+            num = 10;
+            ASSERT_EQUAL(mock.get().returnValMo().i, 10);
+            Verify(Method(mock, returnValMo)).Once();
+        }
+    }
+
     void always_return_default_from_same_type_temp() {
         Mock<SomeStruct> mock;