[GTest] create sut and mocks automatically when they are creatable

Author: kris-jusiak

README.md

@@ -121,7 +121,7 @@ struct BenchmarkTest : testing::Test {          |
  void SetUp() override {                        |
    sut = std::make_unique<example>(m1, m2, m3); |
  }                                              |
-                                                | // setup is NOT NEEDED!
+                                                | // set-up is NOT NEEDED!
  mock_i1 m1;                                    |
  mock_i2 m2;                                    |
  mock_i3 m3;                                    |
@@ -130,29 +130,27 @@ struct BenchmarkTest : testing::Test {          |
 ```
 
 ```cpp
-TEST_F(BenchmarkTest, ShouldCallF1) {           |GTEST(example) {
+TEST_F(BenchmarkTest, ShouldCallF1) {           |GTEST(example) { // set-up
  using namespace testing;                       | using namespace testing;
                                                 |
  EXPECT_CALL(m1,f1(_)).WillOnce(Return(true));  | SHOULD("call f1") {
  EXPECT_CALL(m2,f2_1()).Times(1);               |  EXPECT_CALL(mock<i1>(),(f1)(_)).WillOnce(Return(true));
  EXPECT_CALL(m3,f3(0, 1, 2)).Times(1);          |  EXPECT_CALL(mock<i2>(),(f2_1)()).Times(1);
                                                 |  EXPECT_CALL(mock<i3>(),(f3)(0, 1, 2)).Times(1);
  sut->test();                                   |
-}                                               |  sut->test(); // sut and mocks created automatically
-                                                | }
+}                                               |  sut->test(); // sut and mocks were
+                                                | }             // created automatically
 TEST_F(BenchmarkTest, ShouldCallF2) {           |
  using namespace testing;                       | SHOULD("call f2") {
                                                 |  EXPECT_CALL(mock<i1>(),(f1)(_)).WillOnce(Return(false));
  EXPECT_CALL(m1,f1(_)).WillOnce(Return(false)); |  EXPECT_CALL(mock<i2>(),(f2_2)()).Times(1);
  EXPECT_CALL(m2,f2_2()).Times(1);               |  EXPECT_CALL(mock<i3>(),(f3)(0, 1, 2)).Times(1);
  EXPECT_CALL(m3,f3(0, 1, 2)).Times(1);          |
                                                 |  sut->test();
- sut->test();                                   | }
+ sut->test();                                   | } // tear-down
 }                                               |}
 ```
 
-> Note: GUnit deduces constructor parameters automatically!
-
 #GUnit
 * Header only library
 * Based on top of GoogleTest/GoogleMock

example/GMock.cpp

@@ -6,9 +6,9 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 #include "GUnit/GMock.h"
-#include "GUnit/GMake.h"
 #include <gtest/gtest.h>
 #include <stdexcept>
+#include "GUnit/GMake.h"
 
 class interface {
  public:

include/GUnit/Detail/Preprocessor.h

@@ -20,7 +20,7 @@
 #define __GUNIT_IBP_IS_VARIADIC_R_1 1,
 #define __GUNIT_IBP_IS_VARIADIC_R___GUNIT_IBP_IS_VARIADIC_C 0,
 #define __GUNIT_IBP(...) __GUNIT_IBP_SPLIT(0, __GUNIT_CAT(__GUNIT_IBP_IS_VARIADIC_R_, __GUNIT_IBP_IS_VARIADIC_C __VA_ARGS__))
-#define __GUNIT_IS_EMPTY(...)                 \
+#define __GUNIT_IS_EMPTY(...)                    \
   __GUNIT_IS_EMPTY_IIF(__GUNIT_IBP(__VA_ARGS__)) \
   (__GUNIT_IS_EMPTY_GEN_ZERO, __GUNIT_IS_EMPTY_PROCESS)(__VA_ARGS__)
 #define __GUNIT_IS_EMPTY_PRIMITIVE_CAT(a, b) a##b

include/GUnit/GMake.h

@@ -186,6 +186,24 @@ struct resolve_size {
   operator const T &() const;
 };
 
+template <std::size_t, class T>
+using resolve_size_t = resolve_size<T>;
+
+template <class TParent>
+struct resolve_creatable {
+  template <class T, GUNIT_REQUIRES(!is_copy_ctor<TParent, T>::value && detail::is_abstract<deref_t<T>>::value)>
+  operator T();
+
+  template <class T, GUNIT_REQUIRES(!is_copy_ctor<TParent, T>::value && detail::is_abstract<deref_t<T>>::value)>
+  operator T &() const;
+
+  template <class T, GUNIT_REQUIRES(!is_copy_ctor<TParent, T>::value && detail::is_abstract<deref_t<T>>::value)>
+  operator const T &() const;
+};
+
+template <std::size_t, class T>
+using resolve_creatable_t = resolve_creatable<T>;
+
 template <class TParent, template <class> class TMock, class TArgs = std::tuple<>>
 class resolve {
  public:
@@ -254,9 +272,6 @@ class resolve {
 template <std::size_t, class T, template <class> class TMock, class TArgs = std::tuple<>>
 using resolve_t = resolve<T, TMock, TArgs>;
 
-template <std::size_t, class T>
-using resolve_size_t = resolve_size<T>;
-
 template <class, class = std::make_index_sequence<GUNIT_MAX_CTOR_SIZE>>
 struct ctor_size;
 
@@ -284,7 +299,16 @@ auto make_impl(detail::identity<T>, mocks_t &mocks, std::tuple<TArgs...> &args,
   return T(resolve_t<Ns, detail::deref_t<T>, TMock, std::tuple<TArgs...>>{mocks, args}...);
 }
 
-} // detail
+template <class, class>
+struct is_creatable_impl;
+
+template <class T, std::size_t... Ns>
+struct is_creatable_impl<T, std::index_sequence<Ns...>> : std::is_constructible<T, resolve_creatable_t<Ns, T>...> {};
+
+template <class T>
+using is_creatable = is_creatable_impl<T, std::make_index_sequence<ctor_size<T>::value>>;
+
+}  // detail
 
 template <class T, class... TArgs>
 auto make(TArgs &&... args) {

include/GUnit/GMock.h

@@ -26,7 +26,6 @@
 namespace testing {
 inline namespace v1 {
 namespace detail {
-
 static auto gmock_ready = true;
 
 // clang-format off
@@ -164,7 +163,7 @@ class vtable {
 };
 }  // detail
 
-template <class T>
+template <class T, class = detail::is_complete<T>>
 class GMock {
   static_assert(detail::is_abstract<T>::value, "T has to be an abstract type");
   static_assert(std::has_virtual_destructor<T>::value, "T has to have a virtual destructor");
@@ -390,7 +389,7 @@ inline auto ByRef(NiceGMock<T> &x) {
 #define __GMOCK_OVERLOAD_CAST_IMPL_1(obj, call)
 #define __GMOCK_OVERLOAD_CAST_IMPL_2(obj, call) \
   (::testing::detail::function_type_t<std::decay_t<decltype(obj)>::type, __GMOCK_FUNCTION call>)
-#define __GMOCK_INTERNAL(...)                  \
+#define __GMOCK_INTERNAL(...)               \
   __GUNIT_IF(__GUNIT_IS_EMPTY(__VA_ARGS__)) \
   (__GUNIT_IGNORE, __GUNIT_COMMA)() __VA_ARGS__
 #define __GMOCK_CALL(...) __GMOCK_INTERNAL

include/GUnit/GTest.h

@@ -57,7 +57,6 @@ class GTestAutoRegister {
   class ScopedVisibility {
    public:
     ScopedVisibility() { gmock_ready = false; }
-
     ~ScopedVisibility() { gmock_ready = true; }
 
    private:
@@ -78,6 +77,12 @@ class GTest {
  protected:
   using SUT = std::unique_ptr<T>;
 
+  explicit GTest(std::false_type) {}
+  explicit GTest(std::true_type) { std::tie(sut, mocks) = make<SUT, StrictGMock>(); }
+
+ public:
+  GTest() : GTest(is_creatable<T>{}) {}
+
   template <class TMock>
   decltype(auto) mock() {
     return mocks.mock<TMock>();
@@ -90,7 +95,7 @@ class GTest {
 template <class T>
 class GTest<T, std::false_type> {};
 
-} // detail
+}  // detail
 
 template <class T>
 class GTest : public detail::GTest<T>, public Test {};

test/GMake.cpp

@@ -6,8 +6,8 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 #include "GUnit/GMake.h"
-#include "GUnit/GMock.h"
 #include <gtest/gtest.h>
+#include "GUnit/GMock.h"
 
 struct interface {
   virtual ~interface() = default;

test/GMock.cpp

@@ -521,7 +521,6 @@ TEST(GMock, ShouldAllowDeletingMock) {
   }
 }
 
-
 TEST(GMock, ShouldHandleByRef) {
   using namespace testing;
   auto i = std::make_shared<GMock<interface>>();

test/GTest.cpp

@@ -697,6 +697,12 @@ GTEST(longest_ctor) {
 
 GTEST(longest_ctor_force) {
   using namespace testing;
+
+  SHOULD("not create sut and mocks") {
+    EXPECT_FALSE((detail::is_creatable<longest_ctor_force>::value));
+    EXPECT_FALSE(sut.get());
+  }
+
   std::tie(sut, mocks) = testing::make<SUT, testing::NaggyGMock>(short{42}, 77.0);
 
   SHOULD("take injected, longest ctor") {
@@ -710,8 +716,13 @@ GTEST(longest_ctor_force) {
 GTEST(complex_example) {
   using namespace testing;
 
+  SHOULD("create sut and mocks") {
+    EXPECT_TRUE((detail::is_creatable<complex_example>::value));
+    EXPECT_TRUE(sut.get());
+  }
+
   SHOULD("make complex example with strict mocks") {
-    std::tie(sut, mocks) = testing::make<SUT, testing::StrictGMock, NiceGMock<interface_dtor>>();
+    std::tie(sut, mocks) = testing::make<SUT, StrictGMock, NiceGMock<interface_dtor>>();
     EXPECT_CALL(mock<interface>(), (get)(_)).WillOnce(Return(123));
     EXPECT_CALL(mock<interface2>(), (f1)(77.0)).Times(1);
     EXPECT_CALL(mock<interface4>(), (f2)(_)).Times(1);
@@ -731,6 +742,17 @@ GTEST(complex_example) {
   }
 }
 
+struct is_default_constructible {};
+
+GTEST(is_default_constructible) {
+  using namespace testing;
+
+  SHOULD("create a default constructible type") {
+    EXPECT_TRUE((detail::is_creatable<is_default_constructible>::value));
+    EXPECT_TRUE(sut.get());
+  }
+}
+
 GTEST(class MakeWithMocks) {
   SHOULD("make complex example with default and custom mocks") {
     using namespace testing;