Prefer T(...) over T{...} when they behave differently

...in gen::construct and gen::makeUnique. Also, add support
for aggregate initialization in gen::makeShared and tests for
all of them.

Author: stolyaroleh

include/rapidcheck/gen/Build.hpp

@@ -119,15 +119,50 @@ class BuildMapper<T, rc::detail::IndexSequence<Indexes...>, Lenses...> {
   std::tuple<Lenses...> m_lenses;
 };
 
+template<typename T, typename... Args>
+typename std::enable_if<std::is_constructible<T, Args...>::value, T>::type
+construct(Args &&... args) {
+  return T(std::move(args)...);
+}
+
+template<typename T, typename... Args>
+typename std::enable_if<!std::is_constructible<T, Args...>::value, T>::type
+construct(Args &&... args) {
+  return T{std::move(args)...};
+}
+
+template<typename T, typename... Args>
+typename std::enable_if<std::is_constructible<T, Args...>::value, std::unique_ptr<T>>::type
+makeUnique(Args &&... args) {
+  return std::unique_ptr<T>(new T(std::move(args)...));
+}
+
+template<typename T, typename... Args>
+typename std::enable_if<!std::is_constructible<T, Args...>::value, std::unique_ptr<T>>::type
+makeUnique(Args &&... args) {
+  return std::unique_ptr<T>(new T{std::move(args)...});
+}
+
+template<typename T, typename... Args>
+typename std::enable_if<std::is_constructible<T, Args...>::value, std::shared_ptr<T>>::type
+makeShared(Args &&... args) {
+  return std::shared_ptr<T>(new T(std::move(args)...));
+}
+
+template<typename T, typename... Args>
+typename std::enable_if<!std::is_constructible<T, Args...>::value, std::shared_ptr<T>>::type
+makeShared(Args &&... args) {
+  return std::shared_ptr<T>(new T{std::move(args)...});
+}
 } // namespace detail
 
 template <typename T, typename... Args>
 Gen<T> construct(Gen<Args>... gens) {
   return gen::map(gen::tuple(std::move(gens)...),
                   [](std::tuple<Args...> &&argsTuple) {
                     return rc::detail::applyTuple(
-                        std::move(argsTuple),
-                        [](Args &&... args) { return T{std::move(args)...}; });
+                      std::move(argsTuple),
+                      detail::construct<T, Args...>);
                   });
 }
 
@@ -141,22 +176,19 @@ Gen<std::unique_ptr<T>> makeUnique(Gen<Args>... gens) {
   return gen::map(gen::tuple(std::move(gens)...),
                   [](std::tuple<Args...> &&argsTuple) {
                     return rc::detail::applyTuple(
-                        std::move(argsTuple),
-                        [](Args &&... args) {
-                          return std::unique_ptr<T>(new T{std::move(args)...});
-                        });
+                      std::move(argsTuple),
+                      detail::makeUnique<T, Args...>);
                   });
 }
 
 template <typename T, typename... Args>
 Gen<std::shared_ptr<T>> makeShared(Gen<Args>... gens) {
   return gen::map(gen::tuple(std::move(gens)...),
                   [](std::tuple<Args...> &&argsTuple) {
-                    return rc::detail::applyTuple(std::move(argsTuple),
-                                                  [](Args &&... args) {
-                                                    return std::make_shared<T>(
-                                                        std::move(args)...);
-                                                  });
+                    return rc::detail::applyTuple(
+                      std::move(argsTuple),
+                      detail::makeShared<T, Args...>
+                    );
                   });
 }
 

test/gen/BuildTests.cpp

@@ -1,6 +1,7 @@
 #include <catch2/catch.hpp>
 #include <rapidcheck/catch.h>
 
+#include "util/Aggregate.h"
 #include "util/GenUtils.h"
 #include "util/Predictable.h"
 #include "util/Logger.h"
@@ -90,6 +91,16 @@ TEST_CASE("gen::construct") {
     RC_ASSERT(isArbitraryPredictable(std::get<0>(value)));
     RC_ASSERT(isArbitraryPredictable(std::get<1>(value)));
   }
+
+  SECTION("works with aggregate initializers") {
+    gen::construct<Aggregate>(gen::arbitrary<int>(), gen::arbitrary<int>());
+  }
+
+  SECTION("prefers T(x, y) over T{x, y} when they behave differently") {
+    auto a = gen::construct<std::vector<int>>(gen::just(3), gen::just(3))(Random(), 0).value();
+    std::vector<int> b(3, 3);
+    RC_ASSERT(a == b);
+  }
 }
 
 TEST_CASE("gen::makeUnique") {
@@ -122,6 +133,16 @@ TEST_CASE("gen::makeUnique") {
     RC_ASSERT(isArbitraryPredictable(std::get<0>(value)));
     RC_ASSERT(isArbitraryPredictable(std::get<1>(value)));
   }
+
+  SECTION("works with aggregate initializers") {
+    gen::makeUnique<Aggregate>(gen::arbitrary<int>(), gen::arbitrary<int>());
+  }
+
+  SECTION("prefers T(x, y) over T{x, y} when they behave differently") {
+    auto a = gen::makeUnique<std::vector<int>>(gen::just(3), gen::just(3))(Random(), 0).value();
+    auto b = std::unique_ptr<std::vector<int>>(new std::vector<int>(3, 3));
+    RC_ASSERT(*a == *b);
+  }
 }
 
 TEST_CASE("gen::makeShared") {
@@ -154,6 +175,16 @@ TEST_CASE("gen::makeShared") {
     RC_ASSERT(isArbitraryPredictable(std::get<0>(value)));
     RC_ASSERT(isArbitraryPredictable(std::get<1>(value)));
   }
+
+  SECTION("works with aggregate initializers") {
+    gen::makeShared<Aggregate>(gen::arbitrary<int>(), gen::arbitrary<int>());
+  }
+
+  SECTION("prefers T(x, y) over T{x, y} when they behave differently") {
+    auto a = gen::makeShared<std::vector<int>>(gen::just(3), gen::just(3))(Random(), 0).value();
+    auto b = std::shared_ptr<std::vector<int>>(new std::vector<int>(3, 3));
+    RC_ASSERT(*a == *b);
+  }
 }
 
 namespace {

test/util/Aggregate.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace rc {
+  struct Aggregate {
+    int x;
+    int y;
+  };
+} // namespace rc