ystdlib-cpp/src/ystdlib/error_handling/test/test_Result.cpp at 77f0f921577738f9ad3c6ccc24045e184abccda5 · y-scope/ystdlib-cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <system_error>
#include <type_traits>

#include <ystdlib/error_handling/Result.hpp>

#include <catch2/catch_test_macros.hpp>

#include "types.hpp"

using ystdlib::error_handling::Result;
using ystdlib::error_handling::success;
using ystdlib::error_handling::test::BinaryErrorCode;
using ystdlib::error_handling::test::BinaryErrorCodeEnum;

namespace {
constexpr int cTestInt{123};
constexpr auto cVoidFunc = [](bool is_error) -> Result<void> {
    if (is_error) {
        return BinaryErrorCode{BinaryErrorCodeEnum::Failure};
    }
    return success();
};
constexpr auto cIntFunc = [](bool is_error) -> Result<int> {
    if (is_error) {
        return std::errc::bad_message;
    }
    return cTestInt;
};
}  // namespace

namespace ystdlib::error_handling::test {
TEST_CASE("test_result_void", "[error_handling][Result]") {
    auto const result_no_error{cVoidFunc(false)};
    REQUIRE_FALSE(result_no_error.has_error());
    REQUIRE(std::is_void_v<decltype(result_no_error.value())>);

    auto const result_has_error{cVoidFunc(true)};
    REQUIRE(result_has_error.has_error());
    REQUIRE(BinaryErrorCode{BinaryErrorCodeEnum::Failure} == result_has_error.error());
}

TEST_CASE("test_result_void_in_main", "[error_handling][Result]") {
    auto main_func = [&](bool is_error) -> Result<void> {
        YSTDLIB_ASSERT_NO_ERROR(cVoidFunc(is_error));
        return success();
    };
    auto const main_no_error{main_func(false)};
    REQUIRE_FALSE(main_no_error.has_error());
    REQUIRE(std::is_void_v<decltype(main_no_error.value())>);

    auto const main_has_error{main_func(true)};
    REQUIRE(main_has_error.has_error());
    REQUIRE((BinaryErrorCode{BinaryErrorCodeEnum::Failure} == main_has_error.error()));
}

TEST_CASE("test_result_int", "[error_handling][Result]") {
    auto const result_no_error{cIntFunc(false)};
    REQUIRE_FALSE(result_no_error.has_error());
    REQUIRE((cTestInt == result_no_error.value()));

    auto const result_has_error{cIntFunc(true)};
    REQUIRE(result_has_error.has_error());
    REQUIRE(std::errc::bad_message == result_has_error.error());
}

TEST_CASE("test_result_int_in_main", "[error_handling][Result]") {
    auto main_func = [&](bool is_error) -> Result<void> {
        YSTDLIB_ASSERT_NO_ERROR(cIntFunc(is_error));
        return success();
    };
    auto const main_no_error{main_func(false)};
    REQUIRE_FALSE(main_no_error.has_error());
    REQUIRE(std::is_void_v<decltype(main_no_error.value())>);

    auto const main_has_error{main_func(true)};
    REQUIRE(main_has_error.has_error());
    REQUIRE((std::errc::bad_message == main_has_error.error()));
}

TEST_CASE("test_result_int_propagate", "[error_handling][Result]") {
    auto main_func = [&](bool is_error) -> Result<int> { return YSTDLIB_TRY(cIntFunc(is_error)); };
    auto const main_no_error{main_func(false)};
    REQUIRE_FALSE(main_no_error.has_error());
    REQUIRE((cTestInt == main_no_error.value()));

    auto const main_has_error{main_func(true)};
    REQUIRE(main_has_error.has_error());
    REQUIRE((std::errc::bad_message == main_has_error.error()));
}
}  // namespace ystdlib::error_handling::test