llvm/libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// <vector>

// reverse_iterator       rbegin();
// reverse_iterator       rend();
// const_reverse_iterator rbegin()  const;
// const_reverse_iterator rend()    const;
// const_reverse_iterator crbegin() const;
// const_reverse_iterator crend()   const;

#include <vector>
#include <cassert>
#include <iterator>

#include "min_allocator.h"

template <class Vector>
TEST_CONSTEXPR_CXX20 void check_vector_reverse_iterators() {
    {
        Vector vec;
        assert(vec.rbegin() == vec.rend());
        assert(vec.crbegin() == vec.crend());
    }
    {
        const int n = 10;
        Vector vec;
        const Vector& cvec = vec;
        vec.reserve(n);
        for (int i = 0; i < n; ++i)
            vec.push_back(i);
        {
            int iterations = 0;

            for (typename Vector::const_reverse_iterator it = vec.crbegin(); it != vec.crend(); ++it) {
                assert(*it == (n - iterations - 1));
                ++iterations;
            }
            assert(iterations == n);
        }
        {
            assert(cvec.rbegin() == vec.crbegin());
            assert(cvec.rend() == vec.crend());
        }
        {
            int iterations = 0;

            for (typename Vector::reverse_iterator it = vec.rbegin(); it != vec.rend(); ++it) {
                assert(*it == (n - iterations - 1));
                *it = 40;
                assert(*it == 40);
                ++iterations;
            }
            assert(iterations == n);
        }

        assert(std::distance(vec.rbegin(), vec.rend()) == n);
        assert(std::distance(cvec.rbegin(), cvec.rend()) == n);
        assert(std::distance(vec.crbegin(), vec.crend()) == n);
        assert(std::distance(cvec.crbegin(), cvec.crend()) == n);
    }
}

TEST_CONSTEXPR_CXX20 bool test() {
    check_vector_reverse_iterators<std::vector<int> >();
#if TEST_STD_VER >= 11
    check_vector_reverse_iterators<std::vector<int, min_allocator<int> > >();
#endif

    return true;
}

int main(int, char**) {
    test();
#if TEST_STD_VER > 17
    static_assert(test());
#endif

    return 0;
}