From d4bd58ad1f83c8e67aead67e2a0e925e05de6904 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ion=20Gazta=C3=B1aga?= Date: Wed, 18 Mar 2026 16:32:57 +0100 Subject: [PATCH] Added tests for all_of, any_of, none_of --- experimental/segmented_all_of_test.cpp | 108 ++++++++++++++++++++++++ experimental/segmented_any_of_test.cpp | 108 ++++++++++++++++++++++++ experimental/segmented_none_of_test.cpp | 108 ++++++++++++++++++++++++ 3 files changed, 324 insertions(+) create mode 100644 experimental/segmented_all_of_test.cpp create mode 100644 experimental/segmented_any_of_test.cpp create mode 100644 experimental/segmented_none_of_test.cpp diff --git a/experimental/segmented_all_of_test.cpp b/experimental/segmented_all_of_test.cpp new file mode 100644 index 0000000..3bb6849 --- /dev/null +++ b/experimental/segmented_all_of_test.cpp @@ -0,0 +1,108 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2025-2026. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include "segmented_test_helper.hpp" +#include + +using namespace boost::container; + +struct is_positive +{ + bool operator()(int x) const { return x > 0; } +}; + +void test_all_of_true() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_all_of(sv.begin(), sv.end(), is_positive())); +} + +void test_all_of_false() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(!segmented_all_of(sv.begin(), sv.end(), is_positive())); +} + +void test_all_of_empty() +{ + test_detail::seg_vector sv; + BOOST_TEST(segmented_all_of(sv.begin(), sv.end(), is_positive())); +} + +void test_all_of_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + BOOST_TEST(segmented_all_of(v.begin(), v.end(), is_positive())); + + v.clear(); + v.push_back(1); + v.push_back(-2); + v.push_back(3); + BOOST_TEST(!segmented_all_of(v.begin(), v.end(), is_positive())); +} + +void test_all_of_sentinel_segmented() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_all_of(sv.begin(), test_detail::make_sentinel(sv.end()), is_positive())); +} + +void test_all_of_sentinel_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(-2); + v.push_back(3); + + BOOST_TEST(!segmented_all_of(v.begin(), test_detail::make_sentinel(v.end()), is_positive())); +} + +void test_all_of_seg2() +{ + test_detail::seg2_vector sv2; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv2.add_flat_segment_range(a1, a1 + 3); + sv2.add_flat_segment_range(a2, a2 + 3); + + BOOST_TEST(!segmented_all_of(sv2.begin(), sv2.end(), is_positive())); +} + +int main() +{ + test_all_of_true(); + test_all_of_false(); + test_all_of_empty(); + test_all_of_non_segmented(); + test_all_of_sentinel_segmented(); + test_all_of_sentinel_non_segmented(); + test_all_of_seg2(); + return boost::report_errors(); +} diff --git a/experimental/segmented_any_of_test.cpp b/experimental/segmented_any_of_test.cpp new file mode 100644 index 0000000..e358c9b --- /dev/null +++ b/experimental/segmented_any_of_test.cpp @@ -0,0 +1,108 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2025-2026. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include "segmented_test_helper.hpp" +#include + +using namespace boost::container; + +struct is_negative +{ + bool operator()(int x) const { return x < 0; } +}; + +void test_any_of_true() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_any_of(sv.begin(), sv.end(), is_negative())); +} + +void test_any_of_false() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(!segmented_any_of(sv.begin(), sv.end(), is_negative())); +} + +void test_any_of_empty() +{ + test_detail::seg_vector sv; + BOOST_TEST(!segmented_any_of(sv.begin(), sv.end(), is_negative())); +} + +void test_any_of_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(-2); + v.push_back(3); + BOOST_TEST(segmented_any_of(v.begin(), v.end(), is_negative())); + + v.clear(); + v.push_back(1); + v.push_back(2); + v.push_back(3); + BOOST_TEST(!segmented_any_of(v.begin(), v.end(), is_negative())); +} + +void test_any_of_sentinel_segmented() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_any_of(sv.begin(), test_detail::make_sentinel(sv.end()), is_negative())); +} + +void test_any_of_sentinel_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(-2); + v.push_back(3); + + BOOST_TEST(segmented_any_of(v.begin(), test_detail::make_sentinel(v.end()), is_negative())); +} + +void test_any_of_seg2() +{ + test_detail::seg2_vector sv2; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv2.add_flat_segment_range(a1, a1 + 3); + sv2.add_flat_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_any_of(sv2.begin(), sv2.end(), is_negative())); +} + +int main() +{ + test_any_of_true(); + test_any_of_false(); + test_any_of_empty(); + test_any_of_non_segmented(); + test_any_of_sentinel_segmented(); + test_any_of_sentinel_non_segmented(); + test_any_of_seg2(); + return boost::report_errors(); +} diff --git a/experimental/segmented_none_of_test.cpp b/experimental/segmented_none_of_test.cpp new file mode 100644 index 0000000..253caf0 --- /dev/null +++ b/experimental/segmented_none_of_test.cpp @@ -0,0 +1,108 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2025-2026. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/container for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include "segmented_test_helper.hpp" +#include + +using namespace boost::container; + +struct is_negative +{ + bool operator()(int x) const { return x < 0; } +}; + +void test_none_of_true() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_none_of(sv.begin(), sv.end(), is_negative())); +} + +void test_none_of_false() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(!segmented_none_of(sv.begin(), sv.end(), is_negative())); +} + +void test_none_of_empty() +{ + test_detail::seg_vector sv; + BOOST_TEST(segmented_none_of(sv.begin(), sv.end(), is_negative())); +} + +void test_none_of_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(2); + v.push_back(3); + BOOST_TEST(segmented_none_of(v.begin(), v.end(), is_negative())); + + v.clear(); + v.push_back(1); + v.push_back(-2); + v.push_back(3); + BOOST_TEST(!segmented_none_of(v.begin(), v.end(), is_negative())); +} + +void test_none_of_sentinel_segmented() +{ + test_detail::seg_vector sv; + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + sv.add_segment_range(a1, a1 + 3); + sv.add_segment_range(a2, a2 + 3); + + BOOST_TEST(segmented_none_of(sv.begin(), test_detail::make_sentinel(sv.end()), is_negative())); +} + +void test_none_of_sentinel_non_segmented() +{ + std::vector v; + v.push_back(1); + v.push_back(-2); + v.push_back(3); + + BOOST_TEST(!segmented_none_of(v.begin(), test_detail::make_sentinel(v.end()), is_negative())); +} + +void test_none_of_seg2() +{ + test_detail::seg2_vector sv2; + int a1[] = {1, 2, 3}; + int a2[] = {-4, 5, 6}; + sv2.add_flat_segment_range(a1, a1 + 3); + sv2.add_flat_segment_range(a2, a2 + 3); + + BOOST_TEST(!segmented_none_of(sv2.begin(), sv2.end(), is_negative())); +} + +int main() +{ + test_none_of_true(); + test_none_of_false(); + test_none_of_empty(); + test_none_of_non_segmented(); + test_none_of_sentinel_segmented(); + test_none_of_sentinel_non_segmented(); + test_none_of_seg2(); + return boost::report_errors(); +}