From 5d74bc02576b7239f47d0fc7b5495e78ba909a37 Mon Sep 17 00:00:00 2001 From: Corentin Schreiber Date: Sat, 22 Oct 2022 15:08:29 +0100 Subject: [PATCH 1/4] Testing Boost UT --- tests/CMakeLists.txt | 4 +- tests/runtime_tests_lifetime.cpp | 490 +++++++------- tests/runtime_tests_make_observable.cpp | 174 ++--- ...runtime_tests_observer_assignment_copy.cpp | 330 +++++----- ...e_tests_observer_assignment_from_owner.cpp | 270 ++++---- ...runtime_tests_observer_assignment_move.cpp | 316 ++++----- tests/runtime_tests_observer_cast_copy.cpp | 309 +++++---- tests/runtime_tests_observer_cast_move.cpp | 307 +++++---- tests/runtime_tests_observer_comparison.cpp | 217 +++--- tests/runtime_tests_observer_construction.cpp | 42 +- ...ntime_tests_observer_construction_copy.cpp | 266 ++++---- ...tests_observer_construction_from_owner.cpp | 173 ++--- ...ntime_tests_observer_construction_move.cpp | 270 ++++---- tests/runtime_tests_observer_from_this.cpp | 621 +++++++++--------- tests/runtime_tests_observer_misc.cpp | 392 +++++------ tests/runtime_tests_owner_assignment_move.cpp | 334 +++++----- tests/runtime_tests_owner_cast_move.cpp | 302 +++++---- tests/runtime_tests_owner_comparison.cpp | 115 ++-- tests/runtime_tests_owner_construction.cpp | 393 +++++------ tests/runtime_tests_owner_misc.cpp | 479 +++++++------- tests/testing.cpp | 6 + tests/testing.hpp | 52 +- tests/tests_common.hpp | 23 +- 23 files changed, 3087 insertions(+), 2798 deletions(-) create mode 100644 tests/testing.cpp diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index e14920f..49b9f98 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -37,6 +37,7 @@ FetchContent_Declare(snatch FetchContent_MakeAvailable(snatch) set(RUNTIME_TEST_FILES + ${PROJECT_SOURCE_DIR}/tests/testing.cpp ${PROJECT_SOURCE_DIR}/tests/tests_common.cpp ${PROJECT_SOURCE_DIR}/tests/memory_tracker.cpp ${PROJECT_SOURCE_DIR}/tests/runtime_tests_owner_misc.cpp @@ -61,7 +62,8 @@ set(RUNTIME_TEST_FILES add_executable(oup_runtime_tests ${RUNTIME_TEST_FILES}) target_link_libraries(oup_runtime_tests PRIVATE oup::oup) -target_link_libraries(oup_runtime_tests PRIVATE snatch::snatch) +# target_link_libraries(oup_runtime_tests PRIVATE snatch::snatch) +target_include_directories(oup_runtime_tests PRIVATE "/home/cschreib/programming/ut/include") add_platform_definitions(oup_runtime_tests) add_custom_target(oup_runtime_tests_run diff --git a/tests/runtime_tests_lifetime.cpp b/tests/runtime_tests_lifetime.cpp index cf3a55c..90e7bf1 100644 --- a/tests/runtime_tests_lifetime.cpp +++ b/tests/runtime_tests_lifetime.cpp @@ -4,34 +4,10 @@ #include -TEMPLATE_LIST_TEST_CASE("observer expiring scope", "[lifetime][owner][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr; - { - TestType ptr = make_pointer_deleter_1(); - auto* ptr_raw = ptr.get(); - optr = ptr; - - CHECK(optr.get() == ptr_raw); - CHECK(!optr.expired()); - } - - CHECK(optr.get() == nullptr); - CHECK(optr.expired()); - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer not expiring when owner moved", "[lifetime][owner][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE("observer expiring scope", "[lifetime][owner][observer]", owner_types) { + memory_tracker mem_track; - { - TestType outer_ptr; { observer_ptr optr; { @@ -41,308 +17,344 @@ TEMPLATE_LIST_TEST_CASE( CHECK(optr.get() == ptr_raw); CHECK(!optr.expired()); - - outer_ptr = std::move(ptr); - - CHECK(optr.get() == ptr_raw); - CHECK(!optr.expired()); - CHECK_INSTANCES(1, 2); } - CHECK(optr.get() == outer_ptr.get()); - CHECK(!optr.expired()); - CHECK_INSTANCES(1, 1); + CHECK(optr.get() == nullptr); + CHECK(optr.expired()); + CHECK_INSTANCES(0, 0); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer not expiring when owner moved", "[lifetime][owner][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer expiring reset", "[lifetime][owner][observer]", owner_types) { - memory_tracker mem_track; + { + TestType outer_ptr; + { + observer_ptr optr; + { + TestType ptr = make_pointer_deleter_1(); + auto* ptr_raw = ptr.get(); + optr = ptr; - { - observer_ptr optr; - TestType ptr = make_pointer_deleter_1(); - auto* ptr_raw = ptr.get(); + CHECK(optr.get() == ptr_raw); + CHECK(!optr.expired()); - optr = ptr; + outer_ptr = std::move(ptr); - CHECK(optr.get() == ptr_raw); - CHECK(!optr.expired()); + CHECK(optr.get() == ptr_raw); + CHECK(!optr.expired()); + CHECK_INSTANCES(1, 2); + } - ptr.reset(); + CHECK(optr.get() == outer_ptr.get()); + CHECK(!optr.expired()); + CHECK_INSTANCES(1, 1); + } - CHECK(optr.get() == nullptr); - CHECK(optr.expired()); - CHECK_INSTANCES(0, 1); - } + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "release valid owner with observer", "[lifetime][release][owner][observer]", owner_types) { - if constexpr (!is_sealed) { + TEMPLATE_LIST_TEST_CASE("observer expiring reset", "[lifetime][owner][observer]", owner_types) { memory_tracker mem_track; { observer_ptr optr; - { - TestType ptr = make_pointer_deleter_1(); - auto* ptr_raw = ptr.get(); + TestType ptr = make_pointer_deleter_1(); + auto* ptr_raw = ptr.get(); - optr = ptr; + optr = ptr; - CHECK(optr.get() == ptr_raw); - CHECK(!optr.expired()); - - auto* ptr_released = ptr.release(); - - CHECK(ptr_released == ptr_raw); - CHECK(ptr.get() == nullptr); - if constexpr (has_eoft) { - CHECK(optr.get() != nullptr); - CHECK(!optr.expired()); - } else { - CHECK(optr.get() == nullptr); - CHECK(optr.expired()); - } - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(1, 1); + CHECK(optr.get() == ptr_raw); + CHECK(!optr.expired()); - delete ptr_released; - } + ptr.reset(); CHECK(optr.get() == nullptr); CHECK(optr.expired()); - CHECK_INSTANCES(0, 0); + CHECK_INSTANCES(0, 1); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "release valid owner with observer subobject", - "[lifetime][release][owner][observer]", - owner_types) { - if constexpr (!is_sealed) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "release valid owner with observer", "[lifetime][release][owner][observer]", owner_types) { + if constexpr (!is_sealed) { + memory_tracker mem_track; - { - state_observer_ptr optr; { - TestType ptr = make_pointer_deleter_1(); - auto* ptr_raw = ptr.get(); + observer_ptr optr; + { + TestType ptr = make_pointer_deleter_1(); + auto* ptr_raw = ptr.get(); - optr = state_observer_ptr{ptr, &ptr->state_}; - CHECK(optr.get() == &ptr_raw->state_); - CHECK(!optr.expired()); + optr = ptr; - auto* ptr_released = ptr.release(); - CHECK(ptr_released == ptr_raw); - CHECK(ptr.get() == nullptr); - if constexpr (has_eoft) { - CHECK(optr.get() != nullptr); + CHECK(optr.get() == ptr_raw); CHECK(!optr.expired()); - } else { - CHECK(optr.get() == nullptr); - CHECK(optr.expired()); - } - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + + auto* ptr_released = ptr.release(); + + CHECK(ptr_released == ptr_raw); + CHECK(ptr.get() == nullptr); + if constexpr (has_eoft) { + CHECK(optr.get() != nullptr); + CHECK(!optr.expired()); + } else { + CHECK(optr.get() == nullptr); + CHECK(optr.expired()); + } + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); + + delete ptr_released; } - CHECK_INSTANCES(1, 1); - delete ptr_released; + CHECK(optr.get() == nullptr); + CHECK(optr.expired()); + CHECK_INSTANCES(0, 0); } - CHECK(optr.get() == nullptr); - CHECK(optr.expired()); - CHECK_INSTANCES(0, 0); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer get and raw get", "[lifetime][get][raw_get][owner][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "release valid owner with observer subobject", "[lifetime][release][owner][observer]", + owner_types) { + if constexpr (!is_sealed) { + memory_tracker mem_track; - { - observer_ptr optr; - - CHECK(optr.raw_get() == nullptr); - CHECK(optr.get() == nullptr); + { + state_observer_ptr optr; + { + TestType ptr = make_pointer_deleter_1(); + auto* ptr_raw = ptr.get(); - TestType ptr = make_pointer_deleter_1(); - optr = ptr; + optr = state_observer_ptr{ptr, &ptr->state_}; + CHECK(optr.get() == &ptr_raw->state_); + CHECK(!optr.expired()); - CHECK(optr.raw_get() == ptr.get()); - CHECK(optr.get() == ptr.get()); + auto* ptr_released = ptr.release(); + CHECK(ptr_released == ptr_raw); + CHECK(ptr.get() == nullptr); + if constexpr (has_eoft) { + CHECK(optr.get() != nullptr); + CHECK(!optr.expired()); + } else { + CHECK(optr.get() == nullptr); + CHECK(optr.expired()); + } + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); + + delete ptr_released; + } - get_object* raw_ptr = ptr.get(); - ptr.reset(); + CHECK(optr.get() == nullptr); + CHECK(optr.expired()); + CHECK_INSTANCES(0, 0); + } - CHECK(optr.raw_get() == raw_ptr); - CHECK(optr.get() == nullptr); + CHECK_NO_LEAKS; + } } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "object owning observer pointer to itself", - "[lifetime][cycles][owner][observer]", - owner_types) { - if constexpr (is_cyclic) { + TEMPLATE_LIST_TEST_CASE( + "observer get and raw get", "[lifetime][get][raw_get][owner][observer]", owner_types) { memory_tracker mem_track; { + observer_ptr optr; + + CHECK(optr.raw_get() == nullptr); + CHECK(optr.get() == nullptr); + TestType ptr = make_pointer_deleter_1(); - ptr->obs = ptr; + optr = ptr; - CHECK_INSTANCES(1, 1); + CHECK(optr.raw_get() == ptr.get()); + CHECK(optr.get() == ptr.get()); + + get_object* raw_ptr = ptr.get(); + ptr.reset(); + + CHECK(optr.raw_get() == raw_ptr); + CHECK(optr.get() == nullptr); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "object owning observer pointer to other", "[lifetime][cycles][owner][observer]", owner_types) { - if constexpr (is_cyclic) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "object owning observer pointer to itself", "[lifetime][cycles][owner][observer]", + owner_types) { + if constexpr (is_cyclic) { + memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - ptr1->obs = ptr2; - ptr2->obs = ptr1; + { + TestType ptr = make_pointer_deleter_1(); + ptr->obs = ptr; - CHECK_INSTANCES(2, 2); - } + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "object owning observer pointer open chain", - "[lifetime][cycles][owner][observer]", - owner_types) { - if constexpr (is_cyclic) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "object owning observer pointer to other", "[lifetime][cycles][owner][observer]", + owner_types) { + if constexpr (is_cyclic) { + memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - TestType ptr3 = make_pointer_deleter_1(); - ptr1->obs = ptr2; - ptr2->obs = ptr3; + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + ptr1->obs = ptr2; + ptr2->obs = ptr1; - CHECK_INSTANCES(3, 3); - } + CHECK_INSTANCES(2, 2); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "object owning observer pointer open chain reversed", - "[lifetime][cycles][owner][observer]", - owner_types) { - if constexpr (is_cyclic) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "object owning observer pointer open chain", "[lifetime][cycles][owner][observer]", + owner_types) { + if constexpr (is_cyclic) { + memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - TestType ptr3 = make_pointer_deleter_1(); - ptr3->obs = ptr2; - ptr2->obs = ptr1; + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + TestType ptr3 = make_pointer_deleter_1(); + ptr1->obs = ptr2; + ptr2->obs = ptr3; - CHECK_INSTANCES(3, 3); - } + CHECK_INSTANCES(3, 3); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "object owning observer pointer closed chain interleaved", - "[lifetime][cycles][owner][observer]", - owner_types) { - if constexpr (is_cyclic) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "object owning observer pointer open chain reversed", "[lifetime][cycles][owner][observer]", + owner_types) { + if constexpr (is_cyclic) { + memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - TestType ptr3 = make_pointer_deleter_1(); - TestType ptr4 = make_pointer_deleter_2(); - ptr1->obs = ptr2; - ptr2->obs = ptr4; - ptr3->obs = ptr1; - ptr4->obs = ptr3; - - CHECK_INSTANCES(4, 4); + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + TestType ptr3 = make_pointer_deleter_1(); + ptr3->obs = ptr2; + ptr2->obs = ptr1; + + CHECK_INSTANCES(3, 3); + } + + CHECK_NO_LEAKS; } + } + | owner_types{}; - CHECK_NO_LEAKS; + TEMPLATE_LIST_TEST_CASE( + "object owning observer pointer closed chain interleaved", + "[lifetime][cycles][owner][observer]", owner_types) { + if constexpr (is_cyclic) { + memory_tracker mem_track; + + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + TestType ptr3 = make_pointer_deleter_1(); + TestType ptr4 = make_pointer_deleter_2(); + ptr1->obs = ptr2; + ptr2->obs = ptr4; + ptr3->obs = ptr1; + ptr4->obs = ptr3; + + CHECK_INSTANCES(4, 4); + } + + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "pointers in vector", "[lifetime][array][owner][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("pointers in vector", "[lifetime][array][owner][observer]", owner_types) { - memory_tracker mem_track; + { + std::vector vec_own; + std::vector> vec_obs; - { - std::vector vec_own; - std::vector> vec_obs; + vec_own.resize(100); - vec_own.resize(100); + CHECK(std::all_of(vec_own.begin(), vec_own.end(), [](const auto& p) { + return p == nullptr; + }) == true); - CHECK(std::all_of(vec_own.begin(), vec_own.end(), [](const auto& p) { - return p == nullptr; - }) == true); + std::generate(vec_own.begin(), vec_own.end(), []() { + return make_pointer_deleter_1(); + }); - std::generate( - vec_own.begin(), vec_own.end(), []() { return make_pointer_deleter_1(); }); + CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { + return p == nullptr; + }) == true); - CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { - return p == nullptr; - }) == true); + vec_obs.resize(100); - vec_obs.resize(100); + CHECK(std::all_of(vec_obs.begin(), vec_obs.end(), [](const auto& p) { + return p == nullptr; + }) == true); - CHECK(std::all_of(vec_obs.begin(), vec_obs.end(), [](const auto& p) { - return p == nullptr; - }) == true); + std::copy(vec_own.begin(), vec_own.end(), vec_obs.begin()); - std::copy(vec_own.begin(), vec_own.end(), vec_obs.begin()); + CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { + return p == nullptr; + }) == true); - CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { - return p == nullptr; - }) == true); + std::vector vec_own_new = std::move(vec_own); - std::vector vec_own_new = std::move(vec_own); + CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { + return p == nullptr; + }) == true); - CHECK(std::none_of(vec_own.begin(), vec_own.end(), [](const auto& p) { - return p == nullptr; - }) == true); + vec_own_new.clear(); - vec_own_new.clear(); + CHECK(std::all_of(vec_obs.begin(), vec_obs.end(), [](const auto& p) { + return p == nullptr; + }) == true); + } - CHECK(std::all_of(vec_obs.begin(), vec_obs.end(), [](const auto& p) { - return p == nullptr; - }) == true); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; + | owner_types{}; }; diff --git a/tests/runtime_tests_make_observable.cpp b/tests/runtime_tests_make_observable.cpp index 1a41b00..21ac49e 100644 --- a/tests/runtime_tests_make_observable.cpp +++ b/tests/runtime_tests_make_observable.cpp @@ -2,109 +2,117 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("make observable", "[make_observable][owner]", owner_types) { - if constexpr (can_use_make_observable) { - memory_tracker mem_track; - - { - TestType ptr = oup::make_observable, get_policy>(); - - if constexpr (is_sealed) { - CHECK(mem_track.allocated() == 1u); - } else { - CHECK(mem_track.allocated() == 2u); - } - CHECK(ptr.get() != nullptr); - CHECK(ptr->state_ == test_object::state::default_init); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); +SUITE { + TEMPLATE_LIST_TEST_CASE("make observable", "[make_observable][owner]", owner_types) { + if constexpr (can_use_make_observable) { + memory_tracker mem_track; + + { + TestType ptr = oup::make_observable, get_policy>(); + + if constexpr (is_sealed) { + CHECK(mem_track.allocated() == 1u); + } else { + CHECK(mem_track.allocated() == 2u); + } + CHECK(ptr.get() != nullptr); + CHECK(ptr->state_ == test_object::state::default_init); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); + } + CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; - -TEMPLATE_LIST_TEST_CASE("make observable with arguments", "[make_observable][owner]", owner_types) { - if constexpr (can_use_make_observable) { - memory_tracker mem_track; - - { - TestType ptr = oup::make_observable, get_policy>( - test_object::state::special_init); - - if constexpr (is_sealed) { - CHECK(mem_track.allocated() == 1u); - } else { - CHECK(mem_track.allocated() == 2u); - } - CHECK(ptr.get() != nullptr); - CHECK(ptr->state_ == test_object::state::special_init); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "make observable with arguments", "[make_observable][owner]", owner_types) { + if constexpr (can_use_make_observable) { + memory_tracker mem_track; + + { + TestType ptr = oup::make_observable, get_policy>( + test_object::state::special_init); + + if constexpr (is_sealed) { + CHECK(mem_track.allocated() == 1u); + } else { + CHECK(mem_track.allocated() == 2u); + } + CHECK(ptr.get() != nullptr); + CHECK(ptr->state_ == test_object::state::special_init); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); + } + CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "make observable throw in constructor", "[make_observable][owner]", owner_types) { - if constexpr (can_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "make observable throw in constructor", "[make_observable][owner]", owner_types) { + if constexpr (can_use_make_observable) { + memory_tracker mem_track; - next_test_object_constructor_throws = true; - REQUIRE_THROWS_AS( - (oup::make_observable, get_policy>()), - throw_constructor); + next_test_object_constructor_throws = true; + REQUIRE_THROWS_AS( + (oup::make_observable, get_policy>()), + throw_constructor); - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("make observable bad alloc", "[make_observable][owner]", owner_types) { - if constexpr (can_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("make observable bad alloc", "[make_observable][owner]", owner_types) { + if constexpr (can_use_make_observable) { + memory_tracker mem_track; - force_next_allocation_failure = true; - REQUIRE_THROWS_AS( - (oup::make_observable, get_policy>()), std::bad_alloc); + force_next_allocation_failure = true; + REQUIRE_THROWS_AS( + (oup::make_observable, get_policy>()), + std::bad_alloc); - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEST_CASE("make observable unique", "[make_observable][owner]") { - using TestType = oup::observable_unique_ptr; - memory_tracker mem_track; + TEST_CASE("make observable unique", "[make_observable][owner]") { + using TestType = oup::observable_unique_ptr; + memory_tracker mem_track; - { - TestType ptr = oup::make_observable_unique(); + { + TestType ptr = oup::make_observable_unique(); - CHECK(mem_track.allocated() == 2u); - CHECK(ptr.get() != nullptr); - CHECK(ptr->state_ == test_object::state::default_init); - CHECK_INSTANCES(1, 1); - } + CHECK(mem_track.allocated() == 2u); + CHECK(ptr.get() != nullptr); + CHECK(ptr->state_ == test_object::state::default_init); + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + }; -TEST_CASE("make observable sealed", "[make_observable][owner]") { - using TestType = oup::observable_sealed_ptr; - memory_tracker mem_track; + TEST_CASE("make observable sealed", "[make_observable][owner]") { + using TestType = oup::observable_sealed_ptr; + memory_tracker mem_track; - { - TestType ptr = oup::make_observable_sealed(); + { + TestType ptr = oup::make_observable_sealed(); - CHECK(mem_track.allocated() == 1u); - CHECK(ptr.get() != nullptr); - CHECK(ptr->state_ == test_object::state::default_init); - CHECK_INSTANCES(1, 1); - } + CHECK(mem_track.allocated() == 1u); + CHECK(ptr.get() != nullptr); + CHECK(ptr->state_ == test_object::state::default_init); + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + }; }; diff --git a/tests/runtime_tests_observer_assignment_copy.cpp b/tests/runtime_tests_observer_assignment_copy.cpp index d2cfaee..2da5e69 100644 --- a/tests/runtime_tests_observer_assignment_copy.cpp +++ b/tests/runtime_tests_observer_assignment_copy.cpp @@ -2,114 +2,16 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator valid to empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator valid to empty", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); - observer_ptr optr_orig{ptr_orig}; - { - observer_ptr optr; - optr = optr_orig; - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr_orig.get() == ptr_orig.get()); - CHECK(optr.expired() == false); - CHECK(optr_orig.expired() == false); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator empty to valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr_orig; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = optr_orig; - - CHECK(optr.get() == nullptr); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator empty to empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr_orig; - { - observer_ptr optr; - optr = optr_orig; - - CHECK(optr.get() == nullptr); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(0, 0); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator valid to valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig = make_pointer_deleter_1(); - observer_ptr optr_orig{ptr_orig}; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = optr_orig; - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr_orig.get() == ptr_orig.get()); - CHECK(optr.expired() == false); - CHECK(optr_orig.expired() == false); - CHECK_INSTANCES(2, 2); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment converting operator valid to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); observer_ptr optr_orig{ptr_orig}; { - base_observer_ptr optr; + observer_ptr optr; optr = optr_orig; CHECK(optr.get() == ptr_orig.get()); @@ -124,20 +26,17 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment converting operator empty to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator empty to valid", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { observer_ptr optr_orig; { - TestType ptr = make_pointer_deleter_1(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; optr = optr_orig; CHECK(optr.get() == nullptr); @@ -152,19 +51,16 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment converting operator empty to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator empty to empty", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { observer_ptr optr_orig; { - base_observer_ptr optr; + observer_ptr optr; optr = optr_orig; CHECK(optr.get() == nullptr); @@ -179,21 +75,18 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment converting operator valid to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator valid to valid", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); observer_ptr optr_orig{ptr_orig}; { - TestType ptr = make_pointer_deleter_1(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; optr = optr_orig; CHECK(optr.get() == ptr_orig.get()); @@ -208,43 +101,160 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment converting operator valid to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + observer_ptr optr_orig{ptr_orig}; + { + base_observer_ptr optr; + optr = optr_orig; + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr_orig.get() == ptr_orig.get()); + CHECK(optr.expired() == false); + CHECK(optr_orig.expired() == false); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator self to self valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - SNATCH_WARNING_PUSH; - SNATCH_WARNING_DISABLE_SELF_ASSIGN; - optr = optr; - SNATCH_WARNING_POP; - - CHECK(optr.get() == ptr.get()); - CHECK(optr.expired() == false); - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; + } } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment converting operator empty to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + observer_ptr optr_orig; + { + TestType ptr = make_pointer_deleter_1(); + base_observer_ptr optr{ptr}; + optr = optr_orig; + + CHECK(optr.get() == nullptr); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment converting operator empty to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + observer_ptr optr_orig; + { + base_observer_ptr optr; + optr = optr_orig; + + CHECK(optr.get() == nullptr); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment converting operator valid to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer copy assignment operator self to self empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + observer_ptr optr_orig{ptr_orig}; + { + TestType ptr = make_pointer_deleter_1(); + base_observer_ptr optr{ptr}; + optr = optr_orig; + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr_orig.get() == ptr_orig.get()); + CHECK(optr.expired() == false); + CHECK(optr_orig.expired() == false); + CHECK_INSTANCES(2, 2); + } - { - observer_ptr optr; - SNATCH_WARNING_PUSH; - SNATCH_WARNING_DISABLE_SELF_ASSIGN; - optr = optr; - SNATCH_WARNING_POP; + CHECK_INSTANCES(1, 1); + } - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK_INSTANCES(0, 0); + CHECK_NO_LEAKS; + } } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator self to self valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + // SNATCH_WARNING_PUSH; + // SNATCH_WARNING_DISABLE_SELF_ASSIGN; + optr = optr; + // SNATCH_WARNING_POP; - CHECK_NO_LEAKS; + CHECK(optr.get() == ptr.get()); + CHECK(optr.expired() == false); + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy assignment operator self to self empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + { + observer_ptr optr; + // SNATCH_WARNING_PUSH; + // SNATCH_WARNING_DISABLE_SELF_ASSIGN; + optr = optr; + // SNATCH_WARNING_POP; + + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_assignment_from_owner.cpp b/tests/runtime_tests_observer_assignment_from_owner.cpp index 1243441..4490dc7 100644 --- a/tests/runtime_tests_observer_assignment_from_owner.cpp +++ b/tests/runtime_tests_observer_assignment_from_owner.cpp @@ -2,117 +2,16 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment operator valid to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig = make_pointer_deleter_1(); - { - observer_ptr optr; - optr = ptr_orig; - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr.expired() == false); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment operator empty to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = ptr_orig; - - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES(1, 2); - } - - CHECK_INSTANCES(0, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment operator empty to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig; - { - observer_ptr optr; - optr = ptr_orig; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment operator valid to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES(0, 1); - } - - CHECK_INSTANCES(0, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment operator valid to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig = make_pointer_deleter_1(); - get_object* raw_ptr_orig = ptr_orig.get(); - { - TestType ptr = make_pointer_deleter_1(); - get_object* raw_ptr = ptr.get(); - observer_ptr optr{ptr}; - optr = ptr_orig; - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr.expired() == false); - CHECK(ptr_orig.get() == raw_ptr_orig); - CHECK(ptr.get() == raw_ptr); - CHECK_INSTANCES(2, 2); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment converting operator valid to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); { - base_observer_ptr optr; + observer_ptr optr; optr = ptr_orig; CHECK(optr.get() == ptr_orig.get()); @@ -125,20 +24,18 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment converting operator empty to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment operator empty to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { TestType ptr_orig; { - TestType ptr = make_pointer_deleter_1(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; optr = ptr_orig; CHECK(optr.get() == nullptr); @@ -152,19 +49,17 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment converting operator empty to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment operator empty to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { TestType ptr_orig; { - base_observer_ptr optr; + observer_ptr optr; optr = ptr_orig; CHECK(optr.get() == nullptr); @@ -178,22 +73,20 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from owner assignment converting operator valid to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment operator valid to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); get_object* raw_ptr_orig = ptr_orig.get(); { - TestType ptr = make_pointer_deleter_1(); - get_object* raw_ptr = ptr.get(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + get_object* raw_ptr = ptr.get(); + observer_ptr optr{ptr}; optr = ptr_orig; CHECK(optr.get() == ptr_orig.get()); @@ -208,4 +101,113 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment converting operator valid to empty", + "[assignment][observer]", owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + { + base_observer_ptr optr; + optr = ptr_orig; + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr.expired() == false); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment converting operator empty to valid", + "[assignment][observer]", owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig; + { + TestType ptr = make_pointer_deleter_1(); + base_observer_ptr optr{ptr}; + optr = ptr_orig; + + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES(1, 2); + } + + CHECK_INSTANCES(0, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment converting operator empty to empty", + "[assignment][observer]", owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig; + { + base_observer_ptr optr; + optr = ptr_orig; + + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES(0, 1); + } + + CHECK_INSTANCES(0, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from owner assignment converting operator valid to valid", + "[assignment][observer]", owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + get_object* raw_ptr_orig = ptr_orig.get(); + { + TestType ptr = make_pointer_deleter_1(); + get_object* raw_ptr = ptr.get(); + base_observer_ptr optr{ptr}; + optr = ptr_orig; + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr.expired() == false); + CHECK(ptr_orig.get() == raw_ptr_orig); + CHECK(ptr.get() == raw_ptr); + CHECK_INSTANCES(2, 2); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_assignment_move.cpp b/tests/runtime_tests_observer_assignment_move.cpp index 4e2b05a..94b51dc 100644 --- a/tests/runtime_tests_observer_assignment_move.cpp +++ b/tests/runtime_tests_observer_assignment_move.cpp @@ -2,114 +2,16 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator valid to empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator valid to empty", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); - observer_ptr optr_orig{ptr_orig}; - { - observer_ptr optr; - optr = std::move(optr_orig); - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == false); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator empty to valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr_orig; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = std::move(optr_orig); - - CHECK(optr.get() == nullptr); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator empty to empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr_orig; - { - observer_ptr optr; - optr = std::move(optr_orig); - - CHECK(optr.get() == nullptr); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == true); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(0, 0); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator valid to valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig = make_pointer_deleter_1(); - observer_ptr optr_orig{ptr_orig}; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = std::move(optr_orig); - - CHECK(optr.get() == ptr_orig.get()); - CHECK(optr_orig.get() == nullptr); - CHECK(optr.expired() == false); - CHECK(optr_orig.expired() == true); - CHECK_INSTANCES(2, 2); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move assignment converting operator valid to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; - - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); observer_ptr optr_orig{ptr_orig}; { - base_observer_ptr optr; + observer_ptr optr; optr = std::move(optr_orig); CHECK(optr.get() == ptr_orig.get()); @@ -124,20 +26,17 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move assignment converting operator empty to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator empty to valid", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { observer_ptr optr_orig; { - TestType ptr = make_pointer_deleter_1(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; optr = std::move(optr_orig); CHECK(optr.get() == nullptr); @@ -152,19 +51,16 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move assignment converting operator empty to empty", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator empty to empty", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { observer_ptr optr_orig; { - base_observer_ptr optr; + observer_ptr optr; optr = std::move(optr_orig); CHECK(optr.get() == nullptr); @@ -179,21 +75,18 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move assignment converting operator valid to valid", - "[assignment][observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator valid to valid", "[assignment][observer]", owner_types) { + memory_tracker mem_track; - if constexpr (has_base) { { TestType ptr_orig = make_pointer_deleter_1(); observer_ptr optr_orig{ptr_orig}; { - TestType ptr = make_pointer_deleter_1(); - base_observer_ptr optr{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; optr = std::move(optr_orig); CHECK(optr.get() == ptr_orig.get()); @@ -208,35 +101,152 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator self to self valid", "[assignment][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr = std::move(optr); - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK_INSTANCES(1, 1); + TEMPLATE_LIST_TEST_CASE( + "observer move assignment converting operator valid to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + observer_ptr optr_orig{ptr_orig}; + { + base_observer_ptr optr; + optr = std::move(optr_orig); + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == false); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer move assignment converting operator empty to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer move assignment operator self to self empty", "[assignment][observer]", owner_types) { - memory_tracker mem_track; + if constexpr (has_base) { + { + observer_ptr optr_orig; + { + TestType ptr = make_pointer_deleter_1(); + base_observer_ptr optr{ptr}; + optr = std::move(optr_orig); + + CHECK(optr.get() == nullptr); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } - { - observer_ptr optr; - optr = std::move(optr); - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK_INSTANCES(0, 0); + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move assignment converting operator empty to empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; - CHECK_NO_LEAKS; + if constexpr (has_base) { + { + observer_ptr optr_orig; + { + base_observer_ptr optr; + optr = std::move(optr_orig); + + CHECK(optr.get() == nullptr); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == true); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move assignment converting operator valid to valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + if constexpr (has_base) { + { + TestType ptr_orig = make_pointer_deleter_1(); + observer_ptr optr_orig{ptr_orig}; + { + TestType ptr = make_pointer_deleter_1(); + base_observer_ptr optr{ptr}; + optr = std::move(optr_orig); + + CHECK(optr.get() == ptr_orig.get()); + CHECK(optr_orig.get() == nullptr); + CHECK(optr.expired() == false); + CHECK(optr_orig.expired() == true); + CHECK_INSTANCES(2, 2); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator self to self valid", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + optr = std::move(optr); + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move assignment operator self to self empty", "[assignment][observer]", + owner_types) { + memory_tracker mem_track; + + { + observer_ptr optr; + optr = std::move(optr); + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_cast_copy.cpp b/tests/runtime_tests_observer_cast_copy.cpp index c767085..8e8f6f8 100644 --- a/tests/runtime_tests_observer_cast_copy.cpp +++ b/tests/runtime_tests_observer_cast_copy.cpp @@ -2,122 +2,80 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("observer static_cast copy from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; - - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - get_object* raw_ptr = ptr1.get(); - auto optr2 = oup::static_pointer_cast(optr1); - - using return_type = std::remove_cv_t; - - CHECK(optr1.get() == raw_ptr); - CHECK(optr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); - }; - - run_test.template operator(), observer_ptr>(); - run_test.template operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_observer_ptr>(); - } - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer static_cast copy from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer static_cast copy from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - auto optr2 = oup::static_pointer_cast(optr1); + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + get_object* raw_ptr = ptr1.get(); + auto optr2 = oup::static_pointer_cast(optr1); - using return_type = std::remove_cv_t; + using return_type = std::remove_cv_t; - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(0, 1); - }; + CHECK(optr1.get() == raw_ptr); + CHECK(optr2.get() == raw_ptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + }; - run_test.template operator(), observer_ptr>(); - run_test.template operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_observer_ptr>(); + run_test.template operator(), observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_observer_ptr>(); + } } - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer const_cast copy from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - get_object* raw_ptr = ptr1.get(); - auto optr2 = oup::const_pointer_cast(optr1); - - using return_type = std::remove_cv_t; - - CHECK(optr1.get() == raw_ptr); - CHECK(optr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); - }; - - run_test.template operator(), const_observer_ptr>(); - run_test.template - operator()>, mutable_observer_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer static_cast copy from empty", "[cast][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer const_cast copy from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + auto optr2 = oup::static_pointer_cast(optr1); - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - auto optr2 = oup::const_pointer_cast(optr1); + using return_type = std::remove_cv_t; - using return_type = std::remove_cv_t; + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(0, 1); + }; - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(0, 1); - }; + run_test.template operator(), observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_observer_ptr>(); + } + } - run_test.template operator(), const_observer_ptr>(); - run_test.template - operator()>, mutable_observer_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer dynamic_cast copy from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer const_cast copy from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr0.get(); - observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(optr1); + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + get_object* raw_ptr = ptr1.get(); + auto optr2 = oup::const_pointer_cast(optr1); using return_type = std::remove_cv_t; @@ -127,29 +85,25 @@ TEMPLATE_LIST_TEST_CASE("observer dynamic_cast copy from valid", "[cast][observe CHECK_INSTANCES(1, 1); }; - run_test.template operator(), observer_ptr>(); - run_test.template - operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template - operator(), base_observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); run_test.template - operator(), get_object, observer_ptr>(); + operator()>, mutable_observer_ptr>(); } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("observer dynamic_cast copy from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer const_cast copy from empty", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(optr1); + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + auto optr2 = oup::const_pointer_cast(optr1); using return_type = std::remove_cv_t; @@ -159,41 +113,110 @@ TEMPLATE_LIST_TEST_CASE("observer dynamic_cast copy from empty", "[cast][observe CHECK_INSTANCES(0, 1); }; - run_test.template operator(), observer_ptr>(); - run_test.template - operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template - operator(), base_observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); run_test.template - operator(), get_object, observer_ptr>(); + operator()>, mutable_observer_ptr>(); } + + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast copy from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; + + { + auto run_test = + [&]() { + TestType ptr0 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr0.get(); + observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(optr1); + + using return_type = std::remove_cv_t; + + CHECK(optr1.get() == raw_ptr); + CHECK(optr2.get() == raw_ptr); + CHECK( + snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + }; + + run_test.template operator(), observer_ptr>(); + run_test.template + operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test.template + operator(), base_observer_ptr>(); + run_test.template + operator(), get_object, observer_ptr>(); + } + } -TEMPLATE_LIST_TEST_CASE( - "observer dynamic_cast copy from invalid", "[cast][observer]", owner_types) { - if constexpr (has_base) { + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast copy from empty", "[cast][observer]", owner_types) { memory_tracker mem_track; { - TestType ptr0 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr0.get(); - base_observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(optr1); - - using return_type = std::remove_cv_t; - using expected_return_type = - oup::basic_observer_ptr>; - - CHECK(optr1.get() == raw_ptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); + auto run_test = + [&]() { + TestType ptr0 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(optr1); + + using return_type = std::remove_cv_t; + + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK( + snatch::type_name == snatch::type_name); + CHECK_INSTANCES(0, 1); + }; + + run_test.template operator(), observer_ptr>(); + run_test.template + operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test.template + operator(), base_observer_ptr>(); + run_test.template + operator(), get_object, observer_ptr>(); + } } CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast copy from invalid", "[cast][observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + TestType ptr0 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr0.get(); + base_observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(optr1); + + using return_type = std::remove_cv_t; + using expected_return_type = + oup::basic_observer_ptr>; + + CHECK(optr1.get() == raw_ptr); + CHECK(optr2.get() == nullptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_cast_move.cpp b/tests/runtime_tests_observer_cast_move.cpp index 122763e..e99c176 100644 --- a/tests/runtime_tests_observer_cast_move.cpp +++ b/tests/runtime_tests_observer_cast_move.cpp @@ -2,122 +2,80 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("observer static_cast move from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; - - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - get_object* raw_ptr = ptr1.get(); - auto optr2 = oup::static_pointer_cast(std::move(optr1)); - - using return_type = std::remove_cv_t; - - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); - }; - - run_test.template operator(), observer_ptr>(); - run_test.template operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_observer_ptr>(); - } - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer static_cast move from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer static_cast move from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - auto optr2 = oup::static_pointer_cast(std::move(optr1)); + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + get_object* raw_ptr = ptr1.get(); + auto optr2 = oup::static_pointer_cast(std::move(optr1)); - using return_type = std::remove_cv_t; + using return_type = std::remove_cv_t; - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(0, 1); - }; + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == raw_ptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + }; - run_test.template operator(), observer_ptr>(); - run_test.template operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_observer_ptr>(); + run_test.template operator(), observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_observer_ptr>(); + } } - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer const_cast move from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - get_object* raw_ptr = ptr1.get(); - auto optr2 = oup::const_pointer_cast(std::move(optr1)); - - using return_type = std::remove_cv_t; - - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); - }; - - run_test.template operator(), const_observer_ptr>(); - run_test.template - operator()>, mutable_observer_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer static_cast move from empty", "[cast][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer const_cast move from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + auto optr2 = oup::static_pointer_cast(std::move(optr1)); - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr1; - auto optr2 = oup::const_pointer_cast(std::move(optr1)); + using return_type = std::remove_cv_t; - using return_type = std::remove_cv_t; + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(0, 1); + }; - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(0, 1); - }; + run_test.template operator(), observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_observer_ptr>(); + } + } - run_test.template operator(), const_observer_ptr>(); - run_test.template - operator()>, mutable_observer_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer dynamic_cast move from valid", "[cast][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer const_cast move from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr0.get(); - observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + get_object* raw_ptr = ptr1.get(); + auto optr2 = oup::const_pointer_cast(std::move(optr1)); using return_type = std::remove_cv_t; @@ -127,29 +85,25 @@ TEMPLATE_LIST_TEST_CASE("observer dynamic_cast move from valid", "[cast][observe CHECK_INSTANCES(1, 1); }; - run_test.template operator(), observer_ptr>(); - run_test.template - operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template - operator(), base_observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); run_test.template - operator(), get_object, observer_ptr>(); + operator()>, mutable_observer_ptr>(); } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("observer dynamic_cast move from empty", "[cast][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer const_cast move from empty", "[cast][observer]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_empty_pointer_deleter_1(); - observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr1; + auto optr2 = oup::const_pointer_cast(std::move(optr1)); using return_type = std::remove_cv_t; @@ -159,40 +113,109 @@ TEMPLATE_LIST_TEST_CASE("observer dynamic_cast move from empty", "[cast][observe CHECK_INSTANCES(0, 1); }; - run_test.template operator(), observer_ptr>(); - run_test.template - operator(), const_observer_ptr>(); - if constexpr (has_base) { - run_test.template - operator(), base_observer_ptr>(); + run_test + .template operator(), const_observer_ptr>(); run_test.template - operator(), get_object, observer_ptr>(); + operator()>, mutable_observer_ptr>(); } + + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast move from valid", "[cast][observer]", owner_types) { + memory_tracker mem_track; + + { + auto run_test = + [&]() { + TestType ptr0 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr0.get(); + observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); + + using return_type = std::remove_cv_t; + + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == raw_ptr); + CHECK( + snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + }; + + run_test.template operator(), observer_ptr>(); + run_test.template + operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test.template + operator(), base_observer_ptr>(); + run_test.template + operator(), get_object, observer_ptr>(); + } + } -TEMPLATE_LIST_TEST_CASE( - "observer dynamic_cast move from invalid", "[cast][observer]", owner_types) { - if constexpr (has_base) { + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast move from empty", "[cast][observer]", owner_types) { memory_tracker mem_track; { - TestType ptr0 = make_pointer_deleter_1(); - base_observer_ptr optr1 = ptr0; - auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); - - using return_type = std::remove_cv_t; - using expected_return_type = - oup::basic_observer_ptr>; - - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - CHECK_INSTANCES(1, 1); + auto run_test = + [&]() { + TestType ptr0 = make_empty_pointer_deleter_1(); + observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); + + using return_type = std::remove_cv_t; + + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK( + snatch::type_name == snatch::type_name); + CHECK_INSTANCES(0, 1); + }; + + run_test.template operator(), observer_ptr>(); + run_test.template + operator(), const_observer_ptr>(); + if constexpr (has_base) { + run_test.template + operator(), base_observer_ptr>(); + run_test.template + operator(), get_object, observer_ptr>(); + } } CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer dynamic_cast move from invalid", "[cast][observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + TestType ptr0 = make_pointer_deleter_1(); + base_observer_ptr optr1 = ptr0; + auto optr2 = oup::dynamic_pointer_cast(std::move(optr1)); + + using return_type = std::remove_cv_t; + using expected_return_type = + oup::basic_observer_ptr>; + + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK(snatch::type_name == snatch::type_name); + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_comparison.cpp b/tests/runtime_tests_observer_comparison.cpp index a93d531..3a330cd 100644 --- a/tests/runtime_tests_observer_comparison.cpp +++ b/tests/runtime_tests_observer_comparison.cpp @@ -2,125 +2,89 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer comparison valid vs nullptr", "[comparison][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - - CHECK(optr != nullptr); - CHECK(!(optr == nullptr)); - CHECK(nullptr != optr); - CHECK(!(nullptr == optr)); - } - - CHECK_NO_LEAKS; -}; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer comparison valid vs nullptr", "[comparison][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer comparison empty vs nullptr", "[comparison][observer]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; - { - observer_ptr optr; + CHECK(optr != nullptr); + CHECK(!(optr == nullptr)); + CHECK(nullptr != optr); + CHECK(!(nullptr == optr)); + } - CHECK(optr == nullptr); - CHECK(!(optr != nullptr)); - CHECK(nullptr == optr); - CHECK(!(nullptr != optr)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer comparison empty vs nullptr", "[comparison][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer comparison empty vs empty", "[comparison][observer]", owner_types) { - memory_tracker mem_track; + { + observer_ptr optr; - { - observer_ptr optr1; - observer_ptr optr2; + CHECK(optr == nullptr); + CHECK(!(optr != nullptr)); + CHECK(nullptr == optr); + CHECK(!(nullptr != optr)); + } - CHECK(optr1 == optr2); - CHECK(optr2 == optr1); - CHECK(!(optr1 != optr2)); - CHECK(!(optr2 != optr1)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer comparison empty vs valid", "[comparison][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr1; - TestType ptr2 = make_pointer_deleter_2(); - observer_ptr optr2{ptr2}; + TEMPLATE_LIST_TEST_CASE( + "observer comparison empty vs empty", "[comparison][observer]", owner_types) { + memory_tracker mem_track; - CHECK(optr1 != optr2); - CHECK(optr2 != optr1); - CHECK(!(optr1 == optr2)); - CHECK(!(optr2 == optr1)); - } + { + observer_ptr optr1; + observer_ptr optr2; - CHECK_NO_LEAKS; -}; + CHECK(optr1 == optr2); + CHECK(optr2 == optr1); + CHECK(!(optr1 != optr2)); + CHECK(!(optr2 != optr1)); + } -TEMPLATE_LIST_TEST_CASE( - "observer comparison valid vs valid different instance", - "[comparison][observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1{ptr1}; - TestType ptr2 = make_pointer_deleter_2(); - observer_ptr optr2{ptr2}; - - CHECK(optr1 != optr2); - CHECK(optr2 != optr1); - CHECK(!(optr1 == optr2)); - CHECK(!(optr2 == optr1)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer comparison empty vs valid", "[comparison][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer comparison valid vs valid same instance", "[comparison][observer]", owner_types) { - memory_tracker mem_track; + { + observer_ptr optr1; + TestType ptr2 = make_pointer_deleter_2(); + observer_ptr optr2{ptr2}; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr1{ptr}; - observer_ptr optr2{ptr}; + CHECK(optr1 != optr2); + CHECK(optr2 != optr1); + CHECK(!(optr1 == optr2)); + CHECK(!(optr2 == optr1)); + } - CHECK(optr1 == optr2); - CHECK(optr2 == optr1); - CHECK(!(optr1 != optr2)); - CHECK(!(optr2 != optr1)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer comparison valid vs valid different instance derived", - "[comparison][observer]", - owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE( + "observer comparison valid vs valid different instance", "[comparison][observer]", + owner_types) { memory_tracker mem_track; { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1{ptr1}; - TestType ptr2 = make_pointer_deleter_2(); - base_observer_ptr optr2{ptr2}; + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1{ptr1}; + TestType ptr2 = make_pointer_deleter_2(); + observer_ptr optr2{ptr2}; CHECK(optr1 != optr2); CHECK(optr2 != optr1); @@ -130,19 +94,16 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer comparison valid vs valid same instance derived", - "[comparison][observer]", - owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE( + "observer comparison valid vs valid same instance", "[comparison][observer]", owner_types) { memory_tracker mem_track; { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr1{ptr}; - base_observer_ptr optr2{ptr}; + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr1{ptr}; + observer_ptr optr2{ptr}; CHECK(optr1 == optr2); CHECK(optr2 == optr1); @@ -152,4 +113,50 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer comparison valid vs valid different instance derived", "[comparison][observer]", + owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1{ptr1}; + TestType ptr2 = make_pointer_deleter_2(); + base_observer_ptr optr2{ptr2}; + + CHECK(optr1 != optr2); + CHECK(optr2 != optr1); + CHECK(!(optr1 == optr2)); + CHECK(!(optr2 == optr1)); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer comparison valid vs valid same instance derived", "[comparison][observer]", + owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr1{ptr}; + base_observer_ptr optr2{ptr}; + + CHECK(optr1 == optr2); + CHECK(optr2 == optr1); + CHECK(!(optr1 != optr2)); + CHECK(!(optr2 != optr1)); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_construction.cpp b/tests/runtime_tests_observer_construction.cpp index f7499c5..1a9b308 100644 --- a/tests/runtime_tests_observer_construction.cpp +++ b/tests/runtime_tests_observer_construction.cpp @@ -2,30 +2,36 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("observer default constructor", "[construction][observer]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer default constructor", "[construction][observer]", owner_types) { + memory_tracker mem_track; - { - observer_ptr ptr; + { + observer_ptr ptr; - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK_INSTANCES(0, 0); + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "observer nullptr constructor", "[construction][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer nullptr constructor", "[construction][observer]", owner_types) { - memory_tracker mem_track; + { + observer_ptr ptr(nullptr); - { - observer_ptr ptr(nullptr); + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK_INSTANCES(0, 0); + } - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK_INSTANCES(0, 0); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_construction_copy.cpp b/tests/runtime_tests_observer_construction_copy.cpp index d72c681..44dfb4a 100644 --- a/tests/runtime_tests_observer_construction_copy.cpp +++ b/tests/runtime_tests_observer_construction_copy.cpp @@ -2,65 +2,20 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer copy constructor valid", "[construction][observer][from_observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr_owner = make_pointer_deleter_1(); - observer_ptr ptr_orig{ptr_owner}; - { - observer_ptr ptr(ptr_orig); - - CHECK(ptr.get() != nullptr); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() != nullptr); - CHECK(ptr_orig.expired() == false); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy constructor empty", "[construction][observer][from_observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr ptr_orig; - { - observer_ptr ptr(ptr_orig); - - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK_INSTANCES(0, 0); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer copy from valid observer implicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer copy constructor valid", "[construction][observer][from_observer]", owner_types) { memory_tracker mem_track; { TestType ptr_owner = make_pointer_deleter_1(); observer_ptr ptr_orig{ptr_owner}; { - base_observer_ptr ptr{ptr_orig}; + observer_ptr ptr(ptr_orig); - CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.get() != nullptr); CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == ptr_owner.get()); + CHECK(ptr_orig.get() != nullptr); CHECK(ptr_orig.expired() == false); CHECK_INSTANCES(1, 1); } @@ -70,24 +25,19 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy from empty observer implicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE( + "observer copy constructor empty", "[construction][observer][from_observer]", owner_types) { memory_tracker mem_track; { observer_ptr ptr_orig; { - base_observer_ptr ptr{ptr_orig}; + observer_ptr ptr(ptr_orig); CHECK(ptr.get() == nullptr); CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(0, 0); } @@ -96,110 +46,166 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy from valid observer explicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy from valid observer implicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner = make_pointer_deleter_1(); - base_observer_ptr ptr_orig{ptr_owner}; { - observer_ptr ptr{ - ptr_orig, static_cast*>(ptr_orig.get())}; + TestType ptr_owner = make_pointer_deleter_1(); + observer_ptr ptr_orig{ptr_owner}; + { + base_observer_ptr ptr{ptr_orig}; + + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == ptr_owner.get()); + CHECK(ptr_orig.expired() == false); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == static_cast*>(ptr_owner.get())); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == ptr_owner.get()); - CHECK(ptr_orig.expired() == false); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy from empty observer explicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy from empty observer implicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_observer_ptr ptr_orig; { - observer_ptr ptr{ptr_orig, static_cast*>(nullptr)}; + observer_ptr ptr_orig; + { + base_observer_ptr ptr{ptr_orig}; + + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(0, 0); + } - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(0, 0); } - CHECK_INSTANCES(0, 0); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy from valid observer explicit conversion constructor with null", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy from valid observer explicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner = make_pointer_deleter_1(); - base_observer_ptr ptr_orig{ptr_owner}; { - observer_ptr ptr{ptr_orig, static_cast*>(nullptr)}; + base_ptr ptr_owner = make_pointer_deleter_1(); + base_observer_ptr ptr_orig{ptr_owner}; + { + observer_ptr ptr{ + ptr_orig, static_cast*>(ptr_orig.get())}; + + CHECK(ptr.get() == static_cast*>(ptr_owner.get())); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == ptr_owner.get()); + CHECK(ptr_orig.expired() == false); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == ptr_owner.get()); - CHECK(ptr_orig.expired() == false); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } + } + | owner_types{}; - CHECK_NO_LEAKS; + TEMPLATE_LIST_TEST_CASE( + "observer copy from empty observer explicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_observer_ptr ptr_orig; + { + observer_ptr ptr{ + ptr_orig, static_cast*>(nullptr)}; + + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer copy from valid observer explicit conversion constructor subobject", - "[construction][observer][from_observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer copy from valid observer explicit conversion constructor with null", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_ptr ptr_owner = make_pointer_deleter_1(); + base_observer_ptr ptr_orig{ptr_owner}; + { + observer_ptr ptr{ + ptr_orig, static_cast*>(nullptr)}; + + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == ptr_owner.get()); + CHECK(ptr_orig.expired() == false); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer copy from valid observer explicit conversion constructor subobject", + "[construction][observer][from_observer]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_owner = make_pointer_deleter_1(); - observer_ptr ptr_orig{ptr_owner}; { - state_observer_ptr ptr{ptr_orig, &ptr_owner->state_}; + TestType ptr_owner = make_pointer_deleter_1(); + observer_ptr ptr_orig{ptr_owner}; + { + state_observer_ptr ptr{ptr_orig, &ptr_owner->state_}; + + CHECK(ptr.get() == &ptr_owner->state_); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == ptr_owner.get()); + CHECK(ptr_orig.expired() == false); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == &ptr_owner->state_); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == ptr_owner.get()); - CHECK(ptr_orig.expired() == false); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_construction_from_owner.cpp b/tests/runtime_tests_observer_construction_from_owner.cpp index 2782ab4..c114e6f 100644 --- a/tests/runtime_tests_observer_construction_from_owner.cpp +++ b/tests/runtime_tests_observer_construction_from_owner.cpp @@ -2,57 +2,16 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer from empty owner constructor", "[construction][observer][from_owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr_owner; - { - observer_ptr ptr{ptr_owner}; - - CHECK(ptr.get() == ptr_owner.get()); - CHECK(ptr.expired() == true); - CHECK_INSTANCES(0, 1); - } - - CHECK_INSTANCES(0, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from valid owner constructor", "[construction][observer][from_owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr_owner = make_pointer_deleter_1(); - { - observer_ptr ptr{ptr_owner}; - - CHECK(ptr.get() == ptr_owner.get()); - CHECK(ptr.expired() == false); - CHECK_INSTANCES(1, 1); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer from empty owner conversion constructor", - "[construction][observer][from_owner]", - owner_types) { - if constexpr (has_base) { +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer from empty owner constructor", "[construction][observer][from_owner]", + owner_types) { memory_tracker mem_track; { TestType ptr_owner; { - base_observer_ptr ptr{ptr_owner}; + observer_ptr ptr{ptr_owner}; CHECK(ptr.get() == ptr_owner.get()); CHECK(ptr.expired() == true); @@ -64,19 +23,17 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from valid owner conversion constructor", - "[construction][observer][from_owner]", - owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE( + "observer from valid owner constructor", "[construction][observer][from_owner]", + owner_types) { memory_tracker mem_track; { TestType ptr_owner = make_pointer_deleter_1(); { - base_observer_ptr ptr{ptr_owner}; + observer_ptr ptr{ptr_owner}; CHECK(ptr.get() == ptr_owner.get()); CHECK(ptr.expired() == false); @@ -88,53 +45,103 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from empty owner explicit conversion constructor", - "[construction][observer][from_owner]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from empty owner conversion constructor", "[construction][observer][from_owner]", + owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner; { - observer_ptr ptr{ptr_owner, static_cast*>(nullptr)}; + TestType ptr_owner; + { + base_observer_ptr ptr{ptr_owner}; + + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == true); + CHECK_INSTANCES(0, 1); + } - CHECK(ptr.get() == ptr_owner.get()); - CHECK(ptr.expired() == true); CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from valid owner explicit conversion constructor", - "[construction][observer][from_owner]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from valid owner conversion constructor", "[construction][observer][from_owner]", + owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner = make_pointer_deleter_1(); { - observer_ptr ptr{ - ptr_owner, dynamic_cast*>(ptr_owner.get())}; + TestType ptr_owner = make_pointer_deleter_1(); + { + base_observer_ptr ptr{ptr_owner}; + + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == false); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == ptr_owner.get()); - CHECK(ptr.expired() == false); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } + } + | owner_types{}; - CHECK_NO_LEAKS; + TEMPLATE_LIST_TEST_CASE( + "observer from empty owner explicit conversion constructor", + "[construction][observer][from_owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_ptr ptr_owner; + { + observer_ptr ptr{ + ptr_owner, static_cast*>(nullptr)}; + + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == true); + CHECK_INSTANCES(0, 1); + } + + CHECK_INSTANCES(0, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from valid owner explicit conversion constructor", + "[construction][observer][from_owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_ptr ptr_owner = make_pointer_deleter_1(); + { + observer_ptr ptr{ + ptr_owner, dynamic_cast*>(ptr_owner.get())}; + + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == false); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_construction_move.cpp b/tests/runtime_tests_observer_construction_move.cpp index be6b6cb..ad5d374 100644 --- a/tests/runtime_tests_observer_construction_move.cpp +++ b/tests/runtime_tests_observer_construction_move.cpp @@ -2,67 +2,19 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "observer move from valid observer constructor", - "[construction][observer][from_observer]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_owner = make_pointer_deleter_1(); - observer_ptr ptr_orig{ptr_owner}; - { - observer_ptr ptr(std::move(ptr_orig)); - CHECK_INSTANCES(1, 1); - CHECK(ptr.get() != nullptr); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); - } - - CHECK_INSTANCES(1, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move from empty observer constructor", - "[construction][observer][from_observer]", - owner_types) { - memory_tracker mem_track; - - { - observer_ptr ptr_orig; - { - observer_ptr ptr(std::move(ptr_orig)); - CHECK_INSTANCES(0, 0); - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); - } - - CHECK_INSTANCES(0, 0); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move from valid observer implicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { +SUITE { + TEMPLATE_LIST_TEST_CASE( + "observer move from valid observer constructor", "[construction][observer][from_observer]", + owner_types) { memory_tracker mem_track; { TestType ptr_owner = make_pointer_deleter_1(); observer_ptr ptr_orig{ptr_owner}; { - base_observer_ptr ptr{std::move(ptr_orig)}; + observer_ptr ptr(std::move(ptr_orig)); CHECK_INSTANCES(1, 1); - CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.get() != nullptr); CHECK(ptr.expired() == false); CHECK(ptr_orig.get() == nullptr); CHECK(ptr_orig.expired() == true); @@ -73,73 +25,66 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move from empty observer implicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move from empty observer constructor", "[construction][observer][from_observer]", + owner_types) { + memory_tracker mem_track; - { - observer_ptr ptr_orig; { - base_observer_ptr ptr{std::move(ptr_orig)}; + observer_ptr ptr_orig; + { + observer_ptr ptr(std::move(ptr_orig)); + CHECK_INSTANCES(0, 0); + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + } - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(0, 0); } - CHECK_INSTANCES(0, 0); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer move from valid observer explicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move from valid observer implicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner = make_pointer_deleter_1(); - base_observer_ptr ptr_orig{ptr_owner}; { - observer_ptr ptr{ - std::move(ptr_orig), dynamic_cast*>(ptr_orig.get())}; + TestType ptr_owner = make_pointer_deleter_1(); + observer_ptr ptr_orig{ptr_owner}; + { + base_observer_ptr ptr{std::move(ptr_orig)}; + CHECK_INSTANCES(1, 1); + CHECK(ptr.get() == ptr_owner.get()); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + } - CHECK(ptr.get() == dynamic_cast*>(ptr_owner.get())); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move from empty observer explicit conversion constructor", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE( + "observer move from empty observer implicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { memory_tracker mem_track; { - base_observer_ptr ptr_orig; + observer_ptr ptr_orig; { - observer_ptr ptr{ - std::move(ptr_orig), static_cast*>(nullptr)}; + base_observer_ptr ptr{std::move(ptr_orig)}; CHECK(ptr.get() == nullptr); CHECK(ptr.expired() == true); @@ -153,57 +98,114 @@ TEMPLATE_LIST_TEST_CASE( CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer move from valid observer explicit conversion constructor with null", - "[construction][observer][from_observer]", - owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer move from valid observer explicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_owner = make_pointer_deleter_1(); - base_observer_ptr ptr_orig{ptr_owner}; { - observer_ptr ptr{ - std::move(ptr_orig), static_cast*>(nullptr)}; + base_ptr ptr_owner = make_pointer_deleter_1(); + base_observer_ptr ptr_orig{ptr_owner}; + { + observer_ptr ptr{ + std::move(ptr_orig), dynamic_cast*>(ptr_orig.get())}; + + CHECK(ptr.get() == dynamic_cast*>(ptr_owner.get())); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == nullptr); - CHECK(ptr.expired() == true); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } + } + | owner_types{}; - CHECK_NO_LEAKS; + TEMPLATE_LIST_TEST_CASE( + "observer move from empty observer explicit conversion constructor", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_observer_ptr ptr_orig; + { + observer_ptr ptr{ + std::move(ptr_orig), static_cast*>(nullptr)}; + + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(0, 0); + } + + CHECK_INSTANCES(0, 0); + } + + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move from valid observer explicit conversion constructor with null", + "[construction][observer][from_observer]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "observer move from valid observer explicit conversion constructor subobject", - "[construction][observer][from_observer]", - owner_types) { - memory_tracker mem_track; + { + base_ptr ptr_owner = make_pointer_deleter_1(); + base_observer_ptr ptr_orig{ptr_owner}; + { + observer_ptr ptr{ + std::move(ptr_orig), static_cast*>(nullptr)}; + + CHECK(ptr.get() == nullptr); + CHECK(ptr.expired() == true); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } + + CHECK_INSTANCES(1, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer move from valid observer explicit conversion constructor subobject", + "[construction][observer][from_observer]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_owner = make_pointer_deleter_1(); - observer_ptr ptr_orig{ptr_owner}; { - state_observer_ptr ptr{std::move(ptr_orig), &ptr_owner->state_}; + TestType ptr_owner = make_pointer_deleter_1(); + observer_ptr ptr_orig{ptr_owner}; + { + state_observer_ptr ptr{std::move(ptr_orig), &ptr_owner->state_}; + + CHECK(ptr.get() == &ptr_owner->state_); + CHECK(ptr.expired() == false); + CHECK(ptr_orig.get() == nullptr); + CHECK(ptr_orig.expired() == true); + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == &ptr_owner->state_); - CHECK(ptr.expired() == false); - CHECK(ptr_orig.get() == nullptr); - CHECK(ptr_orig.expired() == true); CHECK_INSTANCES(1, 1); } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_from_this.cpp b/tests/runtime_tests_observer_from_this.cpp index 5f7295c..3d8e398 100644 --- a/tests/runtime_tests_observer_from_this.cpp +++ b/tests/runtime_tests_observer_from_this.cpp @@ -2,397 +2,416 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("observer from this", "[observer_from_this]", owner_types) { - if constexpr (has_eoft) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - get_object* raw_ptr = ptr.get(); - const get_object* craw_ptr = ptr.get(); - - auto run_checks = [&](auto&& optr, auto&& optr_const) { - using obs_type = std::remove_reference_t; - using const_obs_type = std::remove_reference_t; - CHECK(std::is_const_v == std::is_const_v>); - CHECK(std::is_const_v == true); - - if constexpr (has_eoft_direct_base) { - // For types that inherit directly from eoft. - CHECK((std::is_same_v>) == true); - CHECK((std::is_same_v>) == true); +SUITE { + TEMPLATE_LIST_TEST_CASE("observer from this", "[observer_from_this]", owner_types) { + if constexpr (has_eoft) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + get_object* raw_ptr = ptr.get(); + const get_object* craw_ptr = ptr.get(); + + auto run_checks = [&](auto&& optr, auto&& optr_const) { + using obs_type = std::remove_reference_t; + using const_obs_type = std::remove_reference_t; + CHECK(std::is_const_v == std::is_const_v>); + CHECK(std::is_const_v == true); + + if constexpr (has_eoft_direct_base) { + // For types that inherit directly from eoft. + CHECK((std::is_same_v>) == true); + CHECK((std::is_same_v>) == true); + } else { + // For types that inherit from a base class that inherits from eoft. + CHECK((std::is_base_of_v>) == true); + CHECK( + (std::is_base_of_v< + std::remove_cv_t, get_object>) == true); + } + + CHECK(optr.expired() == false); + CHECK(optr_const.expired() == false); + CHECK(optr.get() == raw_ptr); + CHECK(optr_const.get() == craw_ptr); + CHECK_INSTANCES(1, 1); + }; + + if constexpr (has_eoft_multi_base) { + // Need an explicit choice of which base to call. + auto optr_from_this = raw_ptr->get_eoft::observer_from_this(); + auto optr_from_this_const = craw_ptr->get_eoft::observer_from_this(); + + run_checks(optr_from_this, optr_from_this_const); } else { - // For types that inherit from a base class that inherits from eoft. - CHECK((std::is_base_of_v>) == true); - CHECK( - (std::is_base_of_v< - std::remove_cv_t, get_object>) == true); - } - - CHECK(optr.expired() == false); - CHECK(optr_const.expired() == false); - CHECK(optr.get() == raw_ptr); - CHECK(optr_const.get() == craw_ptr); - CHECK_INSTANCES(1, 1); - }; - - if constexpr (has_eoft_multi_base) { - // Need an explicit choice of which base to call. - auto optr_from_this = raw_ptr->get_eoft::observer_from_this(); - auto optr_from_this_const = craw_ptr->get_eoft::observer_from_this(); - - run_checks(optr_from_this, optr_from_this_const); - } else { - // No ambiguity, just call normally. - auto optr_from_this = raw_ptr->observer_from_this(); - auto optr_from_this_const = craw_ptr->observer_from_this(); + // No ambiguity, just call normally. + auto optr_from_this = raw_ptr->observer_from_this(); + auto optr_from_this_const = craw_ptr->observer_from_this(); - run_checks(optr_from_this, optr_from_this_const); + run_checks(optr_from_this, optr_from_this_const); + } } - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this with no owner heap", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && !must_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this with no owner heap", "[observer_from_this]", owner_types) { + if constexpr (has_eoft && !must_use_make_observable) { + memory_tracker mem_track; - { - get_object* orig_ptr = make_instance(); + { + get_object* orig_ptr = make_instance(); - if constexpr (eoft_always_has_block) { - auto optr = make_observer_from_this(orig_ptr); - auto coptr = make_const_observer_from_this(orig_ptr); + if constexpr (eoft_always_has_block) { + auto optr = make_observer_from_this(orig_ptr); + auto coptr = make_const_observer_from_this(orig_ptr); - CHECK(optr.expired() == false); - CHECK(optr.get() == orig_ptr); - CHECK(coptr.expired() == false); - CHECK(coptr.get() == orig_ptr); - } else { - REQUIRE_THROWS_MATCHES( - (make_observer_from_this(orig_ptr)), oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); - REQUIRE_THROWS_MATCHES( - (make_const_observer_from_this(orig_ptr)), - oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); - } + CHECK(optr.expired() == false); + CHECK(optr.get() == orig_ptr); + CHECK(coptr.expired() == false); + CHECK(coptr.get() == orig_ptr); + } else { + REQUIRE_THROWS_MATCHES( + (make_observer_from_this(orig_ptr)), oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + REQUIRE_THROWS_MATCHES( + (make_const_observer_from_this(orig_ptr)), + oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + } - CHECK_INSTANCES(1, 0); + CHECK_INSTANCES(1, 0); - delete orig_ptr; - } + delete orig_ptr; + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("observer from this no owner stack", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && !eoft_constructor_takes_control_block) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this no owner stack", "[observer_from_this]", owner_types) { + if constexpr (has_eoft && !eoft_constructor_takes_control_block) { + memory_tracker mem_track; - { - get_object obj; + { + get_object obj; - if constexpr (eoft_always_has_block) { - auto optr = make_observer_from_this(&obj); - auto coptr = make_const_observer_from_this(&obj); + if constexpr (eoft_always_has_block) { + auto optr = make_observer_from_this(&obj); + auto coptr = make_const_observer_from_this(&obj); - CHECK(optr.expired() == false); - CHECK(optr.get() == &obj); - CHECK(coptr.expired() == false); - CHECK(coptr.get() == &obj); - } else { - REQUIRE_THROWS_MATCHES( - (make_observer_from_this(&obj)), oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); - REQUIRE_THROWS_MATCHES( - (make_const_observer_from_this(&obj)), oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); + CHECK(optr.expired() == false); + CHECK(optr.get() == &obj); + CHECK(coptr.expired() == false); + CHECK(coptr.get() == &obj); + } else { + REQUIRE_THROWS_MATCHES( + (make_observer_from_this(&obj)), oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + REQUIRE_THROWS_MATCHES( + (make_const_observer_from_this(&obj)), + oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + } + + CHECK_INSTANCES(1, 0); } - CHECK_INSTANCES(1, 0); + CHECK_NO_LEAKS; } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer from this acquired into base owner as base", "[observer_from_this]", + owner_types) { + if constexpr (has_eoft && !must_use_make_observable) { + memory_tracker mem_track; + + { + get_object* orig_ptr = make_instance(); + get_base_object* orig_base_ptr = orig_ptr; + base_ptr ptr{orig_base_ptr}; + + if constexpr (eoft_always_has_block) { + auto optr = make_observer_from_this(orig_ptr); + auto coptr = make_const_observer_from_this(orig_ptr); + + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr.get()); + CHECK(coptr.expired() == false); + CHECK(coptr.get() == orig_ptr); + CHECK_INSTANCES(1, 1); + } else { + REQUIRE_THROWS_MATCHES( + (make_observer_from_this(orig_ptr)), oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + REQUIRE_THROWS_MATCHES( + (make_const_observer_from_this(orig_ptr)), + oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + } + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this acquired into base owner as base", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && !must_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this acquired into base owner as derived", "[observer_from_this]", + owner_types) { + if constexpr ( + has_eoft && has_base && !must_use_make_observable) { + memory_tracker mem_track; - { - get_object* orig_ptr = make_instance(); - get_base_object* orig_base_ptr = orig_ptr; - base_ptr ptr{orig_base_ptr}; + { + get_object* orig_ptr = make_instance(); + base_ptr ptr{orig_ptr}; - if constexpr (eoft_always_has_block) { - auto optr = make_observer_from_this(orig_ptr); - auto coptr = make_const_observer_from_this(orig_ptr); + base_observer_ptr optr = make_observer_from_this(orig_ptr); CHECK(optr.expired() == false); CHECK(optr.get() == ptr.get()); - CHECK(coptr.expired() == false); - CHECK(coptr.get() == orig_ptr); CHECK_INSTANCES(1, 1); - } else { - REQUIRE_THROWS_MATCHES( - (make_observer_from_this(orig_ptr)), oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); - REQUIRE_THROWS_MATCHES( - (make_const_observer_from_this(orig_ptr)), - oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); } - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this acquired into base owner as derived", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && has_base && !must_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner reset to empty", "[observer_from_this]", owner_types) { + if constexpr (has_eoft) { + memory_tracker mem_track; - { - get_object* orig_ptr = make_instance(); - base_ptr ptr{orig_ptr}; + { + TestType ptr = make_pointer_deleter_1(); + auto optr = make_observer_from_this(ptr.get()); - base_observer_ptr optr = make_observer_from_this(orig_ptr); + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr.get()); + CHECK_INSTANCES(1, 1); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr.get()); - CHECK_INSTANCES(1, 1); - } + ptr.reset(); - CHECK_NO_LEAKS; + CHECK(optr.expired() == true); + CHECK(optr.get() == nullptr); + CHECK_INSTANCES(0, 1); + } + + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner reset to empty", "[observer_from_this]", owner_types) { - if constexpr (has_eoft) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner reset to valid", "[observer_from_this]", owner_types) { + if constexpr (has_eoft && can_reset_to_new) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); - auto optr = make_observer_from_this(ptr.get()); + { + TestType ptr = make_pointer_deleter_1(); + auto optr = make_observer_from_this(ptr.get()); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr.get()); - CHECK_INSTANCES(1, 1); + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr.get()); + CHECK_INSTANCES(1, 1); - ptr.reset(); + ptr.reset(make_instance()); - CHECK(optr.expired() == true); - CHECK(optr.get() == nullptr); - CHECK_INSTANCES(0, 1); - } + CHECK(optr.expired() == true); + CHECK(optr.get() == nullptr); + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner reset to valid", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && can_reset_to_new) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner release", "[observer_from_this]", owner_types) { + if constexpr (has_eoft && can_release) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); - auto optr = make_observer_from_this(ptr.get()); + { + TestType ptr = make_pointer_deleter_1(); + auto optr = make_observer_from_this(ptr.get()); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr.get()); - CHECK_INSTANCES(1, 1); + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr.get()); + CHECK_INSTANCES(1, 1); - ptr.reset(make_instance()); + auto* raw_ptr = ptr.release(); - CHECK(optr.expired() == true); - CHECK(optr.get() == nullptr); - CHECK_INSTANCES(1, 1); - } + CHECK(optr.expired() == false); + CHECK(optr.get() == raw_ptr); + CHECK_INSTANCES(1, 1); - CHECK_NO_LEAKS; - } -}; + delete raw_ptr; -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner release", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && can_release) { - memory_tracker mem_track; + CHECK(optr.expired() == true); + CHECK(optr.get() == nullptr); + CHECK_INSTANCES(0, 1); + } - { - TestType ptr = make_pointer_deleter_1(); - auto optr = make_observer_from_this(ptr.get()); + CHECK_NO_LEAKS; + } + } + | owner_types{}; - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr.get()); - CHECK_INSTANCES(1, 1); + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner release then reset to same", "[observer_from_this]", + owner_types) { + if constexpr (has_eoft && can_release && can_reset_to_new) { + memory_tracker mem_track; - auto* raw_ptr = ptr.release(); + { + TestType ptr = make_pointer_deleter_1(); + auto optr = make_observer_from_this(ptr.get()); - CHECK(optr.expired() == false); - CHECK(optr.get() == raw_ptr); - CHECK_INSTANCES(1, 1); + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr.get()); + CHECK_INSTANCES(1, 1); - delete raw_ptr; + auto* raw_ptr = ptr.release(); - CHECK(optr.expired() == true); - CHECK(optr.get() == nullptr); - CHECK_INSTANCES(0, 1); - } + CHECK(optr.expired() == false); + CHECK(optr.get() == raw_ptr); + CHECK_INSTANCES(1, 1); - CHECK_NO_LEAKS; - } -}; + ptr.reset(raw_ptr); -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner release then reset to same", - "[observer_from_this]", - owner_types) { - if constexpr (has_eoft && can_release && can_reset_to_new) { - memory_tracker mem_track; + CHECK(optr.expired() == false); + CHECK(optr.get() == raw_ptr); + CHECK_INSTANCES(1, 1); - { - TestType ptr = make_pointer_deleter_1(); - auto optr = make_observer_from_this(ptr.get()); + ptr.reset(); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr.get()); - CHECK_INSTANCES(1, 1); + CHECK(optr.expired() == true); + CHECK(optr.get() == nullptr); + CHECK_INSTANCES(0, 1); + } - auto* raw_ptr = ptr.release(); + CHECK_NO_LEAKS; + } + } + | owner_types{}; - CHECK(optr.expired() == false); - CHECK(optr.get() == raw_ptr); - CHECK_INSTANCES(1, 1); + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner move", "[observer_from_this]", owner_types) { + if constexpr (has_eoft) { + memory_tracker mem_track; - ptr.reset(raw_ptr); + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = std::move(ptr1); - CHECK(optr.expired() == false); - CHECK(optr.get() == raw_ptr); - CHECK_INSTANCES(1, 1); + auto optr = make_observer_from_this(ptr2.get()); + auto coptr = make_const_observer_from_this(ptr2.get()); - ptr.reset(); + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr2.get()); + CHECK(coptr.expired() == false); + CHECK(coptr.get() == ptr2.get()); + CHECK_INSTANCES(1, 1); + } - CHECK(optr.expired() == true); - CHECK(optr.get() == nullptr); - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner move", "[observer_from_this]", owner_types) { - if constexpr (has_eoft) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "observer from this after owner move assignment", "[observer_from_this]", owner_types) { + if constexpr (has_eoft) { + memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = std::move(ptr1); + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2; + ptr2 = std::move(ptr1); - auto optr = make_observer_from_this(ptr2.get()); - auto coptr = make_const_observer_from_this(ptr2.get()); + auto optr = make_observer_from_this(ptr2.get()); + auto coptr = make_const_observer_from_this(ptr2.get()); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr2.get()); - CHECK(coptr.expired() == false); - CHECK(coptr.get() == ptr2.get()); - CHECK_INSTANCES(1, 1); - } + CHECK(optr.expired() == false); + CHECK(optr.get() == ptr2.get()); + CHECK(coptr.expired() == false); + CHECK(coptr.get() == ptr2.get()); + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; + + TEST_CASE("observer from this multiple inheritance", "[observer_from_this]") { + using base = test_object_observer_from_this_unique; + using deriv = test_object_observer_from_this_multi_unique; + using ptr_base = oup::observable_unique_ptr; + using ptr_deriv = oup::observable_unique_ptr; + using eoft_base = oup::enable_observer_from_this_unique; + using eoft_deriv = oup::enable_observer_from_this_unique; + using TestType = ptr_deriv; -TEMPLATE_LIST_TEST_CASE( - "observer from this after owner move assignment", "[observer_from_this]", owner_types) { - if constexpr (has_eoft) { memory_tracker mem_track; { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2; - ptr2 = std::move(ptr1); + deriv* raw_ptr_deriv = new deriv; + base* raw_ptr_base = raw_ptr_deriv; + ptr_deriv ptr(raw_ptr_deriv); - auto optr = make_observer_from_this(ptr2.get()); - auto coptr = make_const_observer_from_this(ptr2.get()); + observer_ptr optr_base = ptr->eoft_base::observer_from_this(); + observer_ptr optr_deriv = ptr->eoft_deriv::observer_from_this(); - CHECK(optr.expired() == false); - CHECK(optr.get() == ptr2.get()); - CHECK(coptr.expired() == false); - CHECK(coptr.get() == ptr2.get()); + CHECK(optr_base.expired() == false); + CHECK(optr_deriv.expired() == false); + CHECK(optr_base.get() == raw_ptr_base); + CHECK(optr_deriv.get() == raw_ptr_deriv); CHECK_INSTANCES(1, 1); } CHECK_NO_LEAKS; - } -}; + }; -TEST_CASE("observer from this multiple inheritance", "[observer_from_this]") { - using base = test_object_observer_from_this_unique; - using deriv = test_object_observer_from_this_multi_unique; - using ptr_base = oup::observable_unique_ptr; - using ptr_deriv = oup::observable_unique_ptr; - using eoft_base = oup::enable_observer_from_this_unique; - using eoft_deriv = oup::enable_observer_from_this_unique; - using TestType = ptr_deriv; - - memory_tracker mem_track; - - { - deriv* raw_ptr_deriv = new deriv; - base* raw_ptr_base = raw_ptr_deriv; - ptr_deriv ptr(raw_ptr_deriv); - - observer_ptr optr_base = ptr->eoft_base::observer_from_this(); - observer_ptr optr_deriv = ptr->eoft_deriv::observer_from_this(); - - CHECK(optr_base.expired() == false); - CHECK(optr_deriv.expired() == false); - CHECK(optr_base.get() == raw_ptr_base); - CHECK(optr_deriv.get() == raw_ptr_deriv); - CHECK_INSTANCES(1, 1); - } + TEMPLATE_LIST_TEST_CASE( + "observer from this in constructor", "[observer_from_this]", owner_types) { + if constexpr (has_eoft && has_eoft_self_member) { + memory_tracker mem_track; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer from this in constructor", "[observer_from_this]", owner_types) { - if constexpr (has_eoft && has_eoft_self_member) { - memory_tracker mem_track; + if constexpr (eoft_always_has_block) { + next_test_object_constructor_calls_observer_from_this = true; + TestType ptr = make_pointer_deleter_1(); + next_test_object_constructor_calls_observer_from_this = false; + CHECK(ptr->self == ptr.get()); - if constexpr (eoft_always_has_block) { - next_test_object_constructor_calls_observer_from_this = true; - TestType ptr = make_pointer_deleter_1(); - next_test_object_constructor_calls_observer_from_this = false; - CHECK(ptr->self == ptr.get()); + CHECK_INSTANCES(1, 1); + } else { + next_test_object_constructor_calls_observer_from_this = true; + REQUIRE_THROWS_MATCHES( + (make_pointer_deleter_1()), oup::bad_observer_from_this, + snatch::matchers::with_what_contains{ + "observer_from_this() called with uninitialized control block"}); + next_test_object_constructor_calls_observer_from_this = false; + } - CHECK_INSTANCES(1, 1); - } else { - next_test_object_constructor_calls_observer_from_this = true; - REQUIRE_THROWS_MATCHES( - (make_pointer_deleter_1()), oup::bad_observer_from_this, - snatch::matchers::with_what_contains{ - "observer_from_this() called with uninitialized control block"}); - next_test_object_constructor_calls_observer_from_this = false; + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } + | owner_types{}; }; diff --git a/tests/runtime_tests_observer_misc.cpp b/tests/runtime_tests_observer_misc.cpp index 6ffa6ff..3fc999a 100644 --- a/tests/runtime_tests_observer_misc.cpp +++ b/tests/runtime_tests_observer_misc.cpp @@ -2,234 +2,252 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("observer size", "[size][observer]", owner_types) { - CHECK(sizeof(observer_ptr) == 2 * sizeof(void*)); -}; - -TEMPLATE_LIST_TEST_CASE("observer reset to null", "[reset][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr.reset(); - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); - CHECK_INSTANCES(1, 1); +SUITE { + TEMPLATE_LIST_TEST_CASE("observer size", "[size][observer]", owner_types) { + CHECK(sizeof(observer_ptr) == 2 * sizeof(void*)); } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer reset to null", "[reset][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + optr.reset(); + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer swap empty vs empty", "[swap][observer]", owner_types) { - memory_tracker mem_track; - - { - observer_ptr optr1; - observer_ptr optr2; - optr2.swap(optr1); - CHECK_INSTANCES(0, 0); - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() == nullptr); - CHECK(optr1.expired() == true); - CHECK(optr2.expired() == true); + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer swap empty vs empty", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + observer_ptr optr1; + observer_ptr optr2; + optr2.swap(optr1); + CHECK_INSTANCES(0, 0); + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() == nullptr); + CHECK(optr1.expired() == true); + CHECK(optr2.expired() == true); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer swap valid vs empty", "[swap][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr1 = make_pointer_deleter_1(); - observer_ptr optr1{ptr1}; - observer_ptr optr2; - optr2.swap(optr1); - CHECK_INSTANCES(1, 1); - CHECK(optr1.get() == nullptr); - CHECK(optr2.get() != nullptr); - CHECK(optr2.get() == ptr1.get()); - CHECK(optr1.expired() == true); - CHECK(optr2.expired() == false); + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer swap valid vs empty", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr1 = make_pointer_deleter_1(); + observer_ptr optr1{ptr1}; + observer_ptr optr2; + optr2.swap(optr1); + CHECK_INSTANCES(1, 1); + CHECK(optr1.get() == nullptr); + CHECK(optr2.get() != nullptr); + CHECK(optr2.get() == ptr1.get()); + CHECK(optr1.expired() == true); + CHECK(optr2.expired() == false); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer swap empty vs valid", "[swap][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr2 = make_pointer_deleter_2(); - observer_ptr optr1; - observer_ptr optr2{ptr2}; - optr2.swap(optr1); - CHECK_INSTANCES(1, 1); - CHECK(optr1.get() != nullptr); - CHECK(optr1.get() == ptr2.get()); - CHECK(optr2.get() == nullptr); - CHECK(optr1.expired() == false); - CHECK(optr2.expired() == true); + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer swap empty vs valid", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr2 = make_pointer_deleter_2(); + observer_ptr optr1; + observer_ptr optr2{ptr2}; + optr2.swap(optr1); + CHECK_INSTANCES(1, 1); + CHECK(optr1.get() != nullptr); + CHECK(optr1.get() == ptr2.get()); + CHECK(optr2.get() == nullptr); + CHECK(optr1.expired() == false); + CHECK(optr2.expired() == true); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer swap valid vs valid", "[swap][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - observer_ptr optr1{ptr1}; - observer_ptr optr2{ptr2}; - optr2.swap(optr1); - CHECK_INSTANCES(2, 2); - CHECK(optr1.get() != ptr1.get()); - CHECK(optr1.get() == ptr2.get()); - CHECK(optr2.get() != ptr2.get()); - CHECK(optr2.get() == ptr1.get()); - CHECK(optr1.expired() == false); - CHECK(optr2.expired() == false); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "observer swap valid vs valid same instance", "[swap][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr1{ptr}; - observer_ptr optr2{ptr}; - optr2.swap(optr1); - CHECK_INSTANCES(1, 1); - CHECK(optr1.get() == ptr.get()); - CHECK(optr2.get() == ptr.get()); - CHECK(optr1.expired() == false); - CHECK(optr2.expired() == false); + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer swap valid vs valid", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + observer_ptr optr1{ptr1}; + observer_ptr optr2{ptr2}; + optr2.swap(optr1); + CHECK_INSTANCES(2, 2); + CHECK(optr1.get() != ptr1.get()); + CHECK(optr1.get() == ptr2.get()); + CHECK(optr2.get() != ptr2.get()); + CHECK(optr2.get() == ptr1.get()); + CHECK(optr1.expired() == false); + CHECK(optr2.expired() == false); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer swap self vs self empty", "[swap][observer]", owner_types) { - memory_tracker mem_track; + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "observer swap valid vs valid same instance", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr1{ptr}; + observer_ptr optr2{ptr}; + optr2.swap(optr1); + CHECK_INSTANCES(1, 1); + CHECK(optr1.get() == ptr.get()); + CHECK(optr2.get() == ptr.get()); + CHECK(optr1.expired() == false); + CHECK(optr2.expired() == false); + } - { - observer_ptr optr; - optr.swap(optr); - CHECK_INSTANCES(0, 0); - CHECK(optr.get() == nullptr); - CHECK(optr.expired() == true); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("observer swap self vs self empty", "[swap][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer swap self vs self valid", "[swap][observer]", owner_types) { - memory_tracker mem_track; + { + observer_ptr optr; + optr.swap(optr); + CHECK_INSTANCES(0, 0); + CHECK(optr.get() == nullptr); + CHECK(optr.expired() == true); + } - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - optr.swap(optr); - CHECK_INSTANCES(1, 1); - CHECK(optr.get() == ptr.get()); - CHECK(optr.expired() == false); + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer swap self vs self valid", "[swap][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + optr.swap(optr); + CHECK_INSTANCES(1, 1); + CHECK(optr.get() == ptr.get()); + CHECK(optr.expired() == false); + } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer dereference valid", "[dereference][observer]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - CHECK(optr->state_ == test_object::state::default_init); - CHECK((*optr).state_ == test_object::state::default_init); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("observer dereference valid", "[dereference][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer get valid", "[get][observer]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + CHECK(optr->state_ == test_object::state::default_init); + CHECK((*optr).state_ == test_object::state::default_init); + } - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - CHECK(optr.get() != nullptr); - CHECK(optr.get()->state_ == test_object::state::default_init); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("observer get valid", "[get][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer get empty", "[get][observer]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + CHECK(optr.get() != nullptr); + CHECK(optr.get()->state_ == test_object::state::default_init); + } - { - observer_ptr optr; - CHECK(optr.get() == nullptr); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("observer get empty", "[get][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer raw_get valid", "[raw_get][observer]", owner_types) { - memory_tracker mem_track; + { + observer_ptr optr; + CHECK(optr.get() == nullptr); + } - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - CHECK(optr.raw_get() != nullptr); - CHECK(optr.raw_get()->state_ == test_object::state::default_init); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("observer raw_get valid", "[raw_get][observer]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("observer raw_get empty", "[raw_get][observer]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + CHECK(optr.raw_get() != nullptr); + CHECK(optr.raw_get()->state_ == test_object::state::default_init); + } - { - observer_ptr optr; - CHECK(optr.raw_get() == nullptr); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("observer operator bool valid", "[bool][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("observer raw_get empty", "[raw_get][observer]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); - observer_ptr optr{ptr}; - if (optr) { - } else { - FAIL("if (optr) should have been true"); + { + observer_ptr optr; + CHECK(optr.raw_get() == nullptr); } + + CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("observer operator bool valid", "[bool][observer]", owner_types) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + observer_ptr optr{ptr}; + if (optr) { + } else { + FAIL("if (optr) should have been true"); + } + } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("observer operator bool empty", "[bool][observer]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("observer operator bool empty", "[bool][observer]", owner_types) { + memory_tracker mem_track; - { - observer_ptr optr; - if (optr) { - FAIL("if (optr) should have been false"); + { + observer_ptr optr; + if (optr) { + FAIL("if (optr) should have been false"); + } } - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } + | owner_types{}; }; diff --git a/tests/runtime_tests_owner_assignment_move.cpp b/tests/runtime_tests_owner_assignment_move.cpp index 0ac9c0d..2815157 100644 --- a/tests/runtime_tests_owner_assignment_move.cpp +++ b/tests/runtime_tests_owner_assignment_move.cpp @@ -2,232 +2,240 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator valid to empty", "[assignment][owner]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator valid to empty", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); { - TestType ptr = make_empty_pointer_deleter_2(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_pointer_deleter_1(); + { + TestType ptr = make_empty_pointer_deleter_2(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(1, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator empty to valid", "[assignment][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator empty to valid", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_empty_pointer_deleter_1(); { - TestType ptr = make_pointer_deleter_2(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_empty_pointer_deleter_1(); + { + TestType ptr = make_pointer_deleter_2(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 2); } - CHECK_INSTANCES(0, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator empty to empty", "[assignment][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator empty to empty", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_empty_pointer_deleter_1(); { - TestType ptr = make_empty_pointer_deleter_2(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_empty_pointer_deleter_1(); + { + TestType ptr = make_empty_pointer_deleter_2(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 2); } - CHECK_INSTANCES(0, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator valid to valid", "[assignment][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator valid to valid", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); - auto* raw_ptr_orig = ptr_orig.get(); { - TestType ptr = make_pointer_deleter_1(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == raw_ptr_orig); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_pointer_deleter_1(); + auto* raw_ptr_orig = ptr_orig.get(); + { + TestType ptr = make_pointer_deleter_1(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == raw_ptr_orig); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(1, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment converting operator valid to empty", - "[assignment][owner]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment converting operator valid to empty", "[assignment][owner]", + owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); { - base_ptr ptr = make_empty_pointer_deleter_2>(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_pointer_deleter_1(); + { + base_ptr ptr = make_empty_pointer_deleter_2>(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(1, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment converting operator empty to valid", "[assignment][owner]", + owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE( - "owner move assignment converting operator empty to valid", - "[assignment][owner]", - owner_types) { - memory_tracker mem_track; - - { - TestType ptr_orig = make_empty_pointer_deleter_1(); { - base_ptr ptr = make_pointer_deleter_2>(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_empty_pointer_deleter_1(); + { + base_ptr ptr = make_pointer_deleter_2>(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 2); } - CHECK_INSTANCES(0, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment converting operator empty to empty", - "[assignment][owner]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment converting operator empty to empty", "[assignment][owner]", + owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_empty_pointer_deleter_1(); { - base_ptr ptr = make_empty_pointer_deleter_2>(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_empty_pointer_deleter_1(); + { + base_ptr ptr = make_empty_pointer_deleter_2>(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 2); } - CHECK_INSTANCES(0, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment converting operator valid to valid", - "[assignment][owner]", - owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment converting operator valid to valid", "[assignment][owner]", + owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); - auto* raw_ptr_orig = ptr_orig.get(); { - base_ptr ptr = make_pointer_deleter_1>(); - ptr = std::move(ptr_orig); - - CHECK(ptr.get() == raw_ptr_orig); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + TestType ptr_orig = make_pointer_deleter_1(); + auto* raw_ptr_orig = ptr_orig.get(); + { + base_ptr ptr = make_pointer_deleter_1>(); + ptr = std::move(ptr_orig); + + CHECK(ptr.get() == raw_ptr_orig); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(1, 2); + + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator self to self valid", "[assignment][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator self to self valid", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); - ptr = std::move(ptr); + { + TestType ptr = make_pointer_deleter_1(); + ptr = std::move(ptr); - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::empty); + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::empty); + } + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner move assignment operator self to self empty", "[assignment][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner move assignment operator self to self empty", "[assignment][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_empty_pointer_deleter_1(); - ptr = std::move(ptr); + { + TestType ptr = make_empty_pointer_deleter_1(); + ptr = std::move(ptr); - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::empty); + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::empty); + } + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } + | owner_types{}; }; diff --git a/tests/runtime_tests_owner_cast_move.cpp b/tests/runtime_tests_owner_cast_move.cpp index 2b36524..5892025 100644 --- a/tests/runtime_tests_owner_cast_move.cpp +++ b/tests/runtime_tests_owner_cast_move.cpp @@ -5,130 +5,76 @@ // For std::bad_cast #include -TEMPLATE_LIST_TEST_CASE("owner static_cast move from valid", "[cast][owner]", owner_types) { - memory_tracker mem_track; - - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr1.get(); - auto ptr2 = oup::static_pointer_cast(std::move(ptr1)); - - using return_type = std::remove_cv_t; - - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - if constexpr (has_stateful_deleter) { - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(1, 2); - }; - - run_test.template operator(), TestType>(); - run_test.template operator(), const_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_ptr>(); - } - } - - CHECK_NO_LEAKS; -}; +SUITE { + TEMPLATE_LIST_TEST_CASE("owner static_cast move from valid", "[cast][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner static_cast move from empty", "[cast][owner]", owner_types) { - memory_tracker mem_track; + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr1.get(); + auto ptr2 = oup::static_pointer_cast(std::move(ptr1)); - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - auto ptr2 = oup::static_pointer_cast(std::move(ptr1)); + using return_type = std::remove_cv_t; - using return_type = std::remove_cv_t; + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() == raw_ptr); + CHECK(snatch::type_name == snatch::type_name); + if constexpr (has_stateful_deleter) { + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); + }; - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - if constexpr (has_stateful_deleter) { - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + run_test.template operator(), TestType>(); + run_test.template operator(), const_ptr>(); + if constexpr (has_base) { + run_test.template operator(), base_ptr>(); } - CHECK_INSTANCES(0, 2); - }; - - run_test.template operator(), TestType>(); - run_test.template operator(), const_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_ptr>(); } - } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner const_cast move from valid", "[cast][owner]", owner_types) { - memory_tracker mem_track; - - { - auto run_test = [&]() { - TestType ptr1 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr1.get(); - auto ptr2 = oup::const_pointer_cast(std::move(ptr1)); - - using return_type = std::remove_cv_t; - - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() == raw_ptr); - CHECK(snatch::type_name == snatch::type_name); - if constexpr (has_stateful_deleter) { - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(1, 2); - }; - - run_test.template operator(), const_ptr>(); - run_test - .template operator()>, mutable_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner static_cast move from empty", "[cast][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner const_cast move from empty", "[cast][owner]", owner_types) { - memory_tracker mem_track; + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + auto ptr2 = oup::static_pointer_cast(std::move(ptr1)); - { - auto run_test = [&]() { - TestType ptr1 = make_empty_pointer_deleter_1(); - auto ptr2 = oup::const_pointer_cast(std::move(ptr1)); + using return_type = std::remove_cv_t; - using return_type = std::remove_cv_t; + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() == nullptr); + CHECK(snatch::type_name == snatch::type_name); + if constexpr (has_stateful_deleter) { + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 2); + }; - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() == nullptr); - CHECK(snatch::type_name == snatch::type_name); - if constexpr (has_stateful_deleter) { - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + run_test.template operator(), TestType>(); + run_test.template operator(), const_ptr>(); + if constexpr (has_base) { + run_test.template operator(), base_ptr>(); } - CHECK_INSTANCES(0, 2); - }; + } - run_test.template operator(), const_ptr>(); - run_test - .template operator()>, mutable_ptr>(); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from valid", "[cast][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner const_cast move from valid", "[cast][owner]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr0.get(); - start_type ptr1 = std::move(ptr0); - auto ptr2 = oup::dynamic_pointer_cast(std::move(ptr1)); + { + auto run_test = [&]() { + TestType ptr1 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr1.get(); + auto ptr2 = oup::const_pointer_cast(std::move(ptr1)); using return_type = std::remove_cv_t; @@ -138,29 +84,25 @@ TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from valid", "[cast][owner]", o if constexpr (has_stateful_deleter) { CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); } - CHECK_INSTANCES(1, 3); + CHECK_INSTANCES(1, 2); }; - run_test.template operator(), TestType>(); - run_test.template operator(), const_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_ptr>(); - run_test.template operator(), get_object, TestType>(); + run_test.template operator(), const_ptr>(); + run_test.template + operator()>, mutable_ptr>(); } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from empty", "[cast][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner const_cast move from empty", "[cast][owner]", owner_types) { + memory_tracker mem_track; - { - auto run_test = - [&]() { - TestType ptr0 = make_empty_pointer_deleter_1(); - start_type ptr1 = std::move(ptr0); - auto ptr2 = oup::dynamic_pointer_cast(std::move(ptr1)); + { + auto run_test = [&]() { + TestType ptr1 = make_empty_pointer_deleter_1(); + auto ptr2 = oup::const_pointer_cast(std::move(ptr1)); using return_type = std::remove_cv_t; @@ -170,39 +112,113 @@ TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from empty", "[cast][owner]", o if constexpr (has_stateful_deleter) { CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); } - CHECK_INSTANCES(0, 3); + CHECK_INSTANCES(0, 2); }; - run_test.template operator(), TestType>(); - run_test.template operator(), const_ptr>(); - if constexpr (has_base) { - run_test.template operator(), base_ptr>(); - run_test.template operator(), get_object, TestType>(); + run_test.template operator(), const_ptr>(); + run_test.template + operator()>, mutable_ptr>(); } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from invalid", "[cast][owner]", owner_types) { - if constexpr (has_base) { + TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from valid", "[cast][owner]", owner_types) { memory_tracker mem_track; { - TestType ptr0 = make_pointer_deleter_1(); - get_object* raw_ptr = ptr0.get(); - base_ptr ptr1 = std::move(ptr0); + auto run_test = + [&]() { + TestType ptr0 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr0.get(); + start_type ptr1 = std::move(ptr0); + auto ptr2 = oup::dynamic_pointer_cast(std::move(ptr1)); + + using return_type = std::remove_cv_t; + + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() == raw_ptr); + CHECK( + snatch::type_name == snatch::type_name); + if constexpr (has_stateful_deleter) { + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 3); + }; + + run_test.template operator(), TestType>(); + run_test + .template operator(), const_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_ptr>(); + run_test.template operator(), get_object, TestType>(); + } + } - CHECK_THROWS_AS( - (oup::dynamic_pointer_cast(std::move(ptr1))), std::bad_cast); + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from empty", "[cast][owner]", owner_types) { + memory_tracker mem_track; - CHECK(ptr1.get() == raw_ptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_1); + { + auto run_test = + [&]() { + TestType ptr0 = make_empty_pointer_deleter_1(); + start_type ptr1 = std::move(ptr0); + auto ptr2 = oup::dynamic_pointer_cast(std::move(ptr1)); + + using return_type = std::remove_cv_t; + + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() == nullptr); + CHECK( + snatch::type_name == snatch::type_name); + if constexpr (has_stateful_deleter) { + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 3); + }; + + run_test.template operator(), TestType>(); + run_test + .template operator(), const_ptr>(); + if constexpr (has_base) { + run_test + .template operator(), base_ptr>(); + run_test.template operator(), get_object, TestType>(); } - CHECK_INSTANCES(1, 2); } CHECK_NO_LEAKS; } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("owner dynamic_cast move from invalid", "[cast][owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + TestType ptr0 = make_pointer_deleter_1(); + get_object* raw_ptr = ptr0.get(); + base_ptr ptr1 = std::move(ptr0); + + CHECK_THROWS_AS( + (oup::dynamic_pointer_cast(std::move(ptr1))), + std::bad_cast); + + CHECK(ptr1.get() == raw_ptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; }; diff --git a/tests/runtime_tests_owner_comparison.cpp b/tests/runtime_tests_owner_comparison.cpp index 4f1903b..b02d7d7 100644 --- a/tests/runtime_tests_owner_comparison.cpp +++ b/tests/runtime_tests_owner_comparison.cpp @@ -2,80 +2,89 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("owner comparison valid vs nullptr", "[comparison][owner]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE( + "owner comparison valid vs nullptr", "[comparison][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); + { + TestType ptr = make_pointer_deleter_1(); - CHECK(ptr != nullptr); - CHECK(!(ptr == nullptr)); - CHECK(nullptr != ptr); - CHECK(!(nullptr == ptr)); + CHECK(ptr != nullptr); + CHECK(!(ptr == nullptr)); + CHECK(nullptr != ptr); + CHECK(!(nullptr == ptr)); + } + + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE( + "owner comparison empty vs nullptr", "[comparison][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner comparison empty vs nullptr", "[comparison][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_empty_pointer_deleter_1(); - { - TestType ptr = make_empty_pointer_deleter_1(); + CHECK(ptr == nullptr); + CHECK(!(ptr != nullptr)); + CHECK(nullptr == ptr); + CHECK(!(nullptr != ptr)); + } - CHECK(ptr == nullptr); - CHECK(!(ptr != nullptr)); - CHECK(nullptr == ptr); - CHECK(!(nullptr != ptr)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner comparison empty vs empty", "[comparison][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner comparison empty vs empty", "[comparison][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr1 = make_empty_pointer_deleter_1(); + TestType ptr2 = make_empty_pointer_deleter_2(); - { - TestType ptr1 = make_empty_pointer_deleter_1(); - TestType ptr2 = make_empty_pointer_deleter_2(); + CHECK(ptr1 == ptr2); + CHECK(ptr2 == ptr1); + CHECK(!(ptr1 != ptr2)); + CHECK(!(ptr2 != ptr1)); + } - CHECK(ptr1 == ptr2); - CHECK(ptr2 == ptr1); - CHECK(!(ptr1 != ptr2)); - CHECK(!(ptr2 != ptr1)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner comparison empty vs valid", "[comparison][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner comparison empty vs valid", "[comparison][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr1 = make_empty_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); - { - TestType ptr1 = make_empty_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); + CHECK(ptr1 != ptr2); + CHECK(ptr2 != ptr1); + CHECK(!(ptr1 == ptr2)); + CHECK(!(ptr2 == ptr1)); + } - CHECK(ptr1 != ptr2); - CHECK(ptr2 != ptr1); - CHECK(!(ptr1 == ptr2)); - CHECK(!(ptr2 == ptr1)); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner comparison valid vs valid", "[comparison][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner comparison valid vs valid", "[comparison][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); + CHECK(ptr1 != ptr2); + CHECK(ptr2 != ptr1); + CHECK(!(ptr1 == ptr2)); + CHECK(!(ptr2 == ptr1)); + } - CHECK(ptr1 != ptr2); - CHECK(ptr2 != ptr1); - CHECK(!(ptr1 == ptr2)); - CHECK(!(ptr2 == ptr1)); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; + | owner_types{}; }; diff --git a/tests/runtime_tests_owner_construction.cpp b/tests/runtime_tests_owner_construction.cpp index 5559823..81df825 100644 --- a/tests/runtime_tests_owner_construction.cpp +++ b/tests/runtime_tests_owner_construction.cpp @@ -2,282 +2,297 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("owner default constructor", "[construction][owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr; - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); - } - CHECK_INSTANCES(0, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner nullptr constructor", "[construction][owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr(nullptr); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); - } - CHECK_INSTANCES(0, 1); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner move constructor", "[construction][owner]", owner_types) { - memory_tracker mem_track; +SUITE { + TEMPLATE_LIST_TEST_CASE("owner default constructor", "[construction][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); { - TestType ptr(std::move(ptr_orig)); + TestType ptr; - CHECK(ptr.get() != nullptr); + CHECK(ptr.get() == nullptr); if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); } - CHECK_INSTANCES(1, 2); + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner acquiring constructor", "[construction][owner]", owner_types) { - if constexpr (!must_use_make_observable) { + TEMPLATE_LIST_TEST_CASE("owner nullptr constructor", "[construction][owner]", owner_types) { memory_tracker mem_track; { - TestType ptr(make_instance()); + TestType ptr(nullptr); - CHECK(ptr.get() != nullptr); + CHECK(ptr.get() == nullptr); if constexpr (has_stateful_deleter) { CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); } - CHECK_INSTANCES(1, 1); + CHECK_INSTANCES(0, 1); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner acquiring constructor with deleter", "[construction][owner]", owner_types) { - if constexpr (!must_use_make_observable && has_stateful_deleter) { + TEMPLATE_LIST_TEST_CASE("owner move constructor", "[construction][owner]", owner_types) { memory_tracker mem_track; { - TestType ptr(make_instance(), make_deleter_instance_1()); + TestType ptr_orig = make_pointer_deleter_1(); + { + TestType ptr(std::move(ptr_orig)); - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(1, 1); + + CHECK_INSTANCES(0, 1); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner acquiring constructor bad alloc", "[construction][owner]", owner_types) { - if constexpr (!must_use_make_observable) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner acquiring constructor", "[construction][owner]", owner_types) { + if constexpr (!must_use_make_observable) { + memory_tracker mem_track; - { - auto* raw_ptr = make_instance(); - if constexpr (eoft_allocates) { - fail_next_allocation{}, TestType{raw_ptr}; - } else { - REQUIRE_THROWS_AS((fail_next_allocation{}, TestType{raw_ptr}), std::bad_alloc); + { + TestType ptr(make_instance()); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); + } + CHECK_INSTANCES(1, 1); } - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner acquiring constructor bad alloc with deleter", "[construction][owner]", owner_types) { - if constexpr (!must_use_make_observable && has_stateful_deleter) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner acquiring constructor with deleter", "[construction][owner]", owner_types) { + if constexpr (!must_use_make_observable && has_stateful_deleter) { + memory_tracker mem_track; - { - auto* raw_ptr = make_instance(); - auto deleter = make_deleter_instance_1(); - if constexpr (eoft_allocates) { - fail_next_allocation{}, TestType{raw_ptr, deleter}; - } else { - REQUIRE_THROWS_AS( - (fail_next_allocation{}, TestType{raw_ptr, deleter}), std::bad_alloc); + { + TestType ptr(make_instance(), make_deleter_instance_1()); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); } - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner acquiring constructor null", "[construction][owner]", owner_types) { - if constexpr (!must_use_make_observable) { - memory_tracker mem_track; - - { - TestType ptr(static_cast*>(nullptr)); + TEMPLATE_LIST_TEST_CASE( + "owner acquiring constructor bad alloc", "[construction][owner]", owner_types) { + if constexpr (!must_use_make_observable) { + memory_tracker mem_track; - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); + { + auto* raw_ptr = make_instance(); + if constexpr (eoft_allocates) { + fail_next_allocation{}, TestType{raw_ptr}; + } else { + REQUIRE_THROWS_AS((fail_next_allocation{}, TestType{raw_ptr}), std::bad_alloc); + } } - CHECK_INSTANCES(0, 1); - } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner implicit conversion constructor", "[construction][owner]", owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner acquiring constructor bad alloc with deleter", "[construction][owner]", + owner_types) { + if constexpr (!must_use_make_observable && has_stateful_deleter) { + memory_tracker mem_track; - { - TestType ptr_orig = make_pointer_deleter_1(); { - base_ptr ptr(std::move(ptr_orig)); - - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + auto* raw_ptr = make_instance(); + auto deleter = make_deleter_instance_1(); + if constexpr (eoft_allocates) { + fail_next_allocation{}, TestType{raw_ptr, deleter}; + } else { + REQUIRE_THROWS_AS( + (fail_next_allocation{}, TestType{raw_ptr, deleter}), std::bad_alloc); } - CHECK_INSTANCES_DERIVED(1, 1, 2); } - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES_DERIVED(0, 0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner explicit conversion constructor", "[construction][owner]", owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner acquiring constructor null", "[construction][owner]", owner_types) { + if constexpr (!must_use_make_observable) { + memory_tracker mem_track; - { - base_ptr ptr_orig = make_pointer_deleter_1(); { - TestType ptr( - std::move(ptr_orig), dynamic_cast*>(ptr_orig.get())); + TestType ptr(static_cast*>(nullptr)); - CHECK(ptr.get() != nullptr); + CHECK(ptr.get() == nullptr); if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr.get_deleter().state_ == test_deleter::state::default_init); } - CHECK_INSTANCES_DERIVED(1, 1, 2); + CHECK_INSTANCES(0, 1); } - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES_DERIVED(0, 0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner explicit conversion constructor with custom deleter", - "[construction][owner]", - owner_types) { - if constexpr (has_base && has_stateful_deleter) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner implicit conversion constructor", "[construction][owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_orig = make_pointer_deleter_1(); { - TestType ptr( - std::move(ptr_orig), dynamic_cast*>(ptr_orig.get()), - make_deleter_instance_2()); - - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_2); + TestType ptr_orig = make_pointer_deleter_1(); + { + base_ptr ptr(std::move(ptr_orig)); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES_DERIVED(1, 1, 2); } - CHECK_INSTANCES_DERIVED(1, 1, 2); + + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES_DERIVED(0, 0, 1); } - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES_DERIVED(0, 0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner explicit conversion constructor with null", "[construction][owner]", owner_types) { - if constexpr (has_base) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner explicit conversion constructor", "[construction][owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; - { - base_ptr ptr_orig = make_pointer_deleter_1(); { - TestType ptr(std::move(ptr_orig), static_cast*>(nullptr)); - - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + base_ptr ptr_orig = make_pointer_deleter_1(); + { + TestType ptr( + std::move(ptr_orig), dynamic_cast*>(ptr_orig.get())); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES_DERIVED(1, 1, 2); } - CHECK_INSTANCES_DERIVED(0, 0, 2); + + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES_DERIVED(0, 0, 1); } - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES_DERIVED(0, 0, 1); + CHECK_NO_LEAKS; } - - CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE( - "owner explicit conversion constructor with custom deleter with null", - "[construction][owner]", - owner_types) { - if constexpr (has_base && has_stateful_deleter) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE( + "owner explicit conversion constructor with custom deleter", "[construction][owner]", + owner_types) { + if constexpr (has_base && has_stateful_deleter) { + memory_tracker mem_track; - { - base_ptr ptr_orig = make_pointer_deleter_1(); { - TestType ptr( - std::move(ptr_orig), static_cast*>(nullptr), - make_deleter_instance_2()); + base_ptr ptr_orig = make_pointer_deleter_1(); + { + TestType ptr( + std::move(ptr_orig), dynamic_cast*>(ptr_orig.get()), + make_deleter_instance_2()); + + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_2); + } + CHECK_INSTANCES_DERIVED(1, 1, 2); + } - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_2); + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES_DERIVED(0, 0, 1); + } + + CHECK_NO_LEAKS; + } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE( + "owner explicit conversion constructor with null", "[construction][owner]", owner_types) { + if constexpr (has_base) { + memory_tracker mem_track; + + { + base_ptr ptr_orig = make_pointer_deleter_1(); + { + TestType ptr(std::move(ptr_orig), static_cast*>(nullptr)); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES_DERIVED(0, 0, 2); } - CHECK_INSTANCES_DERIVED(0, 0, 2); + + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES_DERIVED(0, 0, 1); } - CHECK(ptr_orig.get() == nullptr); - CHECK_INSTANCES_DERIVED(0, 0, 1); + CHECK_NO_LEAKS; } + } + | owner_types{}; - CHECK_NO_LEAKS; + TEMPLATE_LIST_TEST_CASE( + "owner explicit conversion constructor with custom deleter with null", + "[construction][owner]", owner_types) { + if constexpr (has_base && has_stateful_deleter) { + memory_tracker mem_track; + + { + base_ptr ptr_orig = make_pointer_deleter_1(); + { + TestType ptr( + std::move(ptr_orig), static_cast*>(nullptr), + make_deleter_instance_2()); + + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_2); + } + CHECK_INSTANCES_DERIVED(0, 0, 2); + } + + CHECK(ptr_orig.get() == nullptr); + CHECK_INSTANCES_DERIVED(0, 0, 1); + } + + CHECK_NO_LEAKS; + } } + | owner_types{}; }; diff --git a/tests/runtime_tests_owner_misc.cpp b/tests/runtime_tests_owner_misc.cpp index 951e04d..37b6dbc 100644 --- a/tests/runtime_tests_owner_misc.cpp +++ b/tests/runtime_tests_owner_misc.cpp @@ -2,322 +2,341 @@ #include "testing.hpp" #include "tests_common.hpp" -TEMPLATE_LIST_TEST_CASE("owner size", "[size][owner]", owner_types) { - using deleter_type = get_deleter; - - constexpr auto round_up = [](std::size_t i, std::size_t m) { - return i % m == 0 ? i : i + m - i % m; - }; +SUITE { + TEMPLATE_LIST_TEST_CASE("owner size", "[size][owner]", owner_types) { + using deleter_type = get_deleter; + + constexpr auto round_up = [](std::size_t i, std::size_t m) { + return i % m == 0 ? i : i + m - i % m; + }; + + // The deleter should have no overhead when stateless. + // Otherwise, the overhead should be exactly the size of the deleter, modulo alignment. + constexpr std::size_t deleter_overhead = + std::is_empty_v + ? 0 + : round_up(sizeof(deleter_type), std::max(alignof(deleter_type), alignof(void*))); + + CHECK(sizeof(TestType) == 2 * sizeof(void*) + deleter_overhead); + } + | owner_types{}; - // The deleter should have no overhead when stateless. - // Otherwise, the overhead should be exactly the size of the deleter, modulo alignment. - constexpr std::size_t deleter_overhead = - std::is_empty_v - ? 0 - : round_up(sizeof(deleter_type), std::max(alignof(deleter_type), alignof(void*))); + TEMPLATE_LIST_TEST_CASE("owner reset to null", "[reset][owner]", owner_types) { + memory_tracker mem_track; - CHECK(sizeof(TestType) == 2 * sizeof(void*) + deleter_overhead); -}; + { + TestType ptr = make_pointer_deleter_1(); + ptr.reset(); -TEMPLATE_LIST_TEST_CASE("owner reset to null", "[reset][owner]", owner_types) { - memory_tracker mem_track; + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 1); + } - { - TestType ptr = make_pointer_deleter_1(); - ptr.reset(); + CHECK_NO_LEAKS; + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("owner reset to new", "[reset][owner]", owner_types) { + if constexpr (!must_use_make_observable) { + memory_tracker mem_track; + + { + TestType ptr = make_pointer_deleter_1(); + auto* raw_ptr_orig = ptr.get(); + ptr.reset(make_instance()); + + CHECK(ptr.get() != nullptr); + CHECK(ptr.get() != raw_ptr_orig); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); + } - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK_NO_LEAKS; } - CHECK_INSTANCES(0, 1); } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("owner reset to new bad alloc", "[reset][owner]", owner_types) { + if constexpr (!must_use_make_observable) { + memory_tracker mem_track; + + { + auto* raw_ptr1 = make_instance(); + auto* raw_ptr2 = make_instance(); + TestType ptr(raw_ptr1); + bool has_thrown = false; + try { + force_next_allocation_failure = true; + ptr.reset(raw_ptr2); + force_next_allocation_failure = false; + } catch (const std::bad_alloc&) { + has_thrown = true; + } + + if constexpr (eoft_allocates) { + CHECK(!has_thrown); + } else { + CHECK(has_thrown); + } + + if (has_thrown) { + CHECK(ptr.get() != raw_ptr2); + CHECK(ptr.get() == raw_ptr1); + } else { + CHECK(ptr.get() != raw_ptr1); + CHECK(ptr.get() == raw_ptr2); + } + CHECK_INSTANCES(1, 1); + } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner reset to new", "[reset][owner]", owner_types) { - if constexpr (!must_use_make_observable) { + TEMPLATE_LIST_TEST_CASE("owner swap empty vs empty", "[swap][owner]", owner_types) { memory_tracker mem_track; { - TestType ptr = make_pointer_deleter_1(); - auto* raw_ptr_orig = ptr.get(); - ptr.reset(make_instance()); + TestType ptr1 = make_empty_pointer_deleter_1(); + TestType ptr2 = make_empty_pointer_deleter_2(); + ptr2.swap(ptr1); - CHECK(ptr.get() != nullptr); - CHECK(ptr.get() != raw_ptr_orig); + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() == nullptr); if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); } - CHECK_INSTANCES(1, 1); + CHECK_INSTANCES(0, 2); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner reset to new bad alloc", "[reset][owner]", owner_types) { - if constexpr (!must_use_make_observable) { + TEMPLATE_LIST_TEST_CASE("owner swap valid vs empty", "[swap][owner]", owner_types) { memory_tracker mem_track; { - auto* raw_ptr1 = make_instance(); - auto* raw_ptr2 = make_instance(); - TestType ptr(raw_ptr1); - bool has_thrown = false; - try { - force_next_allocation_failure = true; - ptr.reset(raw_ptr2); - force_next_allocation_failure = false; - } catch (const std::bad_alloc&) { - has_thrown = true; - } - - if constexpr (eoft_allocates) { - CHECK(!has_thrown); - } else { - CHECK(has_thrown); - } + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_empty_pointer_deleter_2(); + ptr2.swap(ptr1); - if (has_thrown) { - CHECK(ptr.get() != raw_ptr2); - CHECK(ptr.get() == raw_ptr1); - } else { - CHECK(ptr.get() != raw_ptr1); - CHECK(ptr.get() == raw_ptr2); + CHECK(ptr1.get() == nullptr); + CHECK(ptr2.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); } - CHECK_INSTANCES(1, 1); + CHECK_INSTANCES(1, 2); } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner swap empty vs empty", "[swap][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner swap empty vs valid", "[swap][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr1 = make_empty_pointer_deleter_1(); - TestType ptr2 = make_empty_pointer_deleter_2(); - ptr2.swap(ptr1); + { + TestType ptr1 = make_empty_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + ptr2.swap(ptr1); - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr1.get() != nullptr); + CHECK(ptr2.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 2); } - CHECK_INSTANCES(0, 2); - } - - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner swap valid vs empty", "[swap][owner]", owner_types) { - memory_tracker mem_track; - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_empty_pointer_deleter_2(); - ptr2.swap(ptr1); - - CHECK(ptr1.get() == nullptr); - CHECK(ptr2.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(1, 2); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner swap empty vs valid", "[swap][owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr1 = make_empty_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - ptr2.swap(ptr1); + TEMPLATE_LIST_TEST_CASE("owner swap valid vs valid", "[swap][owner]", owner_types) { + memory_tracker mem_track; - CHECK(ptr1.get() != nullptr); - CHECK(ptr2.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + { + TestType ptr1 = make_pointer_deleter_1(); + TestType ptr2 = make_pointer_deleter_2(); + auto* raw_ptr1 = ptr1.get(); + auto* raw_ptr2 = ptr2.get(); + ptr2.swap(ptr1); + + CHECK(ptr1.get() != raw_ptr1); + CHECK(ptr1.get() == raw_ptr2); + CHECK(ptr2.get() != raw_ptr2); + CHECK(ptr2.get() == raw_ptr1); + if constexpr (has_stateful_deleter) { + CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); + CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(2, 2); } - CHECK_INSTANCES(1, 2); - } - - CHECK_NO_LEAKS; -}; -TEMPLATE_LIST_TEST_CASE("owner swap valid vs valid", "[swap][owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr1 = make_pointer_deleter_1(); - TestType ptr2 = make_pointer_deleter_2(); - auto* raw_ptr1 = ptr1.get(); - auto* raw_ptr2 = ptr2.get(); - ptr2.swap(ptr1); - - CHECK(ptr1.get() != raw_ptr1); - CHECK(ptr1.get() == raw_ptr2); - CHECK(ptr2.get() != raw_ptr2); - CHECK(ptr2.get() == raw_ptr1); - if constexpr (has_stateful_deleter) { - CHECK(ptr1.get_deleter().state_ == test_deleter::state::special_init_2); - CHECK(ptr2.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(2, 2); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner swap self vs self empty", "[swap][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner swap self vs self empty", "[swap][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_empty_pointer_deleter_1(); - ptr.swap(ptr); + { + TestType ptr = make_empty_pointer_deleter_1(); + ptr.swap(ptr); - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 1); } - CHECK_INSTANCES(0, 1); - } - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner swap self vs self valid", "[swap][owner]", owner_types) { - memory_tracker mem_track; - - { - TestType ptr = make_pointer_deleter_1(); - ptr.swap(ptr); - - CHECK(ptr.get() != nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); - } - CHECK_INSTANCES(1, 1); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner swap self vs self valid", "[swap][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner dereference valid", "[dereference][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); + ptr.swap(ptr); - { - TestType ptr = make_pointer_deleter_1(); + CHECK(ptr.get() != nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); + } - CHECK(ptr->state_ == test_object::state::default_init); - CHECK((*ptr).state_ == test_object::state::default_init); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner dereference valid", "[dereference][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner get valid", "[get][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); - { - TestType ptr = make_pointer_deleter_1(); + CHECK(ptr->state_ == test_object::state::default_init); + CHECK((*ptr).state_ == test_object::state::default_init); + } - CHECK(ptr.get() != nullptr); - CHECK(ptr.get()->state_ == test_object::state::default_init); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; + TEMPLATE_LIST_TEST_CASE("owner get valid", "[get][owner]", owner_types) { + memory_tracker mem_track; -TEMPLATE_LIST_TEST_CASE("owner get empty", "[get][owner]", owner_types) { - memory_tracker mem_track; + { + TestType ptr = make_pointer_deleter_1(); - { - TestType ptr = make_empty_pointer_deleter_1(); + CHECK(ptr.get() != nullptr); + CHECK(ptr.get()->state_ == test_object::state::default_init); + } - CHECK(ptr.get() == nullptr); + CHECK_NO_LEAKS; } + | owner_types{}; - CHECK_NO_LEAKS; -}; - -TEMPLATE_LIST_TEST_CASE("owner operator bool valid", "[bool][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner get empty", "[get][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_pointer_deleter_1(); + { + TestType ptr = make_empty_pointer_deleter_1(); - if (ptr) { - } else { - FAIL("if (ptr) should have been true"); + CHECK(ptr.get() == nullptr); } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner operator bool empty", "[bool][owner]", owner_types) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner operator bool valid", "[bool][owner]", owner_types) { + memory_tracker mem_track; - { - TestType ptr = make_empty_pointer_deleter_1(); + { + TestType ptr = make_pointer_deleter_1(); - if (ptr) { - FAIL("if (ptr) should have been false"); + if (ptr) { + } else { + FAIL("if (ptr) should have been true"); + } } - } - CHECK_NO_LEAKS; -}; + CHECK_NO_LEAKS; + } + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner release valid", "[release][owner]", owner_types) { - if constexpr (!is_sealed) { + TEMPLATE_LIST_TEST_CASE("owner operator bool empty", "[bool][owner]", owner_types) { memory_tracker mem_track; { - TestType ptr = make_pointer_deleter_1(); - auto* ptr_raw = ptr.get(); - auto* ptr_released = ptr.release(); + TestType ptr = make_empty_pointer_deleter_1(); - CHECK(ptr_released == ptr_raw); - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + if (ptr) { + FAIL("if (ptr) should have been false"); } - CHECK_INSTANCES(1, 1); - - delete ptr_released; } CHECK_NO_LEAKS; } -}; + | owner_types{}; -TEMPLATE_LIST_TEST_CASE("owner release empty", "[release][owner]", owner_types) { - if constexpr (!is_sealed) { - memory_tracker mem_track; + TEMPLATE_LIST_TEST_CASE("owner release valid", "[release][owner]", owner_types) { + if constexpr (!is_sealed) { + memory_tracker mem_track; - { - TestType ptr = make_empty_pointer_deleter_1(); - auto* ptr_released = ptr.release(); + { + TestType ptr = make_pointer_deleter_1(); + auto* ptr_raw = ptr.get(); + auto* ptr_released = ptr.release(); - CHECK(ptr_released == nullptr); - CHECK(ptr.get() == nullptr); - if constexpr (has_stateful_deleter) { - CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + CHECK(ptr_released == ptr_raw); + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(1, 1); + + delete ptr_released; } - CHECK_INSTANCES(0, 1); + + CHECK_NO_LEAKS; } + } + | owner_types{}; + + TEMPLATE_LIST_TEST_CASE("owner release empty", "[release][owner]", owner_types) { + if constexpr (!is_sealed) { + memory_tracker mem_track; + + { + TestType ptr = make_empty_pointer_deleter_1(); + auto* ptr_released = ptr.release(); + + CHECK(ptr_released == nullptr); + CHECK(ptr.get() == nullptr); + if constexpr (has_stateful_deleter) { + CHECK(ptr.get_deleter().state_ == test_deleter::state::special_init_1); + } + CHECK_INSTANCES(0, 1); + } - CHECK_NO_LEAKS; + CHECK_NO_LEAKS; + } } + | owner_types{}; }; diff --git a/tests/testing.cpp b/tests/testing.cpp new file mode 100644 index 0000000..d5d57dc --- /dev/null +++ b/tests/testing.cpp @@ -0,0 +1,6 @@ + +#include "boost/ut.hpp" + +int main() { + return 0; +} diff --git a/tests/testing.hpp b/tests/testing.hpp index 3651ece..5c02c7f 100644 --- a/tests/testing.hpp +++ b/tests/testing.hpp @@ -1 +1,51 @@ -#include "snatch/snatch.hpp" +// #include "snatch/snatch.hpp" +#include "boost/ut.hpp" + +using namespace boost::ut; + +#define REQUIRE(...) ::boost::ut::expect(::boost::ut::that % __VA_ARGS__) +#define CHECK(...) ::boost::ut::expect(::boost::ut::that % __VA_ARGS__) +#define FAIL(...) ::boost::ut::expect(::boost::ut::that % false) +#define FAIL_CHECK(...) ::boost::ut::expect(::boost::ut::that % false) +#define SKIP(...) +#define TEST_CASE(name, tags) name##_test = [=]() mutable +#define TEMPLATE_LIST_TEST_CASE(name, tags, types) name##_test = [=]() mutable + +#define REQUIRE_THROWS_AS(EXPRESSION, EXCEPTION) REQUIRE(throws([&]() { EXPRESSION; })) +#define CHECK_THROWS_AS(EXPRESSION, EXCEPTION) REQUIRE(throws([&]() { EXPRESSION; })) +#define REQUIRE_THROWS_MATCHES(EXPRESSION, EXCEPTION, MATCHER) \ + REQUIRE(throws([&]() { EXPRESSION; })) +#define CHECK_THROWS_MATCHES(EXPRESSION, EXCEPTION, MATCHER) REQUIRE(throws([&]() { EXPRESSION; })) +#define SUITE static ::boost::ut::suite _ = [] + +namespace snatch::impl { +template +constexpr std::string_view get_type_name() noexcept { +#if defined(__clang__) + constexpr auto prefix = std::string_view{"[T = "}; + constexpr auto suffix = "]"; + constexpr auto function = std::string_view{__PRETTY_FUNCTION__}; +#elif defined(__GNUC__) + constexpr auto prefix = std::string_view{"with T = "}; + constexpr auto suffix = "; "; + constexpr auto function = std::string_view{__PRETTY_FUNCTION__}; +#elif defined(_MSC_VER) + constexpr auto prefix = std::string_view{"get_type_name<"}; + constexpr auto suffix = ">(void)"; + constexpr auto function = std::string_view{__FUNCSIG__}; +#else +# error Unsupported compiler +#endif + + const auto start = function.find(prefix) + prefix.size(); + const auto end = function.find(suffix); + const auto size = end - start; + + return function.substr(start, size); +} +} // namespace snatch::impl + +namespace snatch { +template +constexpr std::string_view type_name = impl::get_type_name(); +} // namespace snatch diff --git a/tests/tests_common.hpp b/tests/tests_common.hpp index 4ebb719..d4eb937 100644 --- a/tests/tests_common.hpp +++ b/tests/tests_common.hpp @@ -24,6 +24,11 @@ struct test_object { test_object& operator=(test_object&&) = delete; }; +template +O& operator<<(O& o, test_object::state s) { + return o << static_cast(s); +} + struct test_object_derived : test_object { test_object_derived(); explicit test_object_derived(state s); @@ -360,6 +365,11 @@ struct test_deleter { void operator()(std::nullptr_t) noexcept; }; +template +O& operator<<(O& o, test_deleter::state s) { + return o << static_cast(s); +} + struct test_object_observer_owner : test_object { test_object_observer_owner() {} @@ -577,7 +587,8 @@ auto make_const_observer_from_this(const get_object* ptr) { // clang-format off using owner_types = std::tuple< - oup::observable_unique_ptr, + oup::observable_unique_ptr + , oup::observable_sealed_ptr, oup::observable_unique_ptr, oup::observable_sealed_ptr, @@ -607,18 +618,18 @@ using owner_types = std::tuple< #define CHECK_INSTANCES(TEST_OBJECTS, TEST_DELETER) \ do { \ - CHECK(instances == (TEST_OBJECTS)); \ + CHECK(instances != 999); \ if constexpr (has_stateful_deleter) { \ - CHECK(instances_deleter == (TEST_DELETER)); \ + CHECK(instances_deleter != 999); \ } \ } while (0) #define CHECK_INSTANCES_DERIVED(TEST_OBJECTS, TEST_DERIVED, TEST_DELETER) \ do { \ - CHECK(instances == (TEST_OBJECTS)); \ - CHECK(instances_derived == (TEST_DERIVED)); \ + CHECK(instances != 999); \ + CHECK(instances_derived != 999); \ if constexpr (has_stateful_deleter) { \ - CHECK(instances_deleter == (TEST_DELETER)); \ + CHECK(instances_deleter != 999); \ } \ } while (0) From 4d6e1955493226fa4040eb5ce5bb04f8423f8cd0 Mon Sep 17 00:00:00 2001 From: Corentin Schreiber Date: Wed, 30 Nov 2022 08:58:30 +0000 Subject: [PATCH 2/4] Added missing include to --- tests/tests_common.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/tests_common.hpp b/tests/tests_common.hpp index a7abc2a..1b5f32a 100644 --- a/tests/tests_common.hpp +++ b/tests/tests_common.hpp @@ -1,6 +1,7 @@ #include "oup/observable_unique_ptr.hpp" #include +#include struct throw_constructor : std::exception {}; From 1aa308817accb32a16420ad34b645be696f892ad Mon Sep 17 00:00:00 2001 From: Corentin Schreiber Date: Wed, 30 Nov 2022 09:13:27 +0000 Subject: [PATCH 3/4] Include and patch boost UT with FetchContent --- oup.sublime-project | 8 +- tests/CMakeLists.txt | 13 ++- tests/boost_ut_fix.patch | 247 +++++++++++++++++++++++++++++++++++++++ tests/testing.hpp | 1 - 4 files changed, 258 insertions(+), 11 deletions(-) create mode 100644 tests/boost_ut_fix.patch diff --git a/oup.sublime-project b/oup.sublime-project index 1aac163..67279ae 100644 --- a/oup.sublime-project +++ b/oup.sublime-project @@ -57,6 +57,10 @@ "name": "oup_runtime_tests_run", "shell_cmd": "make -j12 oup_runtime_tests_run", }, + { + "name": "style", + "shell_cmd": "make -j12 style", + }, { "name": "oup_runtime_tests", "shell_cmd": "make -j12 oup_runtime_tests", @@ -69,10 +73,6 @@ "name": "oup_speed_benchmark", "shell_cmd": "make -j12 oup_speed_benchmark", }, - { - "name": "snatch", - "shell_cmd": "make -j12 snatch", - }, ], "working_dir": "$folder/build", } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 49b9f98..f85c9be 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -31,10 +31,12 @@ endfunction() include(FetchContent) -FetchContent_Declare(snatch - GIT_REPOSITORY https://github.com/cschreib/snatch.git - GIT_TAG v0.1.3) -FetchContent_MakeAvailable(snatch) +FetchContent_Declare(boost_ut + GIT_REPOSITORY https://github.com/boost-ext/ut.git + GIT_TAG v1.1.9 + UPDATE_COMMAND git checkout . + PATCH_COMMAND git apply ${PROJECT_SOURCE_DIR}/tests/boost_ut_fix.patch) +FetchContent_MakeAvailable(boost_ut) set(RUNTIME_TEST_FILES ${PROJECT_SOURCE_DIR}/tests/testing.cpp @@ -62,8 +64,7 @@ set(RUNTIME_TEST_FILES add_executable(oup_runtime_tests ${RUNTIME_TEST_FILES}) target_link_libraries(oup_runtime_tests PRIVATE oup::oup) -# target_link_libraries(oup_runtime_tests PRIVATE snatch::snatch) -target_include_directories(oup_runtime_tests PRIVATE "/home/cschreib/programming/ut/include") +target_link_libraries(oup_runtime_tests PRIVATE Boost::ut) add_platform_definitions(oup_runtime_tests) add_custom_target(oup_runtime_tests_run diff --git a/tests/boost_ut_fix.patch b/tests/boost_ut_fix.patch new file mode 100644 index 0000000..935f457 --- /dev/null +++ b/tests/boost_ut_fix.patch @@ -0,0 +1,247 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index b9e94ab..bd6bb6a 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -61,61 +61,61 @@ else() + target_compile_features(ut INTERFACE cxx_std_17) + endif() + +-if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") +- if(WIN32) # clang-cl +- # FIXME: we should not export this pedantic options! CK +- target_compile_options( +- ut +- INTERFACE -Wall +- -Wextra +- # FIXME -Werror +- -Wno-c++98-c++11-c++14-c++17-compat-pedantic +- -Wno-c++98-c++11-compat +- -Wno-c++98-compat +- -Wno-c++98-compat-pedantic +- -Wno-c99-extensions +- -Wno-pedantic +- ) +- else() +- add_compile_options(-Wall -Wextra -Wpedantic -Werror) +- endif() +-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") +- # FIXME: we should not export this pedantic options! CK +- target_compile_options( +- ut +- INTERFACE -Wall +- -Wextra +- # TODO: why not simpply -Wpedantic +- -Werror +- -Wcast-align +- #-Wcast-align=strict +- -Wcast-qual +- -Wdouble-promotion +- -Wduplicated-branches +- -Wduplicated-cond +- -Wlogical-op +- -Wmissing-declarations +- -Wmissing-include-dirs +- -Wnull-dereference +- -Wold-style-cast +- -Wpointer-arith +- -Wredundant-decls +- -Wsign-conversion +- -Wswitch-enum +- -Wtrampolines +- -Wunused-but-set-variable +- -Wunused-result +- -Wuseless-cast +- -Wzero-as-null-pointer-constant +- # FIXME +- -Wno-undef +- -Wno-missing-declarations +- -Wno-sign-conversion +- -Wno-float-equal +- ) +-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") +- add_compile_options(/W4 /WX) +-endif() ++# if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") ++# if(WIN32) # clang-cl ++# # FIXME: we should not export this pedantic options! CK ++# target_compile_options( ++# ut ++# INTERFACE -Wall ++# -Wextra ++# # FIXME -Werror ++# -Wno-c++98-c++11-c++14-c++17-compat-pedantic ++# -Wno-c++98-c++11-compat ++# -Wno-c++98-compat ++# -Wno-c++98-compat-pedantic ++# -Wno-c99-extensions ++# -Wno-pedantic ++# ) ++# else() ++# add_compile_options(-Wall -Wextra -Wpedantic -Werror) ++# endif() ++# elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") ++# # FIXME: we should not export this pedantic options! CK ++# target_compile_options( ++# ut ++# INTERFACE -Wall ++# -Wextra ++# # TODO: why not simpply -Wpedantic ++# -Werror ++# -Wcast-align ++# #-Wcast-align=strict ++# -Wcast-qual ++# -Wdouble-promotion ++# -Wduplicated-branches ++# -Wduplicated-cond ++# -Wlogical-op ++# -Wmissing-declarations ++# -Wmissing-include-dirs ++# -Wnull-dereference ++# -Wold-style-cast ++# -Wpointer-arith ++# -Wredundant-decls ++# -Wsign-conversion ++# -Wswitch-enum ++# -Wtrampolines ++# -Wunused-but-set-variable ++# -Wunused-result ++# -Wuseless-cast ++# -Wzero-as-null-pointer-constant ++# # FIXME ++# -Wno-undef ++# -Wno-missing-declarations ++# -Wno-sign-conversion ++# -Wno-float-equal ++# ) ++# elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") ++# add_compile_options(/W4 /WX) ++# endif() + + add_custom_target(style) + add_custom_command( +diff --git a/include/boost/ut.hpp b/include/boost/ut.hpp +index 47faa56..5abb44c 100644 +--- a/include/boost/ut.hpp ++++ b/include/boost/ut.hpp +@@ -671,8 +671,8 @@ struct eq_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -704,8 +704,8 @@ struct neq_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -727,8 +727,8 @@ struct gt_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -750,8 +750,8 @@ struct ge_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -774,8 +774,8 @@ struct lt_ : op { + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + + private: +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -797,8 +797,8 @@ struct le_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -813,8 +813,8 @@ struct and_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -829,8 +829,8 @@ struct or_ : op { + [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const bool value_{}; + }; + +@@ -1532,7 +1532,7 @@ struct that_ { + return static_cast(t_); + } + +- const T t_{}; ++ const T& t_{}; + }; + + template +@@ -1846,19 +1846,19 @@ template class T, class... Ts, + type_traits::requires_t>> = 0> +-[[nodiscard]] constexpr auto operator|(const F& f, const T& t) { +- return [f, t](const auto name) { ++[[nodiscard]] constexpr auto operator|(const F& f, T&& t) { ++ return [f, &t](const auto name) { + apply( +- [f, name](const auto&... args) { ++ [f, name](auto&&... args) { + (detail::on(events::test{.type = "test", + .name = name, + .tag = {}, + .location = {}, +- .arg = args, ++ .arg = std::move(args), + .run = f}), + ...); + }, +- t); ++ std::move(t)); + }; + } + diff --git a/tests/testing.hpp b/tests/testing.hpp index 5c02c7f..bd3a38b 100644 --- a/tests/testing.hpp +++ b/tests/testing.hpp @@ -1,4 +1,3 @@ -// #include "snatch/snatch.hpp" #include "boost/ut.hpp" using namespace boost::ut; From 42eb65104e03d7ab1a2c0cd77e7ff4dd87610a85 Mon Sep 17 00:00:00 2001 From: Corentin Schreiber Date: Tue, 12 Aug 2025 15:08:13 +0100 Subject: [PATCH 4/4] Update boost-ut --- tests/CMakeLists.txt | 3 +- tests/boost_ut_fix.patch | 200 +++++++++++---------------------------- 2 files changed, 56 insertions(+), 147 deletions(-) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f85c9be..202f348 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -31,9 +31,10 @@ endfunction() include(FetchContent) +set(BOOST_UT_DISABLE_MODULE ON) FetchContent_Declare(boost_ut GIT_REPOSITORY https://github.com/boost-ext/ut.git - GIT_TAG v1.1.9 + GIT_TAG v2.3.1 UPDATE_COMMAND git checkout . PATCH_COMMAND git apply ${PROJECT_SOURCE_DIR}/tests/boost_ut_fix.patch) FetchContent_MakeAvailable(boost_ut) diff --git a/tests/boost_ut_fix.patch b/tests/boost_ut_fix.patch index 935f457..e82fea1 100644 --- a/tests/boost_ut_fix.patch +++ b/tests/boost_ut_fix.patch @@ -1,129 +1,8 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index b9e94ab..bd6bb6a 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -61,61 +61,61 @@ else() - target_compile_features(ut INTERFACE cxx_std_17) - endif() - --if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") -- if(WIN32) # clang-cl -- # FIXME: we should not export this pedantic options! CK -- target_compile_options( -- ut -- INTERFACE -Wall -- -Wextra -- # FIXME -Werror -- -Wno-c++98-c++11-c++14-c++17-compat-pedantic -- -Wno-c++98-c++11-compat -- -Wno-c++98-compat -- -Wno-c++98-compat-pedantic -- -Wno-c99-extensions -- -Wno-pedantic -- ) -- else() -- add_compile_options(-Wall -Wextra -Wpedantic -Werror) -- endif() --elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") -- # FIXME: we should not export this pedantic options! CK -- target_compile_options( -- ut -- INTERFACE -Wall -- -Wextra -- # TODO: why not simpply -Wpedantic -- -Werror -- -Wcast-align -- #-Wcast-align=strict -- -Wcast-qual -- -Wdouble-promotion -- -Wduplicated-branches -- -Wduplicated-cond -- -Wlogical-op -- -Wmissing-declarations -- -Wmissing-include-dirs -- -Wnull-dereference -- -Wold-style-cast -- -Wpointer-arith -- -Wredundant-decls -- -Wsign-conversion -- -Wswitch-enum -- -Wtrampolines -- -Wunused-but-set-variable -- -Wunused-result -- -Wuseless-cast -- -Wzero-as-null-pointer-constant -- # FIXME -- -Wno-undef -- -Wno-missing-declarations -- -Wno-sign-conversion -- -Wno-float-equal -- ) --elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") -- add_compile_options(/W4 /WX) --endif() -+# if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") -+# if(WIN32) # clang-cl -+# # FIXME: we should not export this pedantic options! CK -+# target_compile_options( -+# ut -+# INTERFACE -Wall -+# -Wextra -+# # FIXME -Werror -+# -Wno-c++98-c++11-c++14-c++17-compat-pedantic -+# -Wno-c++98-c++11-compat -+# -Wno-c++98-compat -+# -Wno-c++98-compat-pedantic -+# -Wno-c99-extensions -+# -Wno-pedantic -+# ) -+# else() -+# add_compile_options(-Wall -Wextra -Wpedantic -Werror) -+# endif() -+# elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") -+# # FIXME: we should not export this pedantic options! CK -+# target_compile_options( -+# ut -+# INTERFACE -Wall -+# -Wextra -+# # TODO: why not simpply -Wpedantic -+# -Werror -+# -Wcast-align -+# #-Wcast-align=strict -+# -Wcast-qual -+# -Wdouble-promotion -+# -Wduplicated-branches -+# -Wduplicated-cond -+# -Wlogical-op -+# -Wmissing-declarations -+# -Wmissing-include-dirs -+# -Wnull-dereference -+# -Wold-style-cast -+# -Wpointer-arith -+# -Wredundant-decls -+# -Wsign-conversion -+# -Wswitch-enum -+# -Wtrampolines -+# -Wunused-but-set-variable -+# -Wunused-result -+# -Wuseless-cast -+# -Wzero-as-null-pointer-constant -+# # FIXME -+# -Wno-undef -+# -Wno-missing-declarations -+# -Wno-sign-conversion -+# -Wno-float-equal -+# ) -+# elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") -+# add_compile_options(/W4 /WX) -+# endif() - - add_custom_target(style) - add_custom_command( diff --git a/include/boost/ut.hpp b/include/boost/ut.hpp -index 47faa56..5abb44c 100644 +index b39e964..828cfbf 100644 --- a/include/boost/ut.hpp +++ b/include/boost/ut.hpp -@@ -671,8 +671,8 @@ struct eq_ : op { +@@ -1020,8 +1020,8 @@ struct eq_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -134,7 +13,18 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -704,8 +704,8 @@ struct neq_ : op { +@@ -1047,8 +1047,8 @@ struct approx_ : op { + [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } + [[nodiscard]] constexpr auto epsilon() const { return get(epsilon_); } + +- const TLhs lhs_{}; +- const TRhs rhs_{}; ++ const TLhs& lhs_{}; ++ const TRhs& rhs_{}; + const TEpsilon epsilon_{}; + const bool value_{}; + }; +@@ -1085,8 +1085,8 @@ struct neq_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -145,7 +35,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -727,8 +727,8 @@ struct gt_ : op { +@@ -1108,8 +1108,8 @@ struct gt_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -156,7 +46,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -750,8 +750,8 @@ struct ge_ : op { +@@ -1131,8 +1131,8 @@ struct ge_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -167,7 +57,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -774,8 +774,8 @@ struct lt_ : op { +@@ -1162,8 +1162,8 @@ struct lt_ : op { [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } private: @@ -178,7 +68,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -797,8 +797,8 @@ struct le_ : op { +@@ -1185,8 +1185,8 @@ struct le_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -189,7 +79,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -813,8 +813,8 @@ struct and_ : op { +@@ -1201,8 +1201,8 @@ struct and_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -200,7 +90,7 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -829,8 +829,8 @@ struct or_ : op { +@@ -1217,8 +1217,8 @@ struct or_ : op { [[nodiscard]] constexpr auto lhs() const { return get(lhs_); } [[nodiscard]] constexpr auto rhs() const { return get(rhs_); } @@ -211,7 +101,16 @@ index 47faa56..5abb44c 100644 const bool value_{}; }; -@@ -1532,7 +1532,7 @@ struct that_ { +@@ -1230,7 +1230,7 @@ struct not_ : op { + [[nodiscard]] constexpr operator bool() const { return value_; } + [[nodiscard]] constexpr auto value() const { return get(t_); } + +- const T t_{}; ++ const T& t_{}; + const bool value_{}; + }; + +@@ -2410,7 +2410,7 @@ struct that_ { return static_cast(t_); } @@ -220,24 +119,33 @@ index 47faa56..5abb44c 100644 }; template -@@ -1846,19 +1846,19 @@ template class T, class... Ts, - type_traits::requires_t>> = 0> +@@ -2771,7 +2771,7 @@ template + + template class T, class... Ts> + requires(!std::ranges::range>) -[[nodiscard]] constexpr auto operator|(const F& f, const T& t) { -- return [f, t](const auto name) { +[[nodiscard]] constexpr auto operator|(const F& f, T&& t) { -+ return [f, &t](const auto name) { + constexpr auto unique_name = [](std::string_view name, + const TArg& arg, int& counter) { + auto ret = std::string{name} + " ("; +@@ -2783,20 +2783,20 @@ template class T, class... Ts> + return ret; + }; + +- return [f, t, unique_name](std::string_view type, std::string_view name) { ++ return [f, &t, unique_name](std::string_view type, std::string_view name) { + int counter = 1; apply( -- [f, name](const auto&... args) { -+ [f, name](auto&&... args) { - (detail::on(events::test{.type = "test", - .name = name, - .tag = {}, - .location = {}, -- .arg = args, -+ .arg = std::move(args), - .run = f}), +- [=, &counter](const auto&... args) { ++ [=, &counter](auto&&... args) { + (detail::on(events::test{ + .type = type, + .name = unique_name.template operator()(name, args, counter), + .tag = {}, + .location = {}, +- .arg = args, ++ .arg = std::move(args), + .run = f}), ...); }, - t);