300 lines
9.8 KiB
C++
300 lines
9.8 KiB
C++
|
#include "Promise.h"
|
||
|
|
#include <boost/test/unit_test.hpp>
|
||
|
|
#include <sstream>
|
||
|
|
#include <variant>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
static inline T waitForValue(const Promise<T> &promise, const T &initial) {
|
||
|
|
T value(initial);
|
||
|
|
promise.then([&](const T &res) { value = res; }).wait();
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
static inline T waitForValue(const Promise<void> &promise, const T &initial, const T &expected) {
|
||
|
|
T value(initial);
|
||
|
|
promise.then([&]() { value = expected; }).wait();
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(Then) {
|
||
|
|
std::vector<std::variant<int, std::string>> values;
|
||
|
|
auto input = Promise<int>::resolve(42);
|
||
|
|
auto output = input.then([&](int res) {
|
||
|
|
values.push_back(res);
|
||
|
|
return std::to_string(res + 1);
|
||
|
|
});
|
||
|
|
output.then([&](const std::string &res) { values.push_back(res); }).then([&]() { values.push_back(44); }).wait();
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(values.size(), 3);
|
||
|
|
BOOST_CHECK_EQUAL(std::get<int>(values[0]), 42);
|
||
|
|
BOOST_CHECK_EQUAL(std::get<std::string>(values[1]), "43");
|
||
|
|
BOOST_CHECK_EQUAL(std::get<int>(values[2]), 44);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(input.isFulfilled(), true);
|
||
|
|
BOOST_CHECK_EQUAL(output.isFulfilled(), true);
|
||
|
|
|
||
|
|
// auto p= new int;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenResolveAsync) {
|
||
|
|
std::thread thread;
|
||
|
|
auto promise = Promise<int>::resolve(42).then([&thread](int res) {
|
||
|
|
return Promise<std::string>{[&thread, res](const PromiseResolve<std::string> &resolve) {
|
||
|
|
thread = std::thread([resolve, res]() {
|
||
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
||
|
|
std::ostringstream oss;
|
||
|
|
oss << "foo" << res;
|
||
|
|
resolve(oss.str());
|
||
|
|
});
|
||
|
|
}};
|
||
|
|
});
|
||
|
|
|
||
|
|
std::string value;
|
||
|
|
promise.then([&](const std::string &res) { value = res; }).wait();
|
||
|
|
|
||
|
|
static_assert((std::is_same_v<decltype(promise), Promise<std::string>>));
|
||
|
|
BOOST_CHECK_EQUAL(value, "foo42");
|
||
|
|
BOOST_CHECK_EQUAL(promise.isFulfilled(), true);
|
||
|
|
|
||
|
|
if (thread.joinable()) {
|
||
|
|
thread.join();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenRejectSync) {
|
||
|
|
auto input = Promise<int>::resolve(42);
|
||
|
|
auto output = input.then([](int res) {
|
||
|
|
std::ostringstream oss;
|
||
|
|
oss << "foo" << res;
|
||
|
|
throw oss.str();
|
||
|
|
return 42;
|
||
|
|
});
|
||
|
|
|
||
|
|
std::string error;
|
||
|
|
output.then([&](int res) { error += "bar" + std::to_string(res); }).fail([&](const std::string &err) { error += err; }).wait();
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(error, "foo42");
|
||
|
|
BOOST_CHECK_EQUAL(input.isFulfilled(), true);
|
||
|
|
BOOST_CHECK_EQUAL(output.isRejected(), true);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenRejectAsync) {
|
||
|
|
std::thread thread;
|
||
|
|
auto p = Promise<int>::resolve(42).then([&thread](int res) {
|
||
|
|
return Promise<void>{[&thread, res](const PromiseResolve<void> &, const PromiseReject<void> &reject) {
|
||
|
|
thread = std::thread([reject, res]() {
|
||
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
||
|
|
std::ostringstream oss;
|
||
|
|
oss << "foo" << res;
|
||
|
|
reject(oss.str());
|
||
|
|
});
|
||
|
|
}};
|
||
|
|
});
|
||
|
|
|
||
|
|
static_assert((std::is_same_v<decltype(p), Promise<void>>));
|
||
|
|
|
||
|
|
std::string error;
|
||
|
|
p.fail([&](const std::string &err) { error = err; }).wait();
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(error, "foo42");
|
||
|
|
BOOST_CHECK_EQUAL(p.isRejected(), true);
|
||
|
|
|
||
|
|
if (thread.joinable()) {
|
||
|
|
thread.join();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenSkipResult) {
|
||
|
|
auto p = Promise<int>::resolve(42);
|
||
|
|
|
||
|
|
int value = -1;
|
||
|
|
p.then([&]() { value = 43; }).wait();
|
||
|
|
|
||
|
|
static_assert((std::is_same<decltype(p), Promise<int>>::value));
|
||
|
|
BOOST_CHECK_EQUAL(value, 43);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenNullHandler) {
|
||
|
|
{ // resolved
|
||
|
|
auto p = Promise<int>::resolve(42).then(nullptr);
|
||
|
|
|
||
|
|
int value;
|
||
|
|
p.then([&](const int &res) { value = res; }).wait();
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(value, 42);
|
||
|
|
BOOST_CHECK_EQUAL(p.isFulfilled(), true);
|
||
|
|
}
|
||
|
|
{ // rejected
|
||
|
|
auto p = Promise<int>::reject(std::string{"foo"}).then(nullptr);
|
||
|
|
|
||
|
|
std::string error;
|
||
|
|
p.fail([&](const std::string &err) {
|
||
|
|
error = err;
|
||
|
|
return 0;
|
||
|
|
}).wait();
|
||
|
|
BOOST_CHECK_EQUAL(error, "foo");
|
||
|
|
BOOST_CHECK_EQUAL(p.isRejected(), true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const float kRes = 0.42f;
|
||
|
|
const float kFail = -1.f;
|
||
|
|
|
||
|
|
float fnNoArg() {
|
||
|
|
return kRes;
|
||
|
|
}
|
||
|
|
|
||
|
|
float fnArgByVal(float v) {
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
float fnArgByRef(const float &v) {
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
class Klass {
|
||
|
|
public: // STATICS
|
||
|
|
static float kFnNoArg() {
|
||
|
|
return kRes;
|
||
|
|
}
|
||
|
|
static float kFnArgByVal(float v) {
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
static float kFnArgByRef(const float &v) {
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
public:
|
||
|
|
Klass(float v) : m_v{v} {
|
||
|
|
}
|
||
|
|
|
||
|
|
float fnNoArg() const {
|
||
|
|
return m_v;
|
||
|
|
}
|
||
|
|
float fnArgByVal(float v) const {
|
||
|
|
return v + m_v;
|
||
|
|
}
|
||
|
|
float fnArgByRef(const float &v) const {
|
||
|
|
return v + m_v;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
const float m_v;
|
||
|
|
};
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenFunctionPtrHandlers) {
|
||
|
|
{ // Global functions.
|
||
|
|
auto p0 = Promise<void>::resolve().then(&fnNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(&fnArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(&fnArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
{ // Static member functions.
|
||
|
|
auto p0 = Promise<void>::resolve().then(&Klass::kFnNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(&Klass::kFnArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(&Klass::kFnArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenStdFunctionHandlers) {
|
||
|
|
{ // lvalue.
|
||
|
|
std::function<float()> stdFnNoArg = fnNoArg;
|
||
|
|
std::function<float(float)> stdFnArgByVal = fnArgByVal;
|
||
|
|
std::function<float(const float &)> stdFnArgByRef = fnArgByRef;
|
||
|
|
|
||
|
|
auto p0 = Promise<void>::resolve().then(stdFnNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(stdFnArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(stdFnArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
{ // const lvalue.
|
||
|
|
const std::function<float()> stdFnNoArg = fnNoArg;
|
||
|
|
const std::function<float(float)> stdFnArgByVal = fnArgByVal;
|
||
|
|
const std::function<float(const float &)> stdFnArgByRef = fnArgByRef;
|
||
|
|
|
||
|
|
auto p0 = Promise<void>::resolve().then(stdFnNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(stdFnArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(stdFnArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
{ // rvalue.
|
||
|
|
auto p0 = Promise<void>::resolve().then(std::function<float()>{fnNoArg});
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(std::function<float(float)>{fnArgByVal});
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(std::function<float(const float &)>{fnArgByRef});
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenStdBindHandlers) {
|
||
|
|
using namespace std::placeholders;
|
||
|
|
|
||
|
|
const float val{42.f};
|
||
|
|
const Klass obj{val};
|
||
|
|
|
||
|
|
const std::function<float()> bindNoArg = std::bind(&Klass::fnNoArg, &obj);
|
||
|
|
const std::function<float(float)> bindArgByVal = std::bind(&Klass::fnArgByVal, &obj, _1);
|
||
|
|
const std::function<float(const float &)> bindArgByRef = std::bind(&Klass::fnArgByRef, &obj, _1);
|
||
|
|
|
||
|
|
auto p0 = Promise<void>::resolve().then(bindNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(bindArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(bindArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), val);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), val + kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), val + kRes);
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOST_AUTO_TEST_CASE(ThenLambdaHandlers) {
|
||
|
|
{ // lvalue.
|
||
|
|
auto lambdaNoArg = []() { return kRes; };
|
||
|
|
auto lambdaArgByVal = [](float v) { return v; };
|
||
|
|
auto lambdaArgByRef = [](const float &v) { return v; };
|
||
|
|
|
||
|
|
auto p0 = Promise<void>::resolve().then(lambdaNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(lambdaArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(lambdaArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
{ // const lvalue.
|
||
|
|
const auto lambdaNoArg = []() { return kRes; };
|
||
|
|
const auto lambdaArgByVal = [](float v) { return v; };
|
||
|
|
const auto lambdaArgByRef = [](const float &v) { return v; };
|
||
|
|
|
||
|
|
auto p0 = Promise<void>::resolve().then(lambdaNoArg);
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then(lambdaArgByVal);
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then(lambdaArgByRef);
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
{ // rvalue.
|
||
|
|
auto p0 = Promise<void>::resolve().then([]() { return kRes; });
|
||
|
|
auto p1 = Promise<float>::resolve(kRes).then([](float v) { return v; });
|
||
|
|
auto p2 = Promise<float>::resolve(kRes).then([](const float &v) { return v; });
|
||
|
|
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p0, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p1, kFail), kRes);
|
||
|
|
BOOST_CHECK_EQUAL(waitForValue(p2, kFail), kRes);
|
||
|
|
}
|
||
|
|
}
|