init

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

@@ -0,0 +1,224 @@
+// Range v3 library
+//
+//  Copyright Tobias Mayer 2016
+//  Copyright Casey Carter 2016
+//
+//  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 <forward_list>
+#include <list>
+#include <vector>
+#include <range/v3/core.hpp>
+#include <range/v3/view/chunk_by.hpp>
+#include <range/v3/view/cycle.hpp>
+#include <range/v3/view/iota.hpp>
+#include <range/v3/view/repeat.hpp>
+#include <range/v3/view/repeat_n.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/sliding.hpp>
+#include <range/v3/view/zip.hpp>
+#include "../simple_test.hpp"
+#include "../test_utils.hpp"
+
+using namespace ranges;
+
+namespace
+{
+    namespace ebo_test
+    {
+        struct empty1 {};
+        struct empty2 {};
+        struct refines : empty1, empty2 {};
+    }
+    constexpr bool broken_ebo = sizeof(ebo_test::refines) > sizeof(ebo_test::empty1);
+
+    constexpr auto N = 7;
+    constexpr auto K = 3;
+    CPP_assert(K < N);
+
+    template<typename Adapted>
+    void test_size(Adapted& a, std::true_type)
+    {
+        CPP_assert(sized_range<decltype(a)>);
+        CHECK(size(a), unsigned(N - K + 1));
+    }
+    template<typename Adapted>
+    void test_size(Adapted&, std::false_type)
+    {}
+
+    template<typename Adapted>
+    void test_common(Adapted& a, std::true_type)
+    {
+        CPP_assert(common_range<decltype(a)>);
+    }
+    // template<typename Adapted>
+    // void test_common(Adapted&, std::false_type)
+    // {}
+
+    template<typename Adapted>
+    void test_prev(Adapted& a, iterator_t<Adapted> const& it, std::true_type)
+    {
+        CPP_assert(bidirectional_range<decltype(a)>);
+        ::check_equal(*ranges::prev(it, 3), views::iota(N - K - 2, N - 2));
+    }
+    template<typename Adapted>
+    void test_prev(Adapted&, iterator_t<Adapted> const&, std::false_type)
+    {}
+
+    template<typename Rng, bool>
+    struct size_compare_
+    {
+        iterator_t<Rng> iter1_;
+        iterator_t<Rng> iter2_;
+        range_difference_t<Rng> dist_;
+    };
+    template<typename Rng>
+    struct size_compare_<Rng, true>
+    {
+        iterator_t<Rng> iter1_;
+        range_difference_t<Rng> dist_;
+    };
+
+    template<typename Rng>
+    using size_compare =
+        size_compare_<Rng, random_access_range<Rng> || (bidirectional_range<Rng> && common_range<Rng>)>;
+
+    template<typename ToBase>
+    void test_finite(ToBase to_base)
+    {
+        auto v = to_base(views::iota(0,N));
+        using Base = decltype(v);
+        auto rng = v | views::sliding(K);
+        using Adapted = decltype(rng);
+        test_size(rng, meta::bool_<sized_range<Base>>{});
+
+        using IterTagOfBase = 
+            meta::if_c<contiguous_iterator<iterator_t<Base>>,
+                std::random_access_iterator_tag,
+                iterator_tag_of<iterator_t<Base>>>;
+
+        CPP_assert(same_as<
+            IterTagOfBase,
+            iterator_tag_of<iterator_t<Adapted>>>);
+
+        auto it = ranges::begin(rng);
+        test_common(rng, meta::bool_<common_range<Base>>{});
+
+        for (auto i = 0; i <= N - K; ++i)
+        {
+            ::check_equal(*it++, views::iota(i, i + K));
+        }
+        CHECK(it == ranges::end(rng));
+
+        test_prev(rng, it, meta::bool_<bidirectional_range<Base>>{});
+
+        if (!broken_ebo)
+        {
+            CHECK(sizeof(it) == sizeof(size_compare<Base>));
+        }
+    }
+}
+
+void bug_975()
+{
+    std::vector<double> v{2.0, 2.0, 3.0, 1.0};
+    std::vector<int> i{1, 2, 1, 2};
+    std::vector<int> t{1, 1, 2, 2};
+    {
+        using namespace ranges;
+        auto vals = views::zip(v, i, t);
+        using T = std::tuple<double, int, int>;
+        auto g = vals | views::chunk_by(
+            [](T t1, T t2)
+            {
+                return std::get<2>(t1) == std::get<2>(t2);
+            }
+        );
+
+        auto windows = views::sliding(g, 2);
+        auto it = std::begin(windows);
+        (void)it;
+    }
+}
+
+int main()
+{
+    test_finite(to<std::forward_list<int>>());
+    test_finite(to<std::list<int>>());
+    test_finite(to<std::vector<int>>());
+    test_finite(identity{});
+
+    {
+        // An infinite, cyclic range with cycle length == 1
+        auto rng = views::repeat(5) | views::sliding(K);
+        CPP_assert(random_access_range<decltype(rng)>);
+        auto it = rng.begin();
+        CPP_assert(random_access_iterator<decltype(it)>);
+#if defined(__GNUC__) && !defined(__clang__) && \
+    ((__GNUC__ == 6 && __GNUC_MINOR__ < 3) || __GNUC__ < 6)
+        // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78047
+        {
+            auto deref = *it;
+            auto i = deref.begin();
+            for (auto n = 0; n < K; ++n) {
+                RANGES_ENSURE(i != deref.end());
+                CHECK(*i == 5);
+                ++i;
+            }
+            CHECK(i == deref.end());
+        }
+        auto it2 = next(it, 42);
+        CHECK(it != it2);
+        {
+            auto deref = *it;
+            auto i = deref.begin();
+            for (auto n = 0; n < K; ++n) {
+                RANGES_ENSURE(i != deref.end());
+                CHECK(*i == 5);
+                ++i;
+            }
+            CHECK(i == deref.end());
+        }
+#else
+        ::check_equal(*it, views::repeat_n(5, K));
+        auto it2 = next(it, 42);
+        CHECK(it != it2);
+        ::check_equal(*it2, views::repeat_n(5, K));
+#endif
+    }
+
+    {
+        // An infinite, cyclic range with cycle length == K
+        auto rng = views::iota(0, K) | views::cycle | views::sliding(K);
+        CPP_assert(random_access_range<decltype(rng)>);
+        auto it = rng.begin();
+        CPP_assert(random_access_iterator<decltype(it)>);
+        for (auto i = 0; i < 42; ++i)
+        {
+            ::check_equal(*it++, {0,1,2});
+            ::check_equal(*it++, {1,2,0});
+            ::check_equal(*it++, {2,0,1});
+        }
+        auto it2 = next(it, 42 * K);
+        ::check_equal(*it2, {0,1,2});
+    }
+
+    {
+        // An infinite, cyclic range with cycle length > K
+        auto rng = views::iota(0,7) | views::cycle | views::sliding(K);
+        //[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,0],[6,0,1],...
+        auto it = rng.begin();
+        CPP_assert(random_access_iterator<decltype(it)>);
+        ::check_equal(*it, {0,1,2});
+        ::check_equal(*next(it, 2), {2,3,4});
+        ::check_equal(*next(it,16), {2,3,4});
+        ::check_equal(*next(it,27), {6,0,1});
+    }
+
+    return ::test_result();
+}