From 52d5330cbb866f050a8f0736c139586c8a22c387 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Fri, 21 Feb 2020 21:19:45 +0100 Subject: new_type: begin Iterable implementation --- test/include/iterable_suite.hpp | 11 ++++++++ test/src/driver.cpp | 2 ++ test/src/iterable_suite.cpp | 61 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 74 insertions(+) create mode 100644 test/include/iterable_suite.hpp create mode 100644 test/src/iterable_suite.cpp (limited to 'test') diff --git a/test/include/iterable_suite.hpp b/test/include/iterable_suite.hpp new file mode 100644 index 0000000..c2bbc6e --- /dev/null +++ b/test/include/iterable_suite.hpp @@ -0,0 +1,11 @@ +#ifndef NEWTYPE_TEST_ITERABLE_SUITE_HPP +#define NEWTYPE_TEST_ITERABLE_SUITE_HPP + +#include + +#include +#include + +auto iterable_suite() -> std::pair; + +#endif \ No newline at end of file diff --git a/test/src/driver.cpp b/test/src/driver.cpp index cfd6b90..a0e8904 100644 --- a/test/src/driver.cpp +++ b/test/src/driver.cpp @@ -4,6 +4,7 @@ #include "equality_comparison_suite.hpp" #include "hash_suite.hpp" #include "io_operators_suite.hpp" +#include "iterable_suite.hpp" #include "new_type_constructor_suite.hpp" #include "relational_operators_suite.hpp" @@ -61,6 +62,7 @@ int main(int argc, char ** argv) io_operators_suite(), arithmetic_suite(), hash_suite(), + iterable_suite(), }; auto selectors = get_test_selectors(suites); diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp new file mode 100644 index 0000000..2470571 --- /dev/null +++ b/test/src/iterable_suite.cpp @@ -0,0 +1,61 @@ +#include "iterable_suite.hpp" + +#include "kawaii.hpp" +#include "newtype/derivable.hpp" +#include "newtype/deriving.hpp" +#include "newtype/impl/type_traits_extensions.hpp" +#include "newtype/new_type.hpp" + +#include + +#include +#include + +namespace +{ + +} + +inline namespace begin_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_begin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_begin_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin() -> void + { + static_assert(!nt::impl::has_begin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_begin_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin() -> void + { + static_assert(nt::impl::has_member_begin_v>); + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + ASSERT(nt::impl::has_member_begin_v); + } + + auto a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin() -> void + { + static_assert(nt::impl::has_member_begin_v>); + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + ASSERT(nt::impl::has_member_begin_v); + } + +} // namespace begin_tests + +auto iterable_suite() -> std::pair +{ + return {{ + /// 'begin' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_begin), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin), + KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin), + }, + "Iterable Tests"}; +} \ No newline at end of file -- cgit v1.2.3 From 943033bc921bb328bbc354f15627dbf4bd6ab1e4 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Sat, 22 Feb 2020 18:29:07 +0100 Subject: new_type: fix enablement of begin --- test/src/iterable_suite.cpp | 35 ++++++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index 2470571..bf478e1 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -14,7 +14,16 @@ namespace { -} + struct with_member + { + using iterator = void *; + using const_iterator = void const *; + + auto begin() -> iterator; + auto begin() const -> const_iterator; + }; + +} // namespace inline namespace begin_tests { @@ -34,18 +43,32 @@ inline namespace begin_tests auto a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin() -> void { - static_assert(nt::impl::has_member_begin_v>); - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + static_assert(nt::impl::has_member_begin_v); + using type_alias = nt::new_type; ASSERT(nt::impl::has_member_begin_v); } auto a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin() -> void { - static_assert(nt::impl::has_member_begin_v>); - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + static_assert(nt::impl::has_member_begin_v); + using type_alias = nt::new_type; ASSERT(nt::impl::has_member_begin_v); } + auto a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin() -> void + { + static_assert(!nt::impl::has_free_begin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_begin_v); + } + + auto a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin() -> void + { + static_assert(!nt::impl::has_free_begin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_begin_v); + } + } // namespace begin_tests auto iterable_suite() -> std::pair @@ -56,6 +79,8 @@ auto iterable_suite() -> std::pair KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin), KAWAII(a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin), KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin), + KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin), }, "Iterable Tests"}; } \ No newline at end of file -- cgit v1.2.3 From 62ca586910736b5aba6d622ec27a7b00e3c37359 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Sat, 22 Feb 2020 19:32:12 +0100 Subject: new_type: add additional iterable tests --- test/src/iterable_suite.cpp | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index bf478e1..8c08a66 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -69,6 +69,21 @@ inline namespace begin_tests ASSERT(!nt::impl::has_free_begin_v); } + auto accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*weak.begin(), *strong.begin()); + } + + auto an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(begin(instance), instance.begin()); + } + } // namespace begin_tests auto iterable_suite() -> std::pair @@ -81,6 +96,8 @@ auto iterable_suite() -> std::pair KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin), KAWAII(a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin), KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin), + KAWAII(accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin), }, "Iterable Tests"}; } \ No newline at end of file -- cgit v1.2.3 From bb58e65e6596a2ffac2e85e9fda1e8568aa9b4b1 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Tue, 25 Feb 2020 20:57:06 +0100 Subject: new_type: implement cbegin --- test/src/iterable_suite.cpp | 84 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 72 insertions(+), 12 deletions(-) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index 8c08a66..3bdb16b 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -21,6 +21,7 @@ namespace auto begin() -> iterator; auto begin() const -> const_iterator; + auto cbegin() const -> const_iterator; }; } // namespace @@ -86,18 +87,77 @@ inline namespace begin_tests } // namespace begin_tests +inline namespace cbegin_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_cbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cbegin_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cbegin() -> void + { + static_assert(!nt::impl::has_cbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cbegin_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_cbegin_deriving_iterable_has_member_cbegin() -> void + { + static_assert(nt::impl::has_member_cbegin_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_cbegin_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_cbegin_deriving_iterable_has_no_free_cbegin() -> void + { + static_assert(!nt::impl::has_free_cbegin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_cbegin_v); + } + + auto accessing_the_first_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() + -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*weak.cbegin(), *strong.cbegin()); + } + + auto an_iterator_obtained_via_member_cbegin_compares_equal_to_an_iterator_obtained_via_free_cbegin() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(cbegin(instance), instance.cbegin()); + } + +} // namespace cbegin_tests + auto iterable_suite() -> std::pair { - return {{ - /// 'begin' Tests - KAWAII(a_new__type_not_deriving_iterable_has_no_begin), - KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin), - KAWAII(a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin), - KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin), - KAWAII(a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin), - KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin), - KAWAII(accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), - KAWAII(an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin), - }, - "Iterable Tests"}; + return { + { + // clang-format off + /// 'begin' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_begin), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin), + KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin), + KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin), + KAWAII(accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin), + + /// 'begin' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_cbegin), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cbegin), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_cbegin_deriving_iterable_has_member_cbegin), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_cbegin_deriving_iterable_has_no_free_cbegin), + KAWAII(accessing_the_first_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_cbegin_compares_equal_to_an_iterator_obtained_via_free_cbegin), + // clang-format on + }, + "Iterable Tests"}; } \ No newline at end of file -- cgit v1.2.3 From b01d495beb586d8d18ef592d80f593ea1bbe10e2 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Fri, 28 Feb 2020 06:46:26 +0100 Subject: new_type: implement rbegin and crbegin --- test/src/iterable_suite.cpp | 136 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 135 insertions(+), 1 deletion(-) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index 3bdb16b..778dc35 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -18,10 +18,15 @@ namespace { using iterator = void *; using const_iterator = void const *; + using reverse_iterator = void *; + using const_reverse_iterator = void const *; auto begin() -> iterator; auto begin() const -> const_iterator; auto cbegin() const -> const_iterator; + auto rbegin() -> reverse_iterator; + auto rbegin() const -> const_reverse_iterator; + auto crbegin() const -> const_reverse_iterator; }; } // namespace @@ -135,6 +140,117 @@ inline namespace cbegin_tests } // namespace cbegin_tests +inline namespace rbegin_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_rbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_rbegin() -> void + { + static_assert(!nt::impl::has_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_rbegin_deriving_iterable_has_member_rbegin() -> void + { + static_assert(nt::impl::has_member_rbegin_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rbegin_v); + } + + auto a_new__type_based_on_an_iterable_type_with_constant_member_rbegin_deriving_iterable_has_constant_member_rbegin() -> void + { + static_assert(nt::impl::has_member_rbegin_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rbegin_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_rbegin_deriving_iterable_has_no_free_rbegin() -> void + { + static_assert(!nt::impl::has_free_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_rbegin_v); + } + + auto a_new__type_based_on_an_iterable_type_without_constant_free_rbegin_deriving_iterable_has_no_constant_free_rbegin() -> void + { + static_assert(!nt::impl::has_free_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_rbegin_v); + } + + auto accessing_the_first_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() + -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*weak.rbegin(), *strong.rbegin()); + } + + auto an_iterator_obtained_via_member_rbegin_compares_equal_to_an_iterator_obtained_via_free_rbegin() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(rbegin(instance), instance.rbegin()); + } + +} // namespace rbegin_tests + +inline namespace crbegin_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_crbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crbegin_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crbegin() -> void + { + static_assert(!nt::impl::has_crbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crbegin_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_crbegin_deriving_iterable_has_member_crbegin() -> void + { + static_assert(nt::impl::has_member_crbegin_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_crbegin_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_crbegin_deriving_iterable_has_no_free_crbegin() -> void + { + static_assert(!nt::impl::has_free_crbegin_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_crbegin_v); + } + + auto + accessing_the_first_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() + -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*weak.crbegin(), *strong.crbegin()); + } + + auto an_iterator_obtained_via_member_crbegin_compares_equal_to_an_iterator_obtained_via_free_crbegin() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(crbegin(instance), instance.crbegin()); + } + +} // namespace crbegin_tests + auto iterable_suite() -> std::pair { return { @@ -150,13 +266,31 @@ auto iterable_suite() -> std::pair KAWAII(accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), KAWAII(an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin), - /// 'begin' Tests + /// 'cbegin' Tests KAWAII(a_new__type_not_deriving_iterable_has_no_cbegin), KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cbegin), KAWAII(a_new__type_based_on_an_iterable_type_with_member_cbegin_deriving_iterable_has_member_cbegin), KAWAII(a_new__type_based_on_an_iterable_type_without_free_cbegin_deriving_iterable_has_no_free_cbegin), KAWAII(accessing_the_first_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), KAWAII(an_iterator_obtained_via_member_cbegin_compares_equal_to_an_iterator_obtained_via_free_cbegin), + + /// 'rbegin' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_rbegin), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_rbegin), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_rbegin_deriving_iterable_has_member_rbegin), + KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_rbegin_deriving_iterable_has_constant_member_rbegin), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_rbegin_deriving_iterable_has_no_free_rbegin), + KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_rbegin_deriving_iterable_has_no_constant_free_rbegin), + KAWAII(accessing_the_first_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_rbegin_compares_equal_to_an_iterator_obtained_via_free_rbegin), + + /// 'cbegin' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_crbegin), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crbegin), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_crbegin_deriving_iterable_has_member_crbegin), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_crbegin_deriving_iterable_has_no_free_crbegin), + KAWAII(accessing_the_first_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_crbegin_compares_equal_to_an_iterator_obtained_via_free_crbegin), // clang-format on }, "Iterable Tests"}; -- cgit v1.2.3 From 9e79f0cbfa074f7766f6fea04d41f7803c6cee58 Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Fri, 28 Feb 2020 07:13:29 +0100 Subject: newtype: implement end iterators --- test/src/iterable_suite.cpp | 264 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 263 insertions(+), 1 deletion(-) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index 778dc35..a75ab19 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -27,6 +27,13 @@ namespace auto rbegin() -> reverse_iterator; auto rbegin() const -> const_reverse_iterator; auto crbegin() const -> const_reverse_iterator; + + auto end() -> iterator; + auto end() const -> const_iterator; + auto cend() const -> const_iterator; + auto rend() -> reverse_iterator; + auto rend() const -> const_reverse_iterator; + auto crend() const -> const_reverse_iterator; }; } // namespace @@ -251,6 +258,225 @@ inline namespace crbegin_tests } // namespace crbegin_tests +inline namespace end_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_end() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_end() -> void + { + static_assert(!nt::impl::has_end_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_end_deriving_iterable_has_member_end() -> void + { + static_assert(nt::impl::has_member_end_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_end_v); + } + + auto a_new__type_based_on_an_iterable_type_with_constant_member_end_deriving_iterable_has_constant_member_end() -> void + { + static_assert(nt::impl::has_member_end_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_end_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_end_deriving_iterable_has_no_free_end() -> void + { + static_assert(!nt::impl::has_free_end_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_end_v); + } + + auto a_new__type_based_on_an_iterable_type_without_constant_free_end_deriving_iterable_has_no_constant_free_end() -> void + { + static_assert(!nt::impl::has_free_end_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_end_v); + } + + auto accessing_the_last_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*(weak.end() - 1), *(strong.end() - 1)); + } + + auto an_iterator_obtained_via_member_end_compares_equal_to_an_iterator_obtained_via_free_end() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(end(instance), instance.end()); + } + +} // namespace end_tests + +inline namespace cend_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_cend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cend_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cend() -> void + { + static_assert(!nt::impl::has_cend_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cend_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_cend_deriving_iterable_has_member_cend() -> void + { + static_assert(nt::impl::has_member_cend_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_cend_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_cend_deriving_iterable_has_no_free_cend() -> void + { + static_assert(!nt::impl::has_free_cend_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_cend_v); + } + + auto accessing_the_last_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() + -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*(weak.cend() - 1), *(strong.cend() - 1)); + } + + auto an_iterator_obtained_via_member_cend_compares_equal_to_an_iterator_obtained_via_free_cend() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(cend(instance), instance.cend()); + } + +} // namespace cend_tests + +inline namespace rend_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_rend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rend_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_rend() -> void + { + static_assert(!nt::impl::has_rend_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rend_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_rend_deriving_iterable_has_member_rend() -> void + { + static_assert(nt::impl::has_member_rend_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rend_v); + } + + auto a_new__type_based_on_an_iterable_type_with_constant_member_rend_deriving_iterable_has_constant_member_rend() -> void + { + static_assert(nt::impl::has_member_rend_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rend_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_rend_deriving_iterable_has_no_free_rend() -> void + { + static_assert(!nt::impl::has_free_rend_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_rend_v); + } + + auto a_new__type_based_on_an_iterable_type_without_constant_free_rend_deriving_iterable_has_no_constant_free_rend() -> void + { + static_assert(!nt::impl::has_free_rend_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_rend_v); + } + + auto accessing_the_last_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*(weak.rend() - 1), *(strong.rend() - 1)); + } + + auto an_iterator_obtained_via_member_rend_compares_equal_to_an_iterator_obtained_via_free_rend() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(rend(instance), instance.rend()); + } + +} // namespace rend_tests + +inline namespace crend_tests +{ + + auto a_new__type_not_deriving_iterable_has_no_crend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crend_v)); + } + + auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crend() -> void + { + static_assert(!nt::impl::has_crend_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crend_v)); + } + + auto a_new__type_based_on_an_iterable_type_with_member_crend_deriving_iterable_has_member_crend() -> void + { + static_assert(nt::impl::has_member_crend_v); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_crend_v); + } + + auto a_new__type_based_on_an_iterable_type_without_free_crend_deriving_iterable_has_no_free_crend() -> void + { + static_assert(!nt::impl::has_free_crend_v); + using type_alias = nt::new_type; + ASSERT(!nt::impl::has_free_crend_v); + } + + auto + accessing_the_last_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() + -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto weak = std::array{42, 21, 10}; + auto strong = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(*(weak.crend() - 1), *(strong.crend() - 1)); + } + + auto an_iterator_obtained_via_member_crend_compares_equal_to_an_iterator_obtained_via_free_crend() -> void + { + using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; + auto instance = type_alias{{42, 21, 10}}; + ASSERT_EQUAL(crend(instance), instance.crend()); + } + +} // namespace crend_tests + auto iterable_suite() -> std::pair { return { @@ -284,13 +510,49 @@ auto iterable_suite() -> std::pair KAWAII(accessing_the_first_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), KAWAII(an_iterator_obtained_via_member_rbegin_compares_equal_to_an_iterator_obtained_via_free_rbegin), - /// 'cbegin' Tests + /// 'crbegin' Tests KAWAII(a_new__type_not_deriving_iterable_has_no_crbegin), KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crbegin), KAWAII(a_new__type_based_on_an_iterable_type_with_member_crbegin_deriving_iterable_has_member_crbegin), KAWAII(a_new__type_based_on_an_iterable_type_without_free_crbegin_deriving_iterable_has_no_free_crbegin), KAWAII(accessing_the_first_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), KAWAII(an_iterator_obtained_via_member_crbegin_compares_equal_to_an_iterator_obtained_via_free_crbegin), + + /// 'end' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_end), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_end), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_end_deriving_iterable_has_member_end), + KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_end_deriving_iterable_has_constant_member_end), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_end_deriving_iterable_has_no_free_end), + KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_end_deriving_iterable_has_no_constant_free_end), + KAWAII(accessing_the_last_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_end_compares_equal_to_an_iterator_obtained_via_free_end), + + /// 'cend' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_cend), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cend), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_cend_deriving_iterable_has_member_cend), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_cend_deriving_iterable_has_no_free_cend), + KAWAII(accessing_the_last_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_cend_compares_equal_to_an_iterator_obtained_via_free_cend), + + /// 'rend' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_rend), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_rend), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_rend_deriving_iterable_has_member_rend), + KAWAII(a_new__type_based_on_an_iterable_type_with_constant_member_rend_deriving_iterable_has_constant_member_rend), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_rend_deriving_iterable_has_no_free_rend), + KAWAII(a_new__type_based_on_an_iterable_type_without_constant_free_rend_deriving_iterable_has_no_constant_free_rend), + KAWAII(accessing_the_last_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_rend_compares_equal_to_an_iterator_obtained_via_free_rend), + + /// 'crend' Tests + KAWAII(a_new__type_not_deriving_iterable_has_no_crend), + KAWAII(a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crend), + KAWAII(a_new__type_based_on_an_iterable_type_with_member_crend_deriving_iterable_has_member_crend), + KAWAII(a_new__type_based_on_an_iterable_type_without_free_crend_deriving_iterable_has_no_free_crend), + KAWAII(accessing_the_last_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type), + KAWAII(an_iterator_obtained_via_member_crend_compares_equal_to_an_iterator_obtained_via_free_crend), // clang-format on }, "Iterable Tests"}; -- cgit v1.2.3 From 081688443d12de12d7b66b44630e4c7e0681fabe Mon Sep 17 00:00:00 2001 From: Felix Morgner Date: Sun, 1 Mar 2020 12:06:23 +0100 Subject: new_type: restructure iterable tests --- test/src/iterable_suite.cpp | 790 ++++++++++++++++++++++++++------------------ 1 file changed, 475 insertions(+), 315 deletions(-) (limited to 'test') diff --git a/test/src/iterable_suite.cpp b/test/src/iterable_suite.cpp index a75ab19..3b46024 100644 --- a/test/src/iterable_suite.cpp +++ b/test/src/iterable_suite.cpp @@ -8,18 +8,20 @@ #include +#include #include #include +#include namespace { struct with_member { - using iterator = void *; - using const_iterator = void const *; - using reverse_iterator = void *; - using const_reverse_iterator = void const *; + using iterator = char *; + using const_iterator = char const *; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; auto begin() -> iterator; auto begin() const -> const_iterator; @@ -36,9 +38,77 @@ namespace auto crend() const -> const_reverse_iterator; }; + struct with_free + { + using iterator = char *; + using const_iterator = char const *; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + }; + + auto begin(with_free &) -> with_free::iterator + { + return {}; + } + + auto begin(with_free const &) -> with_free::const_iterator + { + return {}; + } + + auto cbegin(with_free const &) -> with_free::const_iterator + { + return {}; + } + + auto rbegin(with_free &) -> with_free::reverse_iterator + { + return {}; + } + + auto rbegin(with_free const &) -> with_free::const_reverse_iterator + { + return {}; + } + + auto crbegin(with_free const &) -> with_free::const_reverse_iterator + { + return {}; + } + + auto end(with_free &) -> with_free::iterator + { + return {}; + } + + auto end(with_free const &) -> with_free::const_iterator + { + return {}; + } + + auto cend(with_free const &) -> with_free::const_iterator + { + return {}; + } + + auto rend(with_free &) -> with_free::reverse_iterator + { + return {}; + } + + auto rend(with_free const &) -> with_free::const_reverse_iterator + { + return {}; + } + + auto crend(with_free const &) -> with_free::const_reverse_iterator + { + return {}; + } + } // namespace -inline namespace begin_tests +inline namespace combined_enablement_tests { auto a_new__type_not_deriving_iterable_has_no_begin() -> void @@ -47,513 +117,603 @@ inline namespace begin_tests ASSERT(!(nt::impl::has_begin_v)); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_constant_begin() -> void { - static_assert(!nt::impl::has_begin_v); - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_begin_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_begin_v)); } - auto a_new__type_based_on_an_iterable_type_with_member_begin_deriving_iterable_has_member_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_cbegin() -> void { - static_assert(nt::impl::has_member_begin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_begin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cbegin_v)); } - auto a_new__type_based_on_an_iterable_type_with_constant_member_begin_deriving_iterable_has_constant_member_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_rbegin() -> void { - static_assert(nt::impl::has_member_begin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_begin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); } - auto a_new__type_based_on_an_iterable_type_without_free_begin_deriving_iterable_has_no_free_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_constant_rbegin() -> void { - static_assert(!nt::impl::has_free_begin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_begin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); } - auto a_new__type_based_on_an_iterable_type_without_constant_free_begin_deriving_iterable_has_no_constant_free_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_crbegin() -> void { - static_assert(!nt::impl::has_free_begin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_begin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crbegin_v)); } - auto accessing_the_first_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() -> void + auto a_new__type_not_deriving_iterable_has_no_end() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*weak.begin(), *strong.begin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); } - auto an_iterator_obtained_via_member_begin_compares_equal_to_an_iterator_obtained_via_free_begin() -> void + auto a_new__type_not_deriving_iterable_has_no_constant_end() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(begin(instance), instance.begin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); } -} // namespace begin_tests + auto a_new__type_not_deriving_iterable_has_no_cend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cend_v)); + } -inline namespace cbegin_tests -{ + auto a_new__type_not_deriving_iterable_has_no_rend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rend_v)); + } - auto a_new__type_not_deriving_iterable_has_no_cbegin() -> void + auto a_new__type_not_deriving_iterable_has_no_constant_rend() -> void { using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_cbegin_v)); + ASSERT(!(nt::impl::has_rend_v)); + } + + auto a_new__type_not_deriving_iterable_has_no_crend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crend_v)); + } + + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_begin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_begin_v)); + } + + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_constant_begin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_begin_v)); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_cbegin() -> void { - static_assert(!nt::impl::has_cbegin_v); using type_alias = nt::new_type; ASSERT(!(nt::impl::has_cbegin_v)); } - auto a_new__type_based_on_an_iterable_type_with_member_cbegin_deriving_iterable_has_member_cbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_rbegin() -> void { - static_assert(nt::impl::has_member_cbegin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_cbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); } - auto a_new__type_based_on_an_iterable_type_without_free_cbegin_deriving_iterable_has_no_free_cbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_constant_rbegin() -> void { - static_assert(!nt::impl::has_free_cbegin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_cbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rbegin_v)); } - auto accessing_the_first_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() - -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_crbegin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*weak.cbegin(), *strong.cbegin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crbegin_v)); } - auto an_iterator_obtained_via_member_cbegin_compares_equal_to_an_iterator_obtained_via_free_cbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_end() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(cbegin(instance), instance.cbegin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); } -} // namespace cbegin_tests + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_constant_end() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_end_v)); + } -inline namespace rbegin_tests -{ + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_cend() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_cend_v)); + } - auto a_new__type_not_deriving_iterable_has_no_rbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_rend() -> void { - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_rbegin_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_rend_v)); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_rbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_constant_rend() -> void { - static_assert(!nt::impl::has_rbegin_v); using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_rbegin_v)); + ASSERT(!(nt::impl::has_rend_v)); } - auto a_new__type_based_on_an_iterable_type_with_member_rbegin_deriving_iterable_has_member_rbegin() -> void + auto a_new__type_on_a_non_iterable_type_deriving_iterable_has_no_crend() -> void { - static_assert(nt::impl::has_member_rbegin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_crend_v)); } - auto a_new__type_based_on_an_iterable_type_with_constant_member_rbegin_deriving_iterable_has_constant_member_rbegin() -> void +} // namespace combined_enablement_tests + +inline namespace member_enablement_tests +{ + + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_begin() -> void { - static_assert(nt::impl::has_member_rbegin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_begin_v)); } - auto a_new__type_based_on_an_iterable_type_without_free_rbegin_deriving_iterable_has_no_free_rbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_constant_begin() -> void { - static_assert(!nt::impl::has_free_rbegin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_begin_v)); } - auto a_new__type_based_on_an_iterable_type_without_constant_free_rbegin_deriving_iterable_has_no_constant_free_rbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_cbegin() -> void { - static_assert(!nt::impl::has_free_rbegin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_rbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_cbegin_v)); } - auto accessing_the_first_element_of_a_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() - -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_rbegin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*weak.rbegin(), *strong.rbegin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_rbegin_v)); } - auto an_iterator_obtained_via_member_rbegin_compares_equal_to_an_iterator_obtained_via_free_rbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_constant_rbegin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(rbegin(instance), instance.rbegin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_rbegin_v)); } -} // namespace rbegin_tests + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_crbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_crbegin_v)); + } -inline namespace crbegin_tests -{ + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_end() -> void + { + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_end_v)); + } - auto a_new__type_not_deriving_iterable_has_no_crbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_constant_end() -> void { - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_crbegin_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_end_v)); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_crbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_cend() -> void { - static_assert(!nt::impl::has_crbegin_v); - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_crbegin_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_cend_v)); } - auto a_new__type_based_on_an_iterable_type_with_member_crbegin_deriving_iterable_has_member_crbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_rend() -> void { - static_assert(nt::impl::has_member_crbegin_v); - using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_crbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_rend_v)); } - auto a_new__type_based_on_an_iterable_type_without_free_crbegin_deriving_iterable_has_no_free_crbegin() -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_constant_rend() -> void { - static_assert(!nt::impl::has_free_crbegin_v); - using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_crbegin_v); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_rend_v)); } - auto - accessing_the_first_element_of_a_constant_reverse_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() - -> void + auto a_new__type_on_a_non_member_iterable_type_deriving_iterable_has_no_member_crend() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*weak.crbegin(), *strong.crbegin()); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_member_crend_v)); } - auto an_iterator_obtained_via_member_crbegin_compares_equal_to_an_iterator_obtained_via_free_crbegin() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_begin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(crbegin(instance), instance.crbegin()); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_begin_v); } -} // namespace crbegin_tests + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_constant_begin() -> void + { + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_begin_v); + } -inline namespace end_tests -{ + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_cbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_cbegin_v); + } - auto a_new__type_not_deriving_iterable_has_no_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_rbegin() -> void { - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_end_v)); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rbegin_v); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_constant_rbegin() -> void { - static_assert(!nt::impl::has_end_v); - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_end_v)); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rbegin_v); } - auto a_new__type_based_on_an_iterable_type_with_member_end_deriving_iterable_has_member_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_crbegin() -> void + { + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_crbegin_v); + } + + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_end() -> void { - static_assert(nt::impl::has_member_end_v); using type_alias = nt::new_type; ASSERT(nt::impl::has_member_end_v); } - auto a_new__type_based_on_an_iterable_type_with_constant_member_end_deriving_iterable_has_constant_member_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_constant_end() -> void { - static_assert(nt::impl::has_member_end_v); using type_alias = nt::new_type; ASSERT(nt::impl::has_member_end_v); } - auto a_new__type_based_on_an_iterable_type_without_free_end_deriving_iterable_has_no_free_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_cend() -> void { - static_assert(!nt::impl::has_free_end_v); using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_end_v); + ASSERT(nt::impl::has_member_cend_v); } - auto a_new__type_based_on_an_iterable_type_without_constant_free_end_deriving_iterable_has_no_constant_free_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_rend() -> void { - static_assert(!nt::impl::has_free_end_v); using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_end_v); + ASSERT(nt::impl::has_member_rend_v); } - auto accessing_the_last_element_of_an_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_constant_rend() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*(weak.end() - 1), *(strong.end() - 1)); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_rend_v); } - auto an_iterator_obtained_via_member_end_compares_equal_to_an_iterator_obtained_via_free_end() -> void + auto a_new__type_on_a_member_iterable_type_deriving_iterable_has_member_crend() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(end(instance), instance.end()); + using type_alias = nt::new_type; + ASSERT(nt::impl::has_member_crend_v); } -} // namespace end_tests +} // namespace member_enablement_tests -inline namespace cend_tests +inline namespace free_enablement_tests { - - auto a_new__type_not_deriving_iterable_has_no_cend() -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_begin() -> void { - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_cend_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_free_begin_v)); } - auto a_new__type_based_on_a_non_iterable_type_deriving_iterable_has_no_cend() -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_constant_begin() -> void { - static_assert(!nt::impl::has_cend_v); - using type_alias = nt::new_type; - ASSERT(!(nt::impl::has_cend_v)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_free_begin_v)); } - auto a_new__type_based_on_an_iterable_type_with_member_cend_deriving_iterable_has_member_cend() -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_cbegin() -> void { - static_assert(nt::impl::has_member_cend_v); using type_alias = nt::new_type; - ASSERT(nt::impl::has_member_cend_v); + ASSERT(!(nt::impl::has_free_cbegin_v)); } - auto a_new__type_based_on_an_iterable_type_without_free_cend_deriving_iterable_has_no_free_cend() -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_rbegin() -> void { - static_assert(!nt::impl::has_free_cend_v); using type_alias = nt::new_type; - ASSERT(!nt::impl::has_free_cend_v); + ASSERT(!(nt::impl::has_free_rbegin_v)); } - auto accessing_the_last_element_of_a_constant_iterator_on_a_new__type_yields_the_same_value_as_accessing_it_through_an_unwrapped_type() - -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_constant_rbegin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto weak = std::array{42, 21, 10}; - auto strong = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(*(weak.cend() - 1), *(strong.cend() - 1)); + using type_alias = nt::new_type; + ASSERT(!(nt::impl::has_free_rbegin_v)); } - auto an_iterator_obtained_via_member_cend_compares_equal_to_an_iterator_obtained_via_free_cend() -> void + auto a_new__type_on_a_non_free_iterable_type_deriving_iterable_has_no_free_crbegin() -> void { - using type_alias = nt::new_type, struct tag, deriving(nt::Iterable)>; - auto instance = type_alias{{42, 21, 10}}; - ASSERT_EQUAL(cend(instance), instance.cend())