Feature: New set of facade-macros

README.md

@@ -303,7 +303,7 @@ TEST_CASE("Interfaces can be mocked.")
         ~Derived() override = default;
 
         // This generates the override method and a mock object named `get_`.
-        MOCK_METHOD(get, int, (), const);
+        MAKE_MEMBER_MOCK(get, int, (), const override);
     };
 
     Derived mock{};
@@ -342,7 +342,7 @@ TEST_CASE("Interface overload-sets are directly supported.")
         ~Derived() override = default;
 
         // This generates two overloads of `get` and a single mock object named `get_`.
-        MOCK_OVERLOADED_METHOD(
+        MAKE_OVERLOADED_MEMBER_MOCK(
             get,                                    // The name of the overload set.
             ADD_OVERLOAD(int&, ()),                 // This enables `int& operator ()()`...
             ADD_OVERLOAD(const int&, (), const));   // ... and this the `const int& operator ()() const` on the mock.

examples/CMakeLists.txt

@@ -8,8 +8,9 @@ add_executable(${TARGET_NAME}
     "CustomMatcher.cpp"
     "CustomPrinter.cpp"
     "CustomString.cpp"
+    "Deprecated_InterfaceMock.cpp"
+    "FacadeMock.cpp"
     "Finalizers.cpp"
-    "InterfaceMock.cpp"
     "Mock.cpp"
     "Requirements.cpp"
     "Sequences.cpp"

examples/InterfaceMock.cpp → examples/Deprecated_InterfaceMock.cpp

@@ -3,52 +3,14 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
 
-#include "mimic++/InterfaceMock.hpp"
+#include "mimic++/Facade.hpp"
+#include "mimic++/macros/InterfaceMocking.hpp"
 #include "mimic++/policies/FinalizerPolicies.hpp"
 
-TEST_CASE(
-    "Mocking interface methods by hand.",
-    "[example][example::mock][example::mock::interface]")
-{
-    //! [interface mock manual]
-    class Interface
-    {
-    public:
-        virtual ~Interface() = default;
-        virtual void foo() = 0;
-    };
-
-    class Derived
-        : public Interface
-    {
-    public:
-        ~Derived() override = default;
+#include "../test/unit-tests/SuppressionMacros.hpp" // needs to disable the deprecations
 
-        // Begin boilerplate
-
-        // we build our mock object by hand
-        mimicpp::Mock<void()> foo_{};
-
-        // and forward the incoming call from the interface function to the mock object.
-        void foo() override
-        {
-            return foo_();
-        }
-
-        // End boilerplate
-    };
-
-    // this may be a function from somewhere else, working with an interface.
-    constexpr auto my_function = [](Interface& obj) {
-        obj.foo();
-    };
-
-    Derived mock{};
-    SCOPED_EXP mock.foo_.expect_call();
-
-    my_function(mock);
-    //! [interface mock manual]
-}
+START_WARNING_SUPPRESSION
+SUPPRESS_DEPRECATION
 
 TEST_CASE(
     "Interfaces methods can be mocked.",
@@ -189,3 +151,5 @@ TEST_CASE(
     use_interfaceB(mock); // calls foo() and the const bar()
                           //! [interface mock multiple inheritance]
 }
+
+STOP_WARNING_SUPPRESSION

examples/FacadeMock.cpp

@@ -0,0 +1,235 @@
+//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          https://www.boost.org/LICENSE_1_0.txt)
+
+#include "mimic++/Facade.hpp"
+#include "mimic++/policies/FinalizerPolicies.hpp"
+
+TEST_CASE(
+    "Mocking a polymorphic type by hand.",
+    "[example][example::mock][example::mock::facade]")
+{
+    //! [facade mock manual]
+    class Interface
+    {
+    public:
+        virtual ~Interface() = default;
+        virtual void foo() = 0;
+    };
+
+    class Derived
+        : public Interface
+    {
+    public:
+        ~Derived() override = default;
+
+        // Begin boilerplate
+
+        // we build our mock object by hand
+        mimicpp::Mock<void()> foo_{};
+
+        // and forward the incoming call from the interface function to the mock object.
+        void foo() override
+        {
+            return foo_();
+        }
+
+        // End boilerplate
+    };
+
+    // this may be a function from somewhere else, working with an interface.
+    constexpr auto my_function = [](Interface& obj) {
+        obj.foo();
+    };
+
+    Derived mock{};
+    SCOPED_EXP mock.foo_.expect_call();
+
+    my_function(mock);
+    //! [facade mock manual]
+}
+
+TEST_CASE(
+    "Virtual functions can be mocked.",
+    "[example][example::mock][example::mock::facade]")
+{
+    //! [facade interface mock simple]
+    class Interface
+    {
+    public:
+        virtual ~Interface() = default;
+        virtual void foo() = 0;
+    };
+
+    class Derived
+        : public Interface
+    {
+    public:
+        ~Derived() override = default;
+
+        // this generates the override method and a mock object named `foo_`
+        MAKE_MEMBER_MOCK(foo, void, (), override);
+    };
+
+    // this may be a function from somewhere else, working with an interface.
+    constexpr auto my_function = [](Interface& obj) {
+        obj.foo();
+    };
+
+    Derived mock{};
+    SCOPED_EXP mock.foo_.expect_call(); // note the `_` suffix. That's the name of the mock object.
+
+    my_function(mock);
+    //! [facade interface mock]
+}
+
+TEST_CASE(
+    "Overloaded virtual functions can be mocked.",
+    "[example][example::mock][example::mock::facade]")
+{
+    //! [facade interface mock overloaded]
+    class Interface
+    {
+    public:
+        virtual ~Interface() = default;
+        virtual void foo() = 0;
+        virtual void foo() const noexcept = 0;
+    };
+
+    class Derived
+        : public Interface
+    {
+    public:
+        ~Derived() override = default;
+
+        // this generates both overrides and a mock object named `foo_`
+        MAKE_OVERLOADED_MEMBER_MOCK(
+            foo,
+            ADD_OVERLOAD(void, (), override),
+            ADD_OVERLOAD(void, (), const noexcept override)); // note the `const noexcept` specifications as third argument
+    };
+
+    // this may be a function from somewhere else, working with an immutable interface.
+    constexpr auto my_function = [](Interface const& obj) {
+        obj.foo();
+    };
+
+    Derived mock{};
+    SCOPED_EXP std::as_const(mock).foo_.expect_call(); // We explicitly require the const overload to be called.
+
+    my_function(mock);
+    //! [facade interface mock overloaded]
+}
+
+TEST_CASE(
+    "Facade-Mocks can have an explicit *this* param.",
+    "[example][example::mock][example::mock::facade]")
+{
+    //! [facade mock with this]
+    namespace finally = mimicpp::finally;
+
+    class Base
+    {
+    public:
+        virtual ~Base() = default;
+
+        virtual int foo() const
+        {
+            return 42;
+        }
+    };
+
+    class Derived
+        : public Base
+    {
+    public:
+        ~Derived() override = default;
+
+        // This alias is required because the `..._WITH_THIS` macros are not able to determine the current type by themselves.
+        using self_type = Derived;
+
+        // This generates the override method and a mock object named foo_, which expects an explicit *this* param.
+        // => `Mock<int(Derived const*) const>`
+        MAKE_MEMBER_MOCK_WITH_THIS(foo, int, (), const override);
+    };
+
+    Derived object{};
+
+    // The first param behaves like an actual *this* pointer.
+    SCOPED_EXP object.foo_.expect_call(&object)
+        // Let's redirect the call to the actual `Base::foo` implementation.
+        and finally::returns_apply_all_result_of([](auto* self) { return self->Base::foo(); });
+
+    CHECK(42 == object.foo());
+    //! [facade mock with this]
+}
+
+TEST_CASE(
+    "Multiple-inheritance is supported.",
+    "[example][example::mock][example::mock::facade]")
+{
+    //! [facade mock multiple inheritance]
+    namespace expect = mimicpp::expect;
+    namespace finally = mimicpp::finally;
+
+    class InterfaceA
+    {
+    public:
+        virtual ~InterfaceA() = default;
+        virtual void foo() = 0;
+
+        virtual void bar() = 0;
+    };
+
+    class InterfaceB
+    {
+    public:
+        virtual ~InterfaceB() = default;
+        virtual void foo() = 0;
+
+        virtual int bar() const noexcept = 0;
+    };
+
+    class Derived
+        : public InterfaceA,
+          public InterfaceB
+    {
+    public:
+        ~Derived() override = default;
+
+        // Both interfaces have a foo() method with the same signature, so we do not need to overload.
+        MAKE_MEMBER_MOCK(foo, void, (), override); // mocks both foo() methods from InterfaceA and InterfaceB
+
+        // Both interfaces have a bar() method, but with different signature. So, let's work on that overload-set.
+        MAKE_OVERLOADED_MEMBER_MOCK(
+            bar,
+            ADD_OVERLOAD(void, (), override),                // from InterfaceA
+            ADD_OVERLOAD(int, (), const noexcept override)); // from InterfaceB
+    };
+
+    // let's build a function, which requires the InterfaceA
+    constexpr auto use_interfaceA = [](InterfaceA& obj) {
+        obj.foo();
+        obj.bar();
+    };
+
+    // and another, which requires the InterfaceB
+    constexpr auto use_interfaceB = [](InterfaceB& obj) {
+        obj.foo();
+        std::ignore = obj.bar(); // InterfaceB::bar returns an int, just explicitly ignore it here
+    };
+
+    // setting up the expectations isn't any different from the previous examples
+    Derived mock{};
+    SCOPED_EXP mock.foo_.expect_call()
+        and expect::twice();
+    SCOPED_EXP mock.bar_.expect_call();               // selects the non-const overload of bar()
+    SCOPED_EXP std::as_const(mock).bar_.expect_call() // selects the const overload of bar()
+        and finally::returns(42);
+
+    use_interfaceA(mock); // calls foo() and the non-const bar()
+    use_interfaceB(mock); // calls foo() and the const bar()
+
+    //! [facade mock multiple inheritance]
+}

examples/RegisterCallConvention.cpp

@@ -4,7 +4,7 @@
 //          https://www.boost.org/LICENSE_1_0.txt)
 
 #include "mimic++/CallConvention.hpp"
-#include "mimic++/InterfaceMock.hpp"
+#include "mimic++/Facade.hpp"
 
 //! [register __stdcall]
 MIMICPP_REGISTER_CALL_CONVENTION(__stdcall, detail::stdcall_convention);
@@ -37,7 +37,7 @@ TEST_CASE(
     struct derived
         : public interface
     {
-        MIMICPP_MOCK_METHOD(foo, void, (), const, __stdcall); // the call-convention goes last
+        MIMICPP_MAKE_MEMBER_MOCK(foo, void, (), const override, __stdcall); // the call-convention goes last
     };
 
     derived mock{};

examples/VariadicMocks.cpp

@@ -3,7 +3,7 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
 
-#include "mimic++/InterfaceMock.hpp"
+#include "mimic++/Facade.hpp"
 #include "mimic++/Mock.hpp"
 #include "mimic++/matchers/RangeMatchers.hpp"
 #include "mimic++/policies/FinalizerPolicies.hpp"
@@ -54,11 +54,11 @@ namespace
         : public VariadicInterface<Args...>
     {
     public:
-        MOCK_METHOD(foo, void, (Args...));
-        MOCK_OVERLOADED_METHOD(
+        MAKE_MEMBER_MOCK(foo, void, (Args...), override);
+        MAKE_OVERLOADED_MEMBER_MOCK(
             bar,
-            ADD_OVERLOAD(int, (int, Args...)),
-            ADD_OVERLOAD(std::string, (Args..., int, Args...), const));
+            ADD_OVERLOAD(int, (int, Args...), override),
+            ADD_OVERLOAD(std::string, (Args..., int, Args...), const override));
     };
 
     //! [variadic interface def]