mirror of
https://github.com/BlackMATov/promise.hpp.git
synced 2025-12-16 14:11:21 +07:00
new build scripts
This commit is contained in:
BlackMATov
356
untests/promise4_tests.cpp
Normal file
356
untests/promise4_tests.cpp
Normal file
@@ -0,0 +1,356 @@
|
||||
/*******************************************************************************
|
||||
* This file is part of the "https://github.com/blackmatov/promise.hpp"
|
||||
* For conditions of distribution and use, see copyright notice in LICENSE.md
|
||||
* Copyright (C) 2018-2023, by Matvey Cherevko (blackmatov@gmail.com)
|
||||
******************************************************************************/
|
||||
|
||||
#include <promise.hpp/promise.hpp>
|
||||
#include <doctest/doctest.h>
|
||||
|
||||
#include <array>
|
||||
#include <thread>
|
||||
#include <numeric>
|
||||
#include <cstring>
|
||||
|
||||
namespace pr = promise_hpp;
|
||||
|
||||
namespace
|
||||
{
|
||||
struct obj_t {
|
||||
};
|
||||
|
||||
bool check_hello_fail_exception(std::exception_ptr e) {
|
||||
try {
|
||||
std::rethrow_exception(e);
|
||||
} catch (std::logic_error& ee) {
|
||||
return 0 == std::strcmp(ee.what(), "hello fail");
|
||||
} catch (...) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
class auto_thread final {
|
||||
public:
|
||||
template < typename F, typename... Args >
|
||||
auto_thread(F&& f, Args&&... args)
|
||||
: thread_(std::forward<F>(f), std::forward<Args>(args)...) {}
|
||||
|
||||
~auto_thread() noexcept {
|
||||
if ( thread_.joinable() ) {
|
||||
thread_.join();
|
||||
}
|
||||
}
|
||||
|
||||
void join() {
|
||||
thread_.join();
|
||||
}
|
||||
private:
|
||||
std::thread thread_;
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("get_and_wait") {
|
||||
SUBCASE("get_void_promises") {
|
||||
{
|
||||
auto p = pr::make_resolved_promise();
|
||||
REQUIRE_NOTHROW(p.get());
|
||||
}
|
||||
{
|
||||
auto p = pr::make_rejected_promise<void>(std::logic_error("hello fail"));
|
||||
REQUIRE_THROWS_AS(p.get(), std::logic_error);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<void>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.resolve();
|
||||
}};
|
||||
t.join();
|
||||
REQUIRE_NOTHROW(p.get());
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<void>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.resolve();
|
||||
}};
|
||||
REQUIRE_NOTHROW(p.get());
|
||||
}
|
||||
{
|
||||
const auto time_now = [](){
|
||||
return std::chrono::high_resolution_clock::now();
|
||||
};
|
||||
|
||||
auto p1 = pr::make_resolved_promise();
|
||||
REQUIRE_NOTHROW(p1.wait());
|
||||
REQUIRE(p1.wait_for(std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p1.wait_for(std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p1.wait_until(time_now() + std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p1.wait_until(time_now() + std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
|
||||
|
||||
auto p2 = pr::make_resolved_promise<int>(5);
|
||||
REQUIRE_NOTHROW(p2.wait());
|
||||
REQUIRE(p2.wait_for(std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p2.wait_for(std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p2.wait_until(time_now() + std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p2.wait_until(time_now() + std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<void>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
p.resolve();
|
||||
}};
|
||||
REQUIRE(p.wait_for(
|
||||
std::chrono::milliseconds(5))
|
||||
== pr::promise_wait_status::timeout);
|
||||
REQUIRE(p.wait_for(
|
||||
std::chrono::milliseconds(200))
|
||||
== pr::promise_wait_status::no_timeout);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<void>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
p.resolve();
|
||||
}};
|
||||
REQUIRE(p.wait_until(
|
||||
std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5))
|
||||
== pr::promise_wait_status::timeout);
|
||||
REQUIRE(p.wait_until(
|
||||
std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(200))
|
||||
== pr::promise_wait_status::no_timeout);
|
||||
}
|
||||
}
|
||||
SUBCASE("get_typed_promises") {
|
||||
{
|
||||
auto p = pr::make_resolved_promise(42);
|
||||
REQUIRE(p.get() == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
|
||||
REQUIRE_THROWS_AS(p.get(), std::logic_error);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.resolve(42);
|
||||
}};
|
||||
t.join();
|
||||
REQUIRE(p.get() == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.resolve(42);
|
||||
}};
|
||||
REQUIRE(p.get() == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
p.resolve(42);
|
||||
}};
|
||||
REQUIRE(p.wait_for(
|
||||
std::chrono::milliseconds(5))
|
||||
== pr::promise_wait_status::timeout);
|
||||
REQUIRE(p.wait_for(
|
||||
std::chrono::milliseconds(200))
|
||||
== pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p.get() == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
||||
p.resolve(42);
|
||||
}};
|
||||
REQUIRE(p.wait_until(
|
||||
std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(5))
|
||||
== pr::promise_wait_status::timeout);
|
||||
REQUIRE(p.wait_until(
|
||||
std::chrono::high_resolution_clock::now() + std::chrono::milliseconds(200))
|
||||
== pr::promise_wait_status::no_timeout);
|
||||
REQUIRE(p.get() == 42);
|
||||
}
|
||||
}
|
||||
SUBCASE("get_or_default") {
|
||||
{
|
||||
auto p = pr::make_resolved_promise(42);
|
||||
REQUIRE(p.get_or_default(84) == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
|
||||
REQUIRE(p.get_or_default(84) == 84);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.resolve(42);
|
||||
}};
|
||||
REQUIRE(p.get_or_default(84) == 42);
|
||||
}
|
||||
{
|
||||
auto p = pr::promise<int>();
|
||||
auto_thread t{[p]() mutable {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(5));
|
||||
p.reject(std::logic_error("hello fail"));
|
||||
}};
|
||||
REQUIRE(p.get_or_default(84) == 84);
|
||||
}
|
||||
{
|
||||
auto p = pr::make_resolved_promise();
|
||||
REQUIRE_NOTHROW(p.get_or_default());
|
||||
}
|
||||
{
|
||||
auto p = pr::make_rejected_promise<void>(std::logic_error("hello fail"));
|
||||
REQUIRE_NOTHROW(p.get_or_default());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("promise_transformations") {
|
||||
{
|
||||
auto p_v = pr::promise<int>()
|
||||
.then([](int){});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_v)::value_type, void>::value,
|
||||
"unit test fail");
|
||||
|
||||
auto p_f = pr::promise<int>()
|
||||
.then([](int){return 1.f;});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_f)::value_type, float>::value,
|
||||
"unit test fail");
|
||||
|
||||
auto p_d = pr::promise<int>()
|
||||
.then([](int){return 1.f;})
|
||||
.then([](float){return 1.0;});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_d)::value_type, double>::value,
|
||||
"unit test fail");
|
||||
}
|
||||
{
|
||||
auto p_v = pr::promise<void>()
|
||||
.then([](){});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_v)::value_type, void>::value,
|
||||
"unit test fail");
|
||||
|
||||
auto p_f = pr::promise<void>()
|
||||
.then([](){return 1.f;});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_f)::value_type, float>::value,
|
||||
"unit test fail");
|
||||
|
||||
auto p_d = pr::promise<void>()
|
||||
.then([](){return 1.f;})
|
||||
.then([](float){return 1.0;});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_d)::value_type, double>::value,
|
||||
"unit test fail");
|
||||
}
|
||||
SUBCASE("after_except") {
|
||||
{
|
||||
auto p_v = pr::promise<int>()
|
||||
.then([](int)->int{
|
||||
throw std::logic_error("hello fail");
|
||||
})
|
||||
.except([](std::exception_ptr){
|
||||
return 0;
|
||||
});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_v)::value_type, int>::value,
|
||||
"unit test fail");
|
||||
}
|
||||
{
|
||||
auto p_v = pr::promise<int>()
|
||||
.then([](int)->int{
|
||||
throw std::logic_error("hello fail");
|
||||
})
|
||||
.except([](std::exception_ptr){
|
||||
return 0;
|
||||
});
|
||||
static_assert(
|
||||
std::is_same<decltype(p_v)::value_type, int>::value,
|
||||
"unit test fail");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("life_after_except") {
|
||||
{
|
||||
int check_42_int = 0;
|
||||
bool call_fail_with_logic_error = false;
|
||||
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
|
||||
p.then([](int v){
|
||||
return v;
|
||||
})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e){
|
||||
call_fail_with_logic_error = check_hello_fail_exception(e);
|
||||
return 42;
|
||||
})
|
||||
.then([&check_42_int](int value){
|
||||
check_42_int = value;
|
||||
});
|
||||
REQUIRE(check_42_int == 42);
|
||||
REQUIRE(call_fail_with_logic_error);
|
||||
}
|
||||
{
|
||||
int check_42_int = 0;
|
||||
bool call_fail_with_logic_error = false;
|
||||
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
|
||||
p.then([](int v){
|
||||
return v;
|
||||
})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e) -> int {
|
||||
call_fail_with_logic_error = check_hello_fail_exception(e);
|
||||
std::rethrow_exception(e);
|
||||
})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e){
|
||||
call_fail_with_logic_error = call_fail_with_logic_error && check_hello_fail_exception(e);
|
||||
return 42;
|
||||
})
|
||||
.then([&check_42_int](int value){
|
||||
check_42_int = value;
|
||||
});
|
||||
REQUIRE(check_42_int == 42);
|
||||
REQUIRE(call_fail_with_logic_error);
|
||||
}
|
||||
{
|
||||
bool call_then_after_except = false;
|
||||
bool call_fail_with_logic_error = false;
|
||||
auto p = pr::make_rejected_promise(std::logic_error("hello fail"));
|
||||
p.then([](){})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e){
|
||||
call_fail_with_logic_error = check_hello_fail_exception(e);
|
||||
})
|
||||
.then([&call_then_after_except](){
|
||||
call_then_after_except = true;
|
||||
});
|
||||
REQUIRE(call_then_after_except);
|
||||
REQUIRE(call_fail_with_logic_error);
|
||||
}
|
||||
{
|
||||
bool call_fail_with_logic_error = false;
|
||||
bool call_then_after_multi_except = false;
|
||||
auto p = pr::make_rejected_promise(std::logic_error("hello fail"));
|
||||
p.then([](){})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e){
|
||||
call_fail_with_logic_error = check_hello_fail_exception(e);
|
||||
std::rethrow_exception(e);
|
||||
})
|
||||
.except([&call_fail_with_logic_error](std::exception_ptr e){
|
||||
call_fail_with_logic_error = call_fail_with_logic_error && check_hello_fail_exception(e);
|
||||
})
|
||||
.then([&call_then_after_multi_except](){
|
||||
call_then_after_multi_except = true;
|
||||
});
|
||||
REQUIRE(call_fail_with_logic_error);
|
||||
REQUIRE(call_then_after_multi_except);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user