init

Telegram/ThirdParty/range-v3/test/view/remove_if.cpp

@@ -0,0 +1,184 @@
+// Range v3 library
+//
+//  Copyright Eric Niebler 2014-present
+//
+//  Use, modification and distribution is subject to 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)
+//
+// Project home: https://github.com/ericniebler/range-v3
+
+#include <array>
+#include <vector>
+#include <iterator>
+#include <functional>
+#include <range/v3/core.hpp>
+#include <range/v3/functional/not_fn.hpp>
+#include <range/v3/view/remove_if.hpp>
+#include <range/v3/view/filter.hpp>
+#include <range/v3/view/counted.hpp>
+#include <range/v3/view/concat.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/subrange.hpp>
+#include <range/v3/utility/copy.hpp>
+#include "../simple_test.hpp"
+#include "../test_utils.hpp"
+#include "../test_iterators.hpp"
+
+struct is_odd
+{
+    constexpr bool operator()(int i) const
+    {
+        return (i % 2) == 1;
+    }
+};
+
+struct is_even
+{
+    constexpr bool operator()(int i) const
+    {
+        return (i % 2) == 0;
+    }
+};
+
+struct my_data
+{
+    int i;
+};
+
+constexpr bool operator==(my_data left, my_data right)
+{
+    return left.i == right.i;
+}
+
+int main()
+{
+    using namespace ranges;
+
+    int rgi[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+    {
+        auto rng = rgi | views::remove_if(is_even());
+        has_type<int &>(*begin(rgi));
+        has_type<int &>(*begin(rng));
+        CPP_assert(view_<decltype(rng)>);
+        CPP_assert(common_range<decltype(rng)>);
+        CPP_assert(!sized_range<decltype(rng)>);
+        CPP_assert(bidirectional_range<decltype(rng)>);
+        CPP_assert(!random_access_range<decltype(rng)>);
+        ::check_equal(rng, {1,3,5,7,9});
+        ::check_equal(rng | views::reverse, {9,7,5,3,1});
+        auto tmp = rng | views::reverse;
+        CHECK(&*begin(tmp) == &rgi[8]);
+    }
+
+    {
+        auto rng2 = views::counted(rgi, 10) | views::remove_if(not_fn(is_odd()));
+        has_type<int &>(*begin(rng2));
+        CPP_assert(view_<decltype(rng2)>);
+        CPP_assert(bidirectional_range<decltype(rng2)>);
+        CPP_assert(!random_access_range<decltype(rng2)>);
+        CPP_assert(common_range<decltype(rng2)>);
+        CPP_assert(!sized_range<decltype(rng2)>);
+        ::check_equal(rng2, {1,3,5,7,9});
+        CHECK(&*begin(rng2) == &rgi[0]);
+    }
+
+    {
+        auto rng3 = views::counted(BidirectionalIterator<int*>{rgi}, 10) | views::remove_if(is_even());
+        has_type<int &>(*begin(rng3));
+        CPP_assert(view_<decltype(rng3)>);
+        CPP_assert(bidirectional_range<decltype(rng3)>);
+        CPP_assert(!random_access_range<decltype(rng3)>);
+        CPP_assert(!common_range<decltype(rng3)>);
+        CPP_assert(!sized_range<decltype(rng3)>);
+        ::check_equal(rng3, {1,3,5,7,9});
+        CHECK(&*begin(rng3) == &rgi[0]);
+        CHECK(&*prev(next(begin(rng3))) == &rgi[0]);
+    }
+
+    {
+        // Test remove_if with a mutable lambda
+        bool flag = true;
+        auto mutable_rng = views::remove_if(rgi, [flag](int) mutable { return flag = !flag;});
+        ::check_equal(mutable_rng, {1,3,5,7,9});
+        CPP_assert(view_<decltype(mutable_rng)>);
+        CPP_assert(!view_<decltype(mutable_rng) const>);
+    }
+
+    {
+        const std::array<int, 3> a{{0, 1, 2}};
+        const std::vector<int> b{3, 4, 5, 6};
+
+        auto r = views::concat(a, b);
+        auto f = [](int i) { return i != 1 && i != 5; };
+        auto r2 = r | views::remove_if(f);
+        ::check_equal(r2, {1,5});
+    }
+
+    {
+        auto rng = debug_input_view<int const>{rgi} | views::remove_if(is_even{});
+        ::check_equal(rng, {1,3,5,7,9});
+    }
+
+    {
+        // Defend against regression of #793
+        int const some_ints[] = {1, 2, 3};
+        auto a = some_ints | ranges::views::remove_if([](int val) { return val > 0; });
+        CHECK(a.empty());
+    }
+
+    {
+        // with projection
+        const std::vector<my_data> some_my_datas{{1}, {2}, {3}, {4}};
+
+        {
+            // views::remove_if without pipe
+            auto rng = ranges::views::remove_if(some_my_datas, is_even(), &my_data::i);
+            ::check_equal(rng, std::vector<my_data>{{1}, {3}});
+        }
+
+        {
+            // views::remove_if with pipe
+            auto rng = some_my_datas | ranges::views::remove_if(is_even(), &my_data::i);
+            ::check_equal(rng, std::vector<my_data>{{1}, {3}});
+        }
+
+        {
+            // views::filter without pipe
+            auto rng = ranges::views::filter(some_my_datas, is_even(), &my_data::i);
+            ::check_equal(rng, std::vector<my_data>{{2}, {4}});
+        }
+
+        {
+            // views::filter with pipe
+            auto rng = some_my_datas | ranges::views::filter(is_even(), &my_data::i);
+            ::check_equal(rng, std::vector<my_data>{{2}, {4}});
+        }
+    }
+
+    // test constexpr binding
+    {
+        using namespace ranges;
+        constexpr std::array<int, 4> is = {{1,2,3,4}};
+        constexpr auto filter = views::remove_if(is_even()) | views::remove_if(is_odd());
+        auto rng = is | filter;
+        CHECK(rng.empty());
+    }
+    {
+        const std::vector<my_data> some_my_datas{{1}, {2}, {3}, {4}};
+        constexpr auto filter = views::remove_if(is_even(), &my_data::i) | views::remove_if(is_odd(), &my_data::i);
+        auto rng = some_my_datas | filter;
+        CHECK(rng.empty());
+    }
+
+    // test issue #1424 <https://github.com/ericniebler/range-v3/issues/1424>
+    {
+        std::vector<int> v{1, 2, 3, 4};
+        auto rng = views::filter(v, is_odd());
+        ::check_equal(rng, {1, 3});
+    }
+
+    return test_result();
+}