Skip to content

Commit

Permalink
Prefer T(...) over T{...} when they behave differently
Browse files Browse the repository at this point in the history 
...in gen::construct and gen::makeUnique. Also, add support
for aggregate initialization in gen::makeShared and tests for
all of them.
  • Loading branch information
@stolyaroleh
stolyaroleh authored and Oleh Stolyar committed Dec 23, 2018
1 parent 3eb9b4f commit b6c7511
Show file tree
Hide file tree
Showing 4 changed files with 116 additions and 14 deletions.
6 changes: 3 additions & 3 deletions include/rapidcheck/detail/ApplyTuple.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ struct ApplyTupleImpl;

template <typename... Ts, std::size_t... Indexes, typename Callable>
struct ApplyTupleImpl<std::tuple<Ts...>, Callable, IndexSequence<Indexes...>> {
using ReturnType = typename std::result_of<Callable(Ts &&...)>::type;
using ReturnType = typename std::result_of<Callable&&(Ts &&...)>::type;

static ReturnType apply(std::tuple<Ts...> &&tuple, Callable &&callable) {
return callable(std::move(std::get<Indexes>(tuple))...);
Expand All @@ -24,7 +24,7 @@ template <typename... Ts, std::size_t... Indexes, typename Callable>
struct ApplyTupleImpl<std::tuple<Ts...> &,
Callable,
IndexSequence<Indexes...>> {
using ReturnType = typename std::result_of<Callable(Ts &...)>::type;
using ReturnType = typename std::result_of<Callable&&(Ts &...)>::type;

static ReturnType apply(std::tuple<Ts...> &tuple, Callable &&callable) {
return callable(std::get<Indexes>(tuple)...);
Expand All @@ -35,7 +35,7 @@ template <typename... Ts, std::size_t... Indexes, typename Callable>
struct ApplyTupleImpl<const std::tuple<Ts...> &,
Callable,
IndexSequence<Indexes...>> {
using ReturnType = typename std::result_of<Callable(const Ts &...)>::type;
using ReturnType = typename std::result_of<Callable&&(const Ts &...)>::type;

static ReturnType apply(const std::tuple<Ts...> &tuple, Callable &&callable) {
return callable(std::get<Indexes>(tuple)...);
Expand Down
58 changes: 47 additions & 11 deletions include/rapidcheck/gen/Build.hpp
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
#pragma once

#include <memory>

#include "rapidcheck/gen/Tuple.h"
#include "rapidcheck/detail/ApplyTuple.h"

Expand Down Expand Up @@ -119,15 +121,51 @@ 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::forward<Args>(args)...);
}

template<typename T, typename... Args>
typename std::enable_if<!std::is_constructible<T, Args...>::value, T>::type
construct(Args &&... args) {
return T{std::forward<Args>(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::forward<Args>(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::forward<Args>(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::make_shared<T>(std::forward<Args>(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::forward<Args>(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::forward<std::tuple<Args...>>(argsTuple),
detail::construct<T, Args...>
);
});
}

Expand All @@ -141,22 +179,20 @@ 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::forward<std::tuple<Args...>>(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::forward<std::tuple<Args...>>(argsTuple),
detail::makeShared<T, Args...>
);
});
}

Expand Down
43 changes: 43 additions & 0 deletions test/gen/BuildTests.cpp
View file
Original file line number Diff line number Diff line change
@@ -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"
Expand Down Expand Up @@ -90,6 +91,20 @@ 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<NestedAggregate>(gen::arbitrary<Aggregate>(),
gen::arbitrary<int>());
gen::construct<NestedAggregate>(gen::arbitrary<int>(),
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") {
Expand Down Expand Up @@ -122,6 +137,20 @@ 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<NestedAggregate>(gen::arbitrary<Aggregate>(),
gen::arbitrary<int>());
gen::makeUnique<NestedAggregate>(gen::arbitrary<int>(),
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") {
Expand Down Expand Up @@ -154,6 +183,20 @@ 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<NestedAggregate>(gen::arbitrary<Aggregate>(),
gen::arbitrary<int>());
gen::makeShared<NestedAggregate>(gen::arbitrary<int>(),
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 {
Expand Down
23 changes: 23 additions & 0 deletions test/util/Aggregate.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,23 @@
#pragma once

#include "rapidcheck.h"

namespace rc {
struct Aggregate {
int x;
int y;
};

template<>
struct Arbitrary<Aggregate> {
static Gen<Aggregate> arbitrary() {
return gen::construct<Aggregate>(gen::arbitrary<int>(),
gen::arbitrary<int>());
}
};

struct NestedAggregate {
Aggregate a;
int z;
};
} // namespace rc

0 comments on commit b6c7511

Please sign in to comment.