Skip to content

F
folly
Commit d58fe683 authored by Kirk Shoop's avatar Kirk Shoop Committed by Facebook Github Bot
Browse files
Options

migrate to gtest 

Summary:
migrated tests
fixed some bugs introduced while tests were disabled

Reviewed By: yfeldblum

Differential Revision: D10515231

fbshipit-source-id: 34cddb6588c4da9cd05256111bf9626b013dd4fa
parent 20d6c1df
Show whitespace changes
Inline Side-by-side
Showing with 879 additions and 969 deletions
folly/experimental/pushmi/constrained_single_sender.h
View file @ d58fe683
......@@ -84,8 +84,8 @@ class any_constrained_single_sender {
return ::folly::pushmi::top(*static_cast<Wrapped*>((void*)src.buffer_));
}
static any_constrained_executor<E, CV> executor(data& src) {
return any_constrained_executor<E, CV>{
executor(*static_cast<Wrapped*>((void*)src.buffer_))};
return any_constrained_executor<E, CV>{::folly::pushmi::executor(
*static_cast<Wrapped*>((void*)src.buffer_))};
}
static void submit(data& src, CV cv, any_receiver<E, VN...> out) {
::folly::pushmi::submit(
......
folly/experimental/pushmi/entangle.h
View file @ d58fe683
......@@ -166,7 +166,7 @@ struct entangled {
entangled& operator=(entangled&&) = delete;
explicit entangled(T t)
: t(std::move(t)), dual(nullptr), stateMachine(kUnlocked) {}
: stateMachine(kUnlocked), t(std::move(t)), dual(nullptr) {}
entangled(entangled&& other)
: stateMachine((other.lockBoth(), kLocked)),
t(std::move(other.t)),
......
folly/experimental/pushmi/o/for_each.h
View file @ d58fe683
......@@ -34,16 +34,27 @@ struct for_each_fn {
using properties =
property_set_insert_t<properties_t<Out>, property_set<is_flow<>>>;
std::function<void(std::ptrdiff_t)> pull;
template <class V>
void value(V&& v) {
set_value(static_cast<Out&>(*this), (V &&) v);
template <class... VN>
void value(VN&&... vn) {
::folly::pushmi::set_value(static_cast<Out&>(*this), (VN &&) vn...);
pull(1);
}
template <class E>
void error(E&& e) {
// break circular reference
pull = nullptr;
::folly::pushmi::set_error(static_cast<Out&>(*this), (E &&) e);
}
void done() {
// break circular reference
pull = nullptr;
::folly::pushmi::set_done(static_cast<Out&>(*this));
}
PUSHMI_TEMPLATE(class Up)
(requires Receiver<Up>)
(requires Receiver<Up> && ReceiveValue<Up, std::ptrdiff_t>)
void starting(Up up) {
pull = [up = std::move(up)](std::ptrdiff_t requested) mutable {
set_value(up, requested);
::folly::pushmi::set_value(up, requested);
};
pull(1);
}
......@@ -62,23 +73,8 @@ struct for_each_fn {
property_set_index_t<properties_t<In>, is_single<>>>>()(
std::move(args_))};
using Out = decltype(out);
submit(
in,
::folly::pushmi::detail::receiver_from_fn<In>()(
Pull<In, Out>{std::move(out)}));
return in;
}
PUSHMI_TEMPLATE(class In)
(requires Sender<In>&& Constrained<In>&& Flow<In>&& Many<In>)
In operator()(In in) {
auto out{::folly::pushmi::detail::receiver_from_fn<subset<
is_sender<>,
property_set_index_t<properties_t<In>, is_single<>>>>()(
std::move(args_))};
using Out = decltype(out);
submit(
::folly::pushmi::submit(
in,
::folly::pushmi::top(in),
::folly::pushmi::detail::receiver_from_fn<In>()(
Pull<In, Out>{std::move(out)}));
return in;
......@@ -88,7 +84,7 @@ struct for_each_fn {
public:
template <class... AN>
auto operator()(AN&&... an) const {
return for_each_fn::fn<AN...>{{(AN &&) an...}};
return for_each_fn::fn<AN...>{std::tuple<AN...>{(AN &&) an...}};
}
};
......
folly/experimental/pushmi/o/from.h
View file @ d58fe683
......@@ -102,7 +102,8 @@ struct flow_from_up {
return;
}
// submit work to exec
submit(p->exec, make_receiver([p = p, requested](auto) {
::folly::pushmi::submit(
p->exec, make_receiver([p = p, requested](auto) {
auto remaining = requested;
// this loop is structured to work when there is
// re-entrancy out.value in the loop may call up.value.
......@@ -122,12 +123,14 @@ struct flow_from_up {
template <class E>
void error(E) noexcept {
p->stop.store(true);
submit(p->exec, make_receiver([p = p](auto) { set_done(p->out); }));
::folly::pushmi::submit(
p->exec, make_receiver([p = p](auto) { set_done(p->out); }));
}
void done() {
p->stop.store(true);
submit(p->exec, make_receiver([p = p](auto) { set_done(p->out); }));
::folly::pushmi::submit(
p->exec, make_receiver([p = p](auto) { set_done(p->out); }));
}
};
......@@ -147,7 +150,8 @@ PUSHMI_INLINE_VAR constexpr struct flow_from_fn {
auto p = std::make_shared<Producer>(
begin_, end_, std::move(out), exec_, false);
submit(exec_, make_receiver([p](auto) {
::folly::pushmi::submit(
exec_, make_receiver([p](auto) {
// pass reference for cancellation.
set_starting(p->out, make_receiver(flow_from_up<Producer>{p}));
}));
......
folly/experimental/pushmi/o/submit.h
View file @ d58fe683
......@@ -58,7 +58,7 @@ struct submit_fn {
In operator()(In in) {
auto out{
::folly::pushmi::detail::receiver_from_fn<In>{}(std::move(args_))};
submit(in, std::move(out));
::folly::pushmi::submit(in, std::move(out));
return in;
}
};
......@@ -81,7 +81,7 @@ struct submit_at_fn {
In operator()(In in) {
auto out{
::folly::pushmi::detail::receiver_from_fn<In>()(std::move(args_))};
submit(in, std::move(at_), std::move(out));
::folly::pushmi::submit(in, std::move(at_), std::move(out));
return in;
}
};
......@@ -90,7 +90,8 @@ struct submit_at_fn {
PUSHMI_TEMPLATE(class TP, class... AN)
(requires Regular<TP>)
auto operator()(TP at, AN... an) const {
return submit_at_fn::fn<TP, AN...>{std::move(at), {(AN &&) an...}};
return submit_at_fn::fn<TP, AN...>{std::move(at),
std::tuple<AN...>{(AN &&) an...}};
}
};
......@@ -109,7 +110,7 @@ struct submit_after_fn {
auto out{
::folly::pushmi::detail::receiver_from_fn<In>()(std::move(args_))};
auto at = ::folly::pushmi::now(in) + std::move(after_);
submit(in, std::move(at), std::move(out));
::folly::pushmi::submit(in, std::move(at), std::move(out));
return in;
}
};
......@@ -118,7 +119,8 @@ struct submit_after_fn {
PUSHMI_TEMPLATE(class D, class... AN)
(requires Regular<D>)
auto operator()(D after, AN... an) const {
return submit_after_fn::fn<D, AN...>{std::move(after), {(AN &&) an...}};
return submit_after_fn::fn<D, AN...>{std::move(after),
std::tuple<AN...>{(AN &&) an...}};
}
};
......@@ -159,7 +161,7 @@ struct blocking_submit_fn {
using properties = properties_t<Exec>;
auto executor() {
return make(state_, executor(ex_));
return make(state_, ::folly::pushmi::executor(ex_));
}
PUSHMI_TEMPLATE(class... ZN)
......@@ -172,14 +174,16 @@ struct blocking_submit_fn {
(requires Receiver<Out>&& Constrained<Exec>)
void submit(CV cv, Out out) {
++state_->nested;
submit(ex_, cv, nested_receiver_impl<Out>{state_, std::move(out)});
::folly::pushmi::submit(
ex_, cv, nested_receiver_impl<Out>{state_, std::move(out)});
}
PUSHMI_TEMPLATE(class Out)
(requires Receiver<Out> && not Constrained<Exec>)
void submit(Out out) {
++state_->nested;
submit(ex_, nested_receiver_impl<Out>{state_, std::move(out)});
::folly::pushmi::submit(
ex_, nested_receiver_impl<Out>{state_, std::move(out)});
}
};
template <class Out>
......@@ -293,7 +297,7 @@ struct blocking_submit_fn {
PUSHMI_TEMPLATE(class Out)
(requires Receiver<Out>&& SenderTo<In, Out>)
void operator()(In& in, Out out) const {
submit(in, std::move(out));
::folly::pushmi::submit(in, std::move(out));
}
};
// TODO - only move, move-only types..
......
folly/experimental/pushmi/strand.h
View file @ d58fe683
......@@ -203,7 +203,8 @@ class strand_executor {
queue_->items_.push(any_receiver<E, any_executor_ref<E>>{std::move(out)});
if (queue_->remaining_ == 0) {
// noone is minding the shop, send a worker
submit(queue_->ex_, strand_queue_receiver<E, Executor>{queue_});
::folly::pushmi::submit(
queue_->ex_, strand_queue_receiver<E, Executor>{queue_});
}
}
};
......
folly/experimental/pushmi/test/CompileTest.cpp
View file @ d58fe683
......@@ -25,6 +25,11 @@
using namespace folly::pushmi::aliases;
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
using namespace testing;
using namespace std::literals;
#if __cpp_deduction_guides >= 201703
......@@ -562,3 +567,5 @@ void flow_many_sender_test() {
mi::Executor<mi::executor_t<decltype(in0)>>,
"sender has invalid executor");
}
TEST(CompileTest, Test) {}
folly/experimental/pushmi/test/FlowManyTest.cpp
View file @ d58fe683
......@@ -22,9 +22,9 @@
using namespace std::literals;
#include <folly/experimental/pushmi/flow_many_sender.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/from.h>
#include <folly/experimental/pushmi/o/for_each.h>
#include <folly/experimental/pushmi/o/from.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/entangle.h>
#include <folly/experimental/pushmi/new_thread.h>
......@@ -33,7 +33,10 @@ using namespace std::literals;
using namespace folly::pushmi::aliases;
#if 0
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
using namespace testing;
#if __cpp_deduction_guides >= 201703
#define MAKE(x) x MAKE_
......@@ -43,12 +46,10 @@ using namespace folly::pushmi::aliases;
#define MAKE(x) make_##x
#endif
SCENARIO("flow many immediate cancellation", "[flowmany][flow][sender]") {
int signals = 0;
GIVEN("A flow many sender") {
auto f = mi::MAKE(flow_many_sender)([&](auto out) {
class ImmediateFlowManySender : public Test {
protected:
auto make_producer() {
return mi::MAKE(flow_many_sender)([&](auto out) {
using Out = decltype(out);
struct Data : mi::receiver<> {
explicit Data(Out out) : out(std::move(out)), stop(false) {}
......@@ -59,21 +60,23 @@ SCENARIO("flow many immediate cancellation", "[flowmany][flow][sender]") {
auto up = mi::MAKE(receiver)(
Data{std::move(out)},
[&](auto& data, auto requested) {
signals += 1000000;
if (requested < 1) {return;}
signals_ += 1000000;
if (requested < 1) {
return;
}
// check boolean to select signal
if (!data.stop) {
::mi::set_value(data.out, 42);
}
::mi::set_done(data.out);
},
[&](auto& data, auto e) noexcept {
signals += 100000;
[&](auto& data, auto) noexcept {
signals_ += 100000;
data.stop = true;
::mi::set_done(data.out);
},
[&](auto& data) {
signals += 10000;
signals_ += 10000;
data.stop = true;
::mi::set_done(data.out);
});
......@@ -81,68 +84,78 @@ SCENARIO("flow many immediate cancellation", "[flowmany][flow][sender]") {
// pass reference for cancellation.
::mi::set_starting(up.data().out, std::move(up));
});
}
WHEN("submit is applied and cancels the producer") {
f |
op::submit(mi::MAKE(flow_receiver)(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
template <class F>
auto make_consumer(F f) {
return mi::MAKE(flow_receiver)(
mi::on_value([&](int) { signals_ += 100; }),
mi::on_error([&](auto) noexcept { signals_ += 1000; }),
mi::on_done([&]() { signals_ += 1; }),
mi::on_starting([&, f](auto up) {
signals_ += 10;
f(std::move(up));
}));
}
int signals_{0};
};
TEST_F(ImmediateFlowManySender, EarlyCancellation) {
make_producer() | op::submit(make_consumer([](auto up) {
// immediately stop producer
mi::on_starting([&](auto up) {
signals += 10;
::mi::set_done(up);
})));
}));
THEN(
"the starting, up.done and out.done signals are each recorded once") {
REQUIRE(signals == 10011);
}
}
EXPECT_THAT(signals_, Eq(10011))
<< "expected that the starting, up.done and out.done signals are each recorded once";
}
WHEN("submit is applied and cancels the producer late") {
f |
op::submit(mi::MAKE(flow_receiver)(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
TEST_F(ImmediateFlowManySender, LateCancellation) {
make_producer() | op::submit(make_consumer([](auto up) {
// do not stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
::mi::set_value(up, 1);
})));
}));
THEN(
"the starting, up.value, value and done signals are each recorded once") {
REQUIRE(signals == 1000111);
}
EXPECT_THAT(signals_, Eq(1000111))
<< "expected that the starting, up.value, value and done signals are each recorded once";
}
using NT = decltype(mi::new_thread());
inline auto make_time(mi::time_source<>& t, NT& ex) {
return t.make(mi::systemNowF{}, [ex]() { return ex; })();
}
class ConcurrentFlowManySender : public Test {
protected:
using TNT = mi::invoke_result_t<decltype(make_time), mi::time_source<>&, NT&>;
void reset() {
at_ = mi::now(tnt_) + 100ms;
signals_ = 0;
terminal_ = 0;
cancel_ = 0;
}
void join() {
timeproduce_.join();
timecancel_.join();
}
}
SCENARIO("flow many cancellation new thread", "[flowmany][flow][sender]") {
auto nt = mi::new_thread();
using NT = decltype(nt);
auto time = mi::time_source<>{};
auto tnt = time.make(mi::systemNowF{}, [nt](){ return nt; })();
using TNT = decltype(tnt);
auto tcncl = time.make(mi::systemNowF{}, [nt](){ return nt; })();
std::atomic<int> signals{0};
auto at = mi::now(tnt) + 200ms;
GIVEN("A flow many sender") {
void cancellation_test(std::chrono::system_clock::time_point at) {
auto f = mi::MAKE(flow_many_sender)([&](auto out) {
using Out = decltype(out);
// boolean cancellation
struct producer {
producer(Out out, TNT tnt, bool s) : out(std::move(out)), tnt(std::move(tnt)), stop(s) {}
producer(Out out, TNT tnt, bool s)
: out(std::move(out)), tnt(std::move(tnt)), stop(s) {}
Out out;
TNT tnt;
std::atomic<bool> stop;
};
auto p = std::make_shared<producer>(std::move(out), tnt, false);
auto p = std::make_shared<producer>(std::move(out), tnt_, false);
struct Data : mi::receiver<> {
explicit Data(std::shared_ptr<producer> p) : p(std::move(p)) {}
......@@ -151,143 +164,121 @@ SCENARIO("flow many cancellation new thread", "[flowmany][flow][sender]") {
auto up = mi::MAKE(receiver)(
Data{p},
[&at, &signals](auto& data, auto requested) {
signals += 1000000;
if (requested < 1) {return;}
[&](auto& data, auto requested) {
signals_ += 1000000;
if (requested < 1) {
return;
}
// submit work to happen later
data.p->tnt |
op::submit_at(
at,
[p = data.p](auto) {
data.p->tnt | op::submit_at(at_, [p = data.p](auto) {
// check boolean to select signal
if (!p->stop) {
::mi::set_value(p->out, 42);
}
::mi::set_done(p->out);
}
});
},
[&signals](auto& data, auto e) noexcept {
signals += 100000;
[&](auto& data, auto) noexcept {
signals_ += 100000;
data.p->stop.store(true);
data.p->tnt | op::submit([p = data.p](auto) {
::mi::set_done(p->out);
});
data.p->tnt |
op::submit([p = data.p](auto) { ::mi::set_done(p->out); });
++cancel_;
},
[&signals](auto& data) {
signals += 10000;
[&](auto& data) {
signals_ += 10000;
data.p->stop.store(true);
data.p->tnt | op::submit([p = data.p](auto) {
::mi::set_done(p->out);
});
data.p->tnt |
op::submit([p = data.p](auto) { ::mi::set_done(p->out); });
++cancel_;
});
tnt |
op::submit([p, up = std::move(up)](auto tnt) mutable {
tnt_ | op::submit([p, sup = std::move(up)](auto) mutable {
// pass reference for cancellation.
::mi::set_starting(p->out, std::move(up));
::mi::set_starting(p->out, std::move(sup));
});
});
WHEN("submit is applied and cancels the producer early") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
op::submit(mi::MAKE(flow_receiver)(
mi::on_value([&](int) { signals_ += 100; }),
mi::on_error([&](auto) noexcept {
signals_ += 1000;
++terminal_;
}),
mi::on_done([&]() {
signals_ += 1;
++terminal_;
}),
// stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
mi::on_starting([&, at](auto up) {
signals_ += 10;
mi::set_value(up, 1);
tcncl |
op::submit_at(
at - 100ms, [up = std::move(up)](auto) mutable {
tcncl_ | op::submit_at(at, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
});
}));
}
// make sure that the completion signal arrives
std::this_thread::sleep_for(200ms);
})));
THEN(
"the starting, up.done and out.done signals are each recorded once") {
REQUIRE(signals == 1010011);
while (terminal_ == 0 || cancel_ == 0) {
std::this_thread::yield();
}
}
WHEN("submit is applied and cancels the producer late") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// do not stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
mi::set_value(up, 1);
tcncl |
op::submit_at(
at + 100ms, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
});
}));
}
NT ntproduce_{mi::new_thread()};
mi::time_source<> timeproduce_{};
TNT tnt_{make_time(timeproduce_, ntproduce_)};
std::this_thread::sleep_for(200ms);
NT ntcancel_{mi::new_thread()};
mi::time_source<> timecancel_{};
TNT tcncl_{make_time(timecancel_, ntcancel_)};
THEN(
"the starting, up.done and out.value signals are each recorded once") {
REQUIRE(signals == 1010111);
}
}
std::atomic<int> signals_{0};
std::atomic<int> terminal_{0};
std::atomic<int> cancel_{0};
std::chrono::system_clock::time_point at_{mi::now(tnt_) + 100ms};
};
TEST_F(ConcurrentFlowManySender, EarlyCancellation) {
// this nightmare brought to you by ASAN stack-use-after-return.
cancellation_test(at_ - 50ms);
join();
EXPECT_THAT(signals_, Eq(1010011))
<< "expected that the starting, up.done and out.done signals are each recorded once";
}
TEST_F(ConcurrentFlowManySender, LateCancellation) {
// this nightmare brought to you by ASAN stack-use-after-return.
cancellation_test(at_ + 50ms);
WHEN("submit is applied and cancels the producer at the same time") {
// count known results
join();
EXPECT_THAT(signals_, Eq(1010111))
<< "expected that the starting, up.done and out.value signals are each recorded once";
}
TEST_F(ConcurrentFlowManySender, RacingCancellation) {
int total = 0;
int cancellostrace = 0; // 1010111
int cancelled = 0; // 1010011
for (;;) {
signals = 0;
// set completion time to be in 100ms
at = mi::now(tnt) + 100ms;
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// stop producer at the same time that it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
mi::set_value(up, 1);
tcncl | op::submit_at(at, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
});
}));
}
// make sure any cancellation signal has completed
std::this_thread::sleep_for(200ms);
reset();
cancellation_test(at_);
// accumulate known signals
++total;
cancellostrace += signals == 1010111;
cancelled += signals == 1010011;
cancellostrace += signals_ == 1010111;
cancelled += signals_ == 1010011;
if (total != cancellostrace + cancelled) {
// display the unrecognized signals recorded
REQUIRE(signals == -1);
}
if (total >= 100) {
EXPECT_THAT(total, Eq(cancellostrace + cancelled))
<< signals_ << " <- this set of signals is unrecognized";
ASSERT_THAT(total, Lt(100))
// too long, abort and show the signals distribution
WARN(
"total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled);
break;
}
<< "total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled;
if (cancellostrace > 4 && cancelled > 4) {
// yay all known outcomes were observed!
break;
......@@ -295,25 +286,16 @@ SCENARIO("flow many cancellation new thread", "[flowmany][flow][sender]") {
// try again
continue;
}
}
time.join();
}
join();
}
SCENARIO("flow many from", "[flow][sender][for_each]") {
GIVEN("A flow many sender of 5 values") {
TEST(FlowManySender, From) {
auto v = std::array<int, 5>{0, 1, 2, 3, 4};
auto f = op::flow_from(v);
WHEN("for_each is applied") {
int actual = 0;
f | op::for_each(mi::MAKE(receiver)([&](int){++actual;}));
f | op::for_each(mi::MAKE(receiver)([&](int) { ++actual; }));
THEN("all the values are sent once") {
REQUIRE(actual == 5);
}
}
}
EXPECT_THAT(actual, Eq(5)) << "expexcted that all the values are sent once";
}
#endif
folly/experimental/pushmi/test/FlowTest.cpp
View file @ d58fe683
......@@ -29,7 +29,10 @@ using namespace std::literals;
using namespace folly::pushmi::aliases;
#if 0
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
using namespace testing;
#if __cpp_deduction_guides >= 201703
#define MAKE(x) x MAKE_
......@@ -39,11 +42,10 @@ using namespace folly::pushmi::aliases;
#define MAKE(x) make_##x
#endif
SCENARIO("flow single immediate cancellation", "[flow][sender]") {
int signals = 0;
GIVEN("A flow single sender") {
auto f = mi::MAKE(flow_single_sender)([&](auto out) {
class ImmediateFlowSingleSender : public Test {
protected:
auto make_producer() {
return mi::MAKE(flow_single_sender)([&](auto out) {
// boolean cancellation
bool stop = false;
auto set_stop = [](auto& stop) {
......@@ -60,13 +62,13 @@ SCENARIO("flow single immediate cancellation", "[flow][sender]") {
};
auto up = mi::MAKE(receiver)(
Data{std::move(tokens.second)},
[&](auto& data, auto e) noexcept {
signals += 100000;
[&](auto& data, auto) noexcept {
signals_ += 100000;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
},
mi::on_done([&](auto& data) {
signals += 10000;
signals_ += 10000;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
}));
......@@ -83,53 +85,69 @@ SCENARIO("flow single immediate cancellation", "[flow][sender]") {
::mi::set_done(out);
}
});
}
WHEN("submit is applied and cancels the producer") {
f |
op::submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
template <class F>
auto make_consumer(F f) {
return mi::MAKE(flow_receiver)(
mi::on_value([&](int) { signals_ += 100; }),
mi::on_error([&](auto) noexcept { signals_ += 1000; }),
mi::on_done([&]() { signals_ += 1; }),
mi::on_starting([&, f](auto up) {
signals_ += 10;
f(std::move(up));
}));
}
int signals_{0};
};
TEST_F(ImmediateFlowSingleSender, EarlyCancellation) {
make_producer() | op::submit(make_consumer([](auto up) {
// immediately stop producer
mi::on_starting([&](auto up) {
signals += 10;
::mi::set_done(up);
}));
THEN(
"the starting, up.done and out.done signals are each recorded once") {
REQUIRE(signals == 10011);
}
}
EXPECT_THAT(signals_, Eq(10011))
<< "expected that the starting, up.done and out.done signals are each recorded once";
}
WHEN("submit is applied and cancels the producer late") {
f |
op::submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
TEST_F(ImmediateFlowSingleSender, LateCancellation) {
make_producer() | op::submit(make_consumer([](auto) {
// do not stop producer before it is scheduled to run
mi::on_starting([&](auto up) { signals += 10; }));
}));
THEN(
"the starting and out.value signals are each recorded once") {
REQUIRE(signals == 110);
}
EXPECT_THAT(signals_, Eq(110))
<< "expected that the starting and out.value signals are each recorded once";
}
using NT = decltype(mi::new_thread());
inline auto make_time(mi::time_source<>& t, NT& ex) {
return t.make(mi::systemNowF{}, [ex]() { return ex; })();
}
class ConcurrentFlowSingleSender : public Test {
protected:
using TNT = mi::invoke_result_t<decltype(make_time), mi::time_source<>&, NT&>;
void reset() {
at_ = mi::now(tnt_) + 100ms;
signals_ = 0;
terminal_ = 0;
cancel_ = 0;
}
void join() {
timeproduce_.join();
timecancel_.join();
}
}
SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
auto nt = mi::new_thread();
using NT = decltype(nt);
auto time = mi::time_source<>{};
auto tnt = time.make(mi::systemNowF{}, [nt](){ return nt; })();
auto tcncl = time.make(mi::systemNowF{}, [nt](){ return nt; })();
std::atomic<int> signals{0};
auto at = mi::now(tnt) + 200ms;
GIVEN("A flow single sender") {
auto f = mi::MAKE(flow_single_sender)([&](auto out) {
template <class MakeTokens>
void cancellation_test(
std::chrono::system_clock::time_point at,
MakeTokens make_tokens) {
auto f = mi::MAKE(flow_single_sender)([&, make_tokens](auto out) {
// boolean cancellation
bool stop = false;
auto set_stop = [](auto& stop) {
......@@ -137,7 +155,7 @@ SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
*stop = true;
}
};
auto tokens = mi::shared_entangle(stop, set_stop);
auto tokens = make_tokens(stop, set_stop);
using Stopper = decltype(tokens.second);
struct Data : mi::receiver<> {
......@@ -146,30 +164,32 @@ SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
};
auto up = mi::MAKE(receiver)(
Data{std::move(tokens.second)},
[&](auto& data, auto e) noexcept {
signals += 100000;
[&](auto& data, auto) noexcept {
signals_ += 100000;
++cancel_;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
},
mi::on_done([&](auto& data) {
signals += 10000;
signals_ += 10000;
++cancel_;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
}));
// make all the signals come from the same thread
tnt |
op::submit([stoppee = std::move(tokens.first),
up = std::move(up),
out = std::move(out),
at](auto tnt) mutable {
tnt_ |
op::submit([&,
stoppee = std::move(tokens.first),
up_not_a_shadow_howtoeven = std::move(up),
out = std::move(out)](auto tnt) mutable {
// pass reference for cancellation.
::mi::set_starting(out, std::move(up));
::mi::set_starting(out, std::move(up_not_a_shadow_howtoeven));
// submit work to happen later
tnt |
op::submit_at(
at,
at_,
[stoppee = std::move(stoppee),
out = std::move(out)](auto) mutable {
// check boolean to select signal
......@@ -185,103 +205,89 @@ SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
});
});
WHEN("submit is applied and cancels the producer early") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
op::submit(
mi::on_value([&](int) { signals_ += 100; }),
mi::on_error([&](auto) noexcept {
signals_ += 1000;
++terminal_;
}),
mi::on_done([&]() {
signals_ += 1;
++terminal_;
}),
// stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl |
op::submit_at(
at - 50ms, [up = std::move(up)](auto) mutable {
mi::on_starting([&, at](auto up) {
signals_ += 10;
tcncl_ | op::submit_at(at, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
});
}));
}
// make sure that the completion signal arrives
std::this_thread::sleep_for(100ms);
THEN(
"the starting, up.done and out.done signals are each recorded once") {
REQUIRE(signals == 10011);
while (terminal_ == 0 || cancel_ == 0) {
std::this_thread::yield();
}
}
WHEN("submit is applied and cancels the producer late") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// do not stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl |
op::submit_at(
at + 50ms, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
NT ntproduce_{mi::new_thread()};
mi::time_source<> timeproduce_{};
TNT tnt_{make_time(timeproduce_, ntproduce_)};
NT ntcancel_{mi::new_thread()};
mi::time_source<> timecancel_{};
TNT tcncl_{make_time(timecancel_, ntcancel_)};
std::atomic<int> signals_{0};
std::atomic<int> terminal_{0};
std::atomic<int> cancel_{0};
std::chrono::system_clock::time_point at_{mi::now(tnt_) + 100ms};
};
TEST_F(ConcurrentFlowSingleSender, EarlySharedCancellation) {
cancellation_test(at_ - 50ms, [](auto& stop, auto& set_stop) {
return mi::shared_entangle(stop, set_stop);
});
}));
}
std::this_thread::sleep_for(100ms);
join();
THEN(
"the starting, up.done, out.value and out.done signals are each recorded once") {
REQUIRE(signals == 10111);
}
}
EXPECT_THAT(signals_, Eq(10011));
}
WHEN("submit is applied and cancels the producer at the same time") {
// count known results
TEST_F(ConcurrentFlowSingleSender, LateSharedCancellation) {
cancellation_test(at_ + 50ms, [](auto& stop, auto& set_stop) {
return mi::shared_entangle(stop, set_stop);
});
join();
EXPECT_THAT(signals_, Eq(10111))
<< "expected that the starting, up.done, out.value and out.done signals are each recorded once";
}
TEST_F(ConcurrentFlowSingleSender, RacingSharedCancellation) {
int total = 0;
int cancellostrace = 0; // 10111
int cancelled = 0; // 10011
for (;;) {
signals = 0;
// set completion time to be in 100ms
at = mi::now(tnt) + 100ms;
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// stop producer at the same time that it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl | op::submit_at(at, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
reset();
cancellation_test(at_, [](auto& stop, auto& set_stop) {
return mi::shared_entangle(stop, set_stop);
});
}));
}
// make sure any cancellation signal has completed
std::this_thread::sleep_for(100ms);
// accumulate known signals
++total;
cancellostrace += signals == 10111;
cancelled += signals == 10011;
cancellostrace += signals_ == 10111;
cancelled += signals_ == 10011;
EXPECT_THAT(total, Eq(cancellostrace + cancelled))
<< signals_ << " <- this set of signals is unrecognized";
ASSERT_THAT(total, Lt(100))
// too long, show the signals distribution
<< "total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled;
if (total != cancellostrace + cancelled) {
// display the unrecognized signals recorded
REQUIRE(signals == -1);
}
if (total >= 100) {
// too long, abort and show the signals distribution
WARN(
"total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled);
break;
}
if (cancellostrace > 4 && cancelled > 4) {
// yay all known outcomes were observed!
break;
......@@ -289,175 +295,55 @@ SCENARIO("flow single shared cancellation new thread", "[flow][sender]") {
// try again
continue;
}
}
time.join();
}
join();
}
SCENARIO("flow single entangled cancellation new thread", "[flow][sender]") {
auto nt = mi::new_thread();
using NT = decltype(nt);
auto time = mi::time_source<>{};
auto tnt = time.make(mi::systemNowF{}, [nt](){ return nt; })();
auto tcncl = time.make(mi::systemNowF{}, [nt](){ return nt; })();
std::atomic<int> signals{0};
auto at = mi::now(tnt) + 200ms;
GIVEN("A flow single sender") {
auto f = mi::MAKE(flow_single_sender)([&](auto out) {
// boolean cancellation
bool stop = false;
auto set_stop = [](auto& stop) {
if (!!stop) {
*stop = true;
}
};
auto tokens = mi::entangle(stop, set_stop);
using Stopper = decltype(tokens.second);
struct Data : mi::receiver<> {
explicit Data(Stopper stopper) : stopper(std::move(stopper)) {}
Stopper stopper;
};
auto up = mi::MAKE(receiver)(
Data{std::move(tokens.second)},
[&](auto& data, auto e) noexcept {
signals += 100000;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
},
mi::on_done([&](auto& data) {
signals += 10000;
auto both = lock_both(data.stopper);
(*(both.first))(both.second);
}));
// make all the signals come from the same thread
tnt |
op::submit([stoppee = std::move(tokens.first),
up = std::move(up),
out = std::move(out),
at](auto tnt) mutable {
// pass reference for cancellation.
::mi::set_starting(out, std::move(up));
// submit work to happen later
tnt |
op::submit_at(
at,
[stoppee = std::move(stoppee),
out = std::move(out)](auto) mutable {
// check boolean to select signal
auto both = lock_both(stoppee);
if (!!both.first && !*(both.first)) {
::mi::set_value(out, 42);
::mi::set_done(out);
} else {
// cancellation is not an error
::mi::set_done(out);
}
});
TEST_F(ConcurrentFlowSingleSender, EarlyEntangledCancellation) {
cancellation_test(at_ - 50ms, [](auto& stop, auto& set_stop) {
return mi::entangle(stop, set_stop);
});
});
WHEN("submit is applied and cancels the producer early") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl |
op::submit_at(
at - 50ms, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
});
}));
}
// make sure that the completion signal arrives
std::this_thread::sleep_for(100ms);
join();
THEN(
"the starting, up.done and out.done signals are each recorded once") {
REQUIRE(signals == 10011);
}
}
EXPECT_THAT(signals_, Eq(10011));
}
WHEN("submit is applied and cancels the producer late") {
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// do not stop producer before it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl |
op::submit_at(
at + 50ms, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
TEST_F(ConcurrentFlowSingleSender, LateEntangledCancellation) {
cancellation_test(at_ + 50ms, [](auto& stop, auto& set_stop) {
return mi::entangle(stop, set_stop);
});
}));
}
std::this_thread::sleep_for(100ms);
join();
THEN(
"the starting, up.done, out.value and out.done signals are each recorded once") {
REQUIRE(signals == 10111);
}
}
EXPECT_THAT(signals_, Eq(10111))
<< "expected that the starting, up.done, out.value and out.done signals are each recorded once";
}
WHEN("submit is applied and cancels the producer at the same time") {
// count known results
TEST_F(ConcurrentFlowSingleSender, RacingEntangledCancellation) {
int total = 0;
int cancellostrace = 0; // 10111
int cancelled = 0; // 10011
for (;;) {
signals = 0;
// set completion time to be in 100ms
at = mi::now(tnt) + 100ms;
{
f |
op::blocking_submit(
mi::on_value([&](int) { signals += 100; }),
mi::on_error([&](auto) noexcept { signals += 1000; }),
mi::on_done([&]() { signals += 1; }),
// stop producer at the same time that it is scheduled to run
mi::on_starting([&](auto up) {
signals += 10;
tcncl | op::submit_at(at, [up = std::move(up)](auto) mutable {
::mi::set_done(up);
reset();
cancellation_test(at_, [](auto& stop, auto& set_stop) {
return mi::entangle(stop, set_stop);
});
}));
}
// make sure any cancellation signal has completed
std::this_thread::sleep_for(200ms);
// accumulate known signals
++total;
cancellostrace += signals == 10111;
cancelled += signals == 10011;
cancellostrace += signals_ == 10111;
cancelled += signals_ == 10011;
EXPECT_THAT(total, Eq(cancellostrace + cancelled))
<< signals_ << " <- this set of signals is unrecognized";
ASSERT_THAT(total, Lt(100))
// too long, show the signals distribution
<< "total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled;
if (total != cancellostrace + cancelled) {
// display the unrecognized signals recorded
REQUIRE(signals == -1);
}
if (total >= 100) {
// too long, abort and show the signals distribution
WARN(
"total " << total << ", cancel-lost-race " << cancellostrace
<< ", cancelled " << cancelled);
break;
}
if (cancellostrace > 4 && cancelled > 4) {
// yay all known outcomes were observed!
break;
......@@ -465,9 +351,6 @@ SCENARIO("flow single entangled cancellation new thread", "[flow][sender]") {
// try again
continue;
}
}
time.join();
}
join();
}
#endif
folly/experimental/pushmi/test/NewThreadTest.cpp
View file @ d58fe683
......@@ -21,24 +21,29 @@ using namespace std::literals;
#include <folly/experimental/pushmi/flow_single_sender.h>
#include <folly/experimental/pushmi/o/empty.h>
#include <folly/experimental/pushmi/o/extension_operators.h>
#include <folly/experimental/pushmi/o/just.h>
#include <folly/experimental/pushmi/o/on.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/tap.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/o/via.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/extension_operators.h>
#include <folly/experimental/pushmi/new_thread.h>
#include <folly/experimental/pushmi/time_source.h>
#include <folly/experimental/pushmi/strand.h>
#include <folly/experimental/pushmi/time_source.h>
using namespace folly::pushmi::aliases;
#if 0
#include <folly/Conv.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
using namespace testing;
struct countdownsingle {
countdownsingle(int& c)
: counter(&c) {}
explicit countdownsingle(int& c) : counter(&c) {}
int* counter;
......@@ -50,115 +55,113 @@ struct countdownsingle {
}
};
SCENARIO( "new_thread executor", "[new_thread][sender]" ) {
using NT = decltype(mi::new_thread());
inline auto make_time(mi::time_source<>& t, NT& ex) {
return t.make(mi::systemNowF{}, [ex]() { return ex; })();
}
GIVEN( "A new_thread time_single_sender" ) {
auto nt = v::new_thread();
using NT = decltype(nt);
class NewthreadExecutor : public Test {
public:
~NewthreadExecutor() override {
time_.join();
}
auto time = mi::time_source<>{};
protected:
using TNT = mi::invoke_result_t<decltype(make_time), mi::time_source<>&, NT&>;
auto tnt = time.make(mi::systemNowF{}, [nt](){ return nt; })();
NT nt_{mi::new_thread()};
mi::time_source<> time_{};
TNT tnt_{make_time(time_, nt_)};
};
WHEN( "blocking submit now" ) {
TEST_F(NewthreadExecutor, BlockingSubmitNow) {
auto signals = 0;
auto start = v::now(tnt);
auto start = v::now(tnt_);
auto signaled = start;
tnt |
op::transform([](auto tnt){ return tnt | ep::now(); }) |
tnt_ | op::transform([](auto tnt) { return tnt | ep::now(); }) |
op::blocking_submit(
[&](auto at){
[&](auto at) {
signaled = at;
signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
THEN( "the value and done signals are recorded once and the value signal did not drift much" ) {
REQUIRE( signals == 110 );
auto delay = std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start)).count();
INFO("The delay is " << ::Catch::Detail::stringify(delay));
REQUIRE( delay < 1000 );
}
}
signals += 100;
},
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
EXPECT_THAT(signals, Eq(110))
<< "expected that the value and done signals are recorded once and the value signal did not drift much";
auto delay =
std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start))
.count();
EXPECT_THAT(delay, Lt(1000)) << "The delay is " << delay;
}
WHEN( "blocking get now" ) {
auto start = v::now(tnt);
auto signaled = tnt |
op::transform([](auto tnt){
return v::now(tnt);
}) |
TEST_F(NewthreadExecutor, BlockingGetNow) {
auto start = v::now(tnt_);
auto signaled = tnt_ | op::transform([](auto tnt) { return v::now(tnt); }) |
op::get<std::chrono::system_clock::time_point>;
THEN( "the signal did not drift much" ) {
auto delay = std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start)).count();
INFO("The delay is " << ::Catch::Detail::stringify(delay));
REQUIRE( delay < 1000 );
}
}
auto delay =
std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start))
.count();
WHEN( "submissions are ordered in time" ) {
EXPECT_THAT(delay, Lt(1000)) << "The delay is " << delay;
}
TEST_F(NewthreadExecutor, SubmissionsAreOrderedInTime) {
std::vector<std::string> times;
std::atomic<int> pushed(0);
std::atomic<int> pushed{0};
auto push = [&](int time) {
return v::on_value([&, time](auto) { times.push_back(std::to_string(time)); ++pushed; });
return v::on_value([&, time](auto) {
times.push_back(folly::to<std::string>(time));
++pushed;
});
};
tnt | op::submit(v::on_value([push](auto tnt) {
tnt_ | op::submit(v::on_value([push](auto tnt) {
auto now = tnt | ep::now();
tnt |
op::submit_after(40ms, push(40)) |
op::submit_at(now + 10ms, push(10)) |
op::submit_after(20ms, push(20)) |
tnt | op::submit_after(40ms, push(40)) |
op::submit_at(now + 10ms, push(10)) | op::submit_after(20ms, push(20)) |
op::submit_at(now + 10ms, push(11));
}));
while(pushed.load() < 4) { std::this_thread::sleep_for(10ms); }
THEN( "the items were pushed in time order not insertion order" ) {
REQUIRE( times == std::vector<std::string>{"10", "11", "20", "40"});
}
while (pushed.load() < 4) {
std::this_thread::yield();
}
WHEN( "now is called" ) {
EXPECT_THAT(times, ElementsAre("10", "11", "20", "40"))
<< "expected that the items were pushed in time order not insertion order";
}
TEST_F(NewthreadExecutor, NowIsCalled) {
bool done = false;
tnt | ep::now();
tnt | op::blocking_submit([&](auto tnt) {
tnt_ | ep::now();
tnt_ | op::blocking_submit([&](auto tnt) {
tnt | ep::now();
done = true;
});
THEN( "both calls to now() complete" ) {
REQUIRE( done == true );
}
}
EXPECT_THAT(done, Eq(true)) << "exptected that both calls to now() complete";
}
WHEN( "blocking submit" ) {
TEST_F(NewthreadExecutor, BlockingSubmit) {
auto signals = 0;
nt |
op::transform([](auto){ return 42; }) |
nt_ | op::transform([](auto) { return 42; }) |
op::blocking_submit(
[&](auto){
signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
[&](auto) { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
THEN( "the value and done signals are recorded once" ) {
REQUIRE( signals == 110 );
}
}
EXPECT_THAT(signals, Eq(110))
<< "the value and done signals are recorded once";
}
WHEN( "blocking get" ) {
auto v = nt |
op::transform([](auto){
return 42;
}) |
op::get<int>;
TEST_F(NewthreadExecutor, BlockingGet) {
auto v = nt_ | op::transform([](auto) { return 42; }) | op::get<int>;
THEN( "the result is" ) {
REQUIRE( v == 42 );
}
}
EXPECT_THAT(v, Eq(42)) << "expected that the result would be different";
}
WHEN( "virtual derecursion is triggered" ) {
TEST_F(NewthreadExecutor, VirtualDerecursion) {
int counter = 100'000;
std::function<void(::folly::pushmi::any_executor_ref<> exec)> recurse;
recurse = [&](::folly::pushmi::any_executor_ref<> nt) {
......@@ -166,23 +169,22 @@ SCENARIO( "new_thread executor", "[new_thread][sender]" ) {
return;
nt | op::submit(recurse);
};
nt | op::blocking_submit([&](auto nt) { recurse(nt); });
nt_ | op::blocking_submit([&](auto nt) { recurse(nt); });
THEN( "all nested submissions complete" ) {
REQUIRE( counter == 0 );
}
}
EXPECT_THAT(counter, Eq(0))
<< "expected that all nested submissions complete";
}
WHEN( "static derecursion is triggered" ) {
TEST_F(NewthreadExecutor, StaticDerecursion) {
int counter = 100'000;
countdownsingle single{counter};
nt | op::blocking_submit(single);
THEN( "all nested submissions complete" ) {
REQUIRE( counter == 0 );
}
}
nt_ | op::blocking_submit(single);
WHEN( "used with on" ) {
EXPECT_THAT(counter, Eq(0))
<< "expected that all nested submissions complete";
}
TEST_F(NewthreadExecutor, UsedWithOn) {
std::vector<std::string> values;
auto sender = ::folly::pushmi::make_single_sender([](auto out) {
::folly::pushmi::set_value(out, 2.0);
......@@ -192,14 +194,15 @@ SCENARIO( "new_thread executor", "[new_thread][sender]" ) {
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
});
sender | op::on([&](){return nt;}) |
op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
THEN( "only the first item was pushed" ) {
REQUIRE(values == std::vector<std::string>{"2.000000"});
}
}
sender | op::on([&]() { return nt_; }) |
op::blocking_submit(v::on_value(
[&](auto v) { values.push_back(folly::to<std::string>(v)); }));
EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
<< "expected that only the first item was pushed";
}
WHEN( "used with via" ) {
TEST_F(NewthreadExecutor, UsedWithVia) {
std::vector<std::string> values;
auto sender = ::folly::pushmi::make_single_sender([](auto out) {
::folly::pushmi::set_value(out, 2.0);
......@@ -209,14 +212,10 @@ SCENARIO( "new_thread executor", "[new_thread][sender]" ) {
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
});
sender | op::via(mi::strands(nt)) |
op::blocking_submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
THEN( "only the first item was pushed" ) {
REQUIRE(values == std::vector<std::string>{"2.000000"});
}
}
sender | op::via(mi::strands(nt_)) |
op::blocking_submit(v::on_value(
[&](auto v) { values.push_back(folly::to<std::string>(v)); }));
time.join();
}
EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
<< "expected that only the first item was pushed";
}
#endif
folly/experimental/pushmi/test/PushmiTest.cpp
View file @ d58fe683
......@@ -29,140 +29,169 @@ using namespace std::literals;
#include <folly/experimental/pushmi/o/tap.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/trampoline.h>
#include <folly/experimental/pushmi/new_thread.h>
#include <folly/experimental/pushmi/trampoline.h>
using namespace folly::pushmi::aliases;
#if 0
SCENARIO( "empty can be used with tap and submit", "[empty][sender]" ) {
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
GIVEN( "An empty sender" ) {
using namespace testing;
TEST(EmptyNoArgSingleSender, TapAndSubmit) {
auto e = op::empty();
using E = decltype(e);
REQUIRE( v::SenderTo<E, v::any_receiver<>, v::is_single<>> );
EXPECT_THAT((v::SenderTo<E, v::any_receiver<>, v::is_single<>>), Eq(true))
<< "expected empty to return a single sender that can take an any_receiver";
WHEN( "tap and submit are applied" ) {
int signals = 0;
e |
op::tap(
[&](){ signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; }) |
[&]() { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; }) |
op::submit(
[&](){ signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
[&]() { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
THEN( "the done signal is recorded twice" ) {
REQUIRE( signals == 20 );
}
EXPECT_THAT(signals, Eq(20))
<< "expected the done signal to be recorded twice";
WHEN( "future_from is applied" ) {
REQUIRE_THROWS_AS(v::future_from(e).get(), std::future_error);
EXPECT_THROW(v::future_from(e).get(), std::future_error)
<< "expected future_error when future_from is applied";
THEN( "future_from(e) returns std::future<void>" ) {
REQUIRE( std::is_same<std::future<void>, decltype(v::future_from(e))>::value );
}
}
}
}
EXPECT_THAT(
(std::is_same<std::future<void>, decltype(v::future_from(e))>::value),
Eq(true))
<< "expected future_from(e) to return std::future<void>";
}
GIVEN( "An empty int single_sender" ) {
TEST(EmptyIntSingleSender, TapAndSubmit) {
auto e = op::empty<int>();
using E = decltype(e);
REQUIRE( v::SenderTo<E, v::any_receiver<std::exception_ptr, int>, v::is_single<>> );
WHEN( "tap and submit are applied" ) {
EXPECT_THAT(
(v::SenderTo<
E,
v::any_receiver<std::exception_ptr, int>,
v::is_single<>>),
Eq(true))
<< "expected empty to return a single sender that can take an any_receiver<int>";
int signals = 0;
e |
op::tap(
[&](auto v){ signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; }) |
[&](auto) { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; }) |
op::submit(
[&](auto v){ signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
THEN( "the done signal is recorded twice" ) {
REQUIRE( signals == 20 );
}
}
}
}
[&](auto) { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
EXPECT_THAT(signals, Eq(20))
<< "expected the done signal to be recorded twice";
SCENARIO( "just() can be used with transform and submit", "[just][sender]" ) {
EXPECT_THROW(v::future_from<int>(e).get(), std::future_error)
<< "expected future_error when future_from is applied";
GIVEN( "A just int single_sender" ) {
EXPECT_THAT(
(std::is_same<std::future<int>, decltype(v::future_from<int>(e))>::value),
Eq(true))
<< "expected future_from(e) to return std::future<void>";
}
TEST(JustIntSingleSender, TransformAndSubmit) {
auto j = op::just(20);
using J = decltype(j);
REQUIRE( v::SenderTo<J, v::any_receiver<std::exception_ptr, int>, v::is_single<>> );
EXPECT_THAT(
(v::SenderTo<
J,
v::any_receiver<std::exception_ptr, int>,
v::is_single<>>),
Eq(true))
<< "expected empty to return a single sender that can take an any_receiver<int>";
WHEN( "transform and submit are applied" ) {
int signals = 0;
int value = 0;
j |
op::transform(
[&](int v){ signals += 10000; return v + 1; },
[&](auto v){ std:abort(); return v; }) |
op::transform(
[&](int v){ signals += 10000; return v * 2; }) |
[&](int v) {
signals += 10000;
return v + 1;
},
[&](auto v) {
std::abort();
return v;
}) |
op::transform([&](int v) {
signals += 10000;
return v * 2;
}) |
op::submit(
[&](auto v){ value = v; signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
[&](auto v) {
value = v;
signals += 100;
},
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
EXPECT_THAT(signals, Eq(20110))
<< "expected that the transform signal is recorded twice and that the value and done signals once each";
THEN( "the transform signal is recorded twice, the value and done signals once and the result is correct" ) {
REQUIRE( signals == 20110 );
REQUIRE( value == 42 );
}
}
EXPECT_THAT(value, Eq(42)) << "expected a different result";
WHEN( "future_from<int> is applied" ) {
auto twenty = v::future_from<int>(j).get();
THEN( "the value signal is recorded once and the result is correct" ) {
REQUIRE( twenty == 20 );
REQUIRE( std::is_same<std::future<int>, decltype(v::future_from<int>(j))>::value );
}
}
}
}
EXPECT_THAT(twenty, Eq(20))
<< "expected a different result from future_from(e).get()";
SCENARIO( "from() can be used with transform and submit", "[from][sender]" ) {
EXPECT_THAT(
(std::is_same<std::future<int>, decltype(v::future_from<int>(j))>::value),
Eq(true))
<< "expected future_from(e) to return std::future<int>";
}
GIVEN( "A from int many_sender" ) {
int arr[] = {0, 9, 99};
TEST(FromIntManySender, TransformAndSubmit) {
std::array<int, 3> arr{0, 9, 99};
auto m = op::from(arr);
using M = decltype(m);
REQUIRE( v::SenderTo<M, v::any_receiver<std::exception_ptr, int>, v::is_many<>> );
EXPECT_THAT(
(v::SenderTo<M, v::any_receiver<std::exception_ptr, int>, v::is_many<>>),
Eq(true))
<< "expected empty to return a many sender that can take an any_receiver<int>";
WHEN( "transform and submit are applied" ) {
int signals = 0;
int value = 0;
m |
op::transform(
[&](int v){ signals += 10000; return v + 1; },
[&](auto v){ std:abort(); return v; }) |
op::transform(
[&](int v){ signals += 10000; return v * 2; }) |
[&](int v) {
signals += 10000;
return v + 1;
},
[&](auto v) {
std::abort();
return v;
}) |
op::transform([&](int v) {
signals += 10000;
return v * 2;
}) |
op::submit(
[&](auto v){ value += v; signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
[&](auto v) {
value += v;
signals += 100;
},
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
THEN( "the transform signal is recorded twice, the value signal once and the result is correct" ) {
REQUIRE( signals == 60310 );
REQUIRE( value == 222 );
}
}
EXPECT_THAT(signals, Eq(60310))
<< "expected that the transform signal is recorded six times and that the value signal three times and done signal once";
}
EXPECT_THAT(value, Eq(222)) << "expected a different result";
}
#endif
folly/experimental/pushmi/test/TrampolineTest.cpp
View file @ d58fe683
......@@ -21,23 +21,28 @@ using namespace std::literals;
#include <folly/experimental/pushmi/flow_single_sender.h>
#include <folly/experimental/pushmi/o/empty.h>
#include <folly/experimental/pushmi/o/extension_operators.h>
#include <folly/experimental/pushmi/o/just.h>
#include <folly/experimental/pushmi/o/on.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/tap.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/o/via.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/extension_operators.h>
#include <folly/experimental/pushmi/inline.h>
#include <folly/experimental/pushmi/trampoline.h>
using namespace folly::pushmi::aliases;
#if 0
#include <folly/Conv.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
using namespace testing;
struct countdownsingle {
countdownsingle(int& c)
: counter(&c) {}
explicit countdownsingle(int& c) : counter(&c) {}
int* counter;
......@@ -49,38 +54,32 @@ struct countdownsingle {
}
};
SCENARIO( "trampoline executor", "[trampoline][sender]" ) {
using TR = decltype(mi::trampoline());
GIVEN( "A trampoline single_sender" ) {
auto tr = v::trampoline();
using TR = decltype(tr);
class TrampolineExecutor : public Test {
protected:
TR tr_{mi::trampoline()};
};
WHEN( "submit" ) {
TEST_F(TrampolineExecutor, TransformAndSubmit) {
auto signals = 0;
tr |
op::transform([](auto){ return 42; }) |
tr_ | op::transform([](auto) { return 42; }) |
op::submit(
[&](auto){
signals += 100; },
[&](auto e) noexcept { signals += 1000; },
[&](){ signals += 10; });
[&](auto) { signals += 100; },
[&](auto) noexcept { signals += 1000; },
[&]() { signals += 10; });
THEN( "the value and done signals are each recorded once" ) {
REQUIRE( signals == 110 );
}
}
EXPECT_THAT(signals, Eq(110))
<< "expected that the value and done signals are each recorded once";
}
WHEN( "blocking get" ) {
auto v = tr |
op::transform([](auto){ return 42; }) |
op::get<int>;
TEST_F(TrampolineExecutor, BlockingGet) {
auto v = tr_ | op::transform([](auto) { return 42; }) | op::get<int>;
THEN( "the result is" ) {
REQUIRE( v == 42 );
}
}
EXPECT_THAT(v, Eq(42)) << "expected that the result would be different";
}
WHEN( "virtual derecursion is triggered" ) {
TEST_F(TrampolineExecutor, VirtualDerecursion) {
int counter = 100'000;
std::function<void(::folly::pushmi::any_executor_ref<> exec)> recurse;
recurse = [&](::folly::pushmi::any_executor_ref<> tr) {
......@@ -88,23 +87,22 @@ SCENARIO( "trampoline executor", "[trampoline][sender]" ) {
return;
tr | op::submit(recurse);
};
tr | op::submit([&](auto exec) { recurse(exec); });
tr_ | op::submit([&](auto exec) { recurse(exec); });
THEN( "all nested submissions complete" ) {
REQUIRE( counter == 0 );
}
}
EXPECT_THAT(counter, Eq(0))
<< "expected that all nested submissions complete";
}
WHEN( "static derecursion is triggered" ) {
TEST_F(TrampolineExecutor, StaticDerecursion) {
int counter = 100'000;
countdownsingle single{counter};
tr | op::submit(single);
THEN( "all nested submissions complete" ) {
REQUIRE( counter == 0 );
}
}
tr_ | op::submit(single);
EXPECT_THAT(counter, Eq(0))
<< "expected that all nested submissions complete";
}
WHEN( "used with on" ) {
TEST_F(TrampolineExecutor, UsedWithOn) {
std::vector<std::string> values;
auto sender = ::folly::pushmi::make_single_sender([](auto out) {
::folly::pushmi::set_value(out, 2.0);
......@@ -114,18 +112,23 @@ SCENARIO( "trampoline executor", "[trampoline][sender]" ) {
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
});
auto inlineon = sender | op::on([&](){return mi::inline_executor();});
inlineon |
op::submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
THEN( "only the first item was pushed" ) {
REQUIRE(values == std::vector<std::string>{"2.000000"});
}
THEN( "executor was not changed by on" ) {
REQUIRE(std::is_same<mi::executor_t<decltype(sender)>, mi::executor_t<decltype(inlineon)>>::value);
}
}
auto inlineon = sender | op::on([&]() { return mi::inline_executor(); });
inlineon | op::submit(v::on_value([&](auto v) {
values.push_back(folly::to<std::string>(v));
}));
EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
<< "expected that only the first item was pushed";
EXPECT_THAT(
(std::is_same<
mi::executor_t<decltype(sender)>,
mi::executor_t<decltype(inlineon)>>::value),
Eq(true))
<< "expected that executor was not changed by on";
}
WHEN( "used with via" ) {
TEST_F(TrampolineExecutor, UsedWithVia) {
std::vector<std::string> values;
auto sender = ::folly::pushmi::make_single_sender([](auto out) {
::folly::pushmi::set_value(out, 2.0);
......@@ -135,16 +138,18 @@ SCENARIO( "trampoline executor", "[trampoline][sender]" ) {
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
});
auto inlinevia = sender | op::via([&](){return mi::inline_executor();});
inlinevia |
op::submit(v::on_value([&](auto v) { values.push_back(std::to_string(v)); }));
THEN( "only the first item was pushed" ) {
REQUIRE(values == std::vector<std::string>{"2.000000"});
}
THEN( "executor was changed by via" ) {
REQUIRE(!std::is_same<mi::executor_t<decltype(sender)>, mi::executor_t<decltype(inlinevia)>>::value);
}
}
}
auto inlinevia = sender | op::via([&]() { return mi::inline_executor(); });
inlinevia | op::submit(v::on_value([&](auto v) {
values.push_back(folly::to<std::string>(v));
}));
EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
<< "expected that only the first item was pushed";
EXPECT_THAT(
(!std::is_same<
mi::executor_t<decltype(sender)>,
mi::executor_t<decltype(inlinevia)>>::value),
Eq(true))
<< "expected that executor was changed by via";
}
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment