//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// <ranges>
// constexpr iterator& operator--();
// constexpr iterator operator--(int);
#include <ranges>
#include <array>
#include <cassert>
#include <concepts>
#include <functional>
#include <span>
#include <type_traits>
#include <utility>
#include "../types.h"
#include "test_iterators.h"
#include "test_macros.h"
template <class T>
concept HasPreDecrement = requires(T t) {
{ --t };
};
template <class T>
concept HasPostDecrement = requires(T t) {
{ t-- };
};
struct TrackingPred : TrackInitialization {
using TrackInitialization::TrackInitialization;
constexpr bool operator()(int x, int y) const { return x <= y; }
};
template <class Iter, IsConst Constant, class Sent = sentinel_wrapper<Iter>>
constexpr void test() {
using Underlying = View<Iter, Sent>;
using ChunkByView = std::ranges::chunk_by_view<Underlying, std::ranges::less_equal>;
using ChunkByIterator = std::ranges::iterator_t<ChunkByView>;
static_assert(HasPostDecrement<ChunkByIterator>);
static_assert(HasPreDecrement<ChunkByIterator>);
auto make_chunk_by_view = [](auto& arr) {
View view{Iter{arr.data()}, Sent{Iter{arr.data() + arr.size()}}};
return ChunkByView{std::move(view), std::ranges::less_equal{}};
};
// Test with a single chunk
{
std::array array{0, 1, 2, 3, 4};
ChunkByView view = make_chunk_by_view(array);
ChunkByIterator it = std::ranges::next(view.begin(), view.end());
std::same_as<ChunkByIterator&> decltype(auto) result = --it;
assert(&result == &it);
assert(base((*result).begin()) == array.data());
}
// Test with two chunks
{
std::array array{0, 1, 2, 0, 1, 2};
ChunkByView view = make_chunk_by_view(array);
ChunkByIterator it = std::ranges::next(view.begin(), view.end());
std::same_as<ChunkByIterator&> decltype(auto) result = --it;
assert(&result == &it);
assert(base((*result).begin()) == array.data() + 3);
--it;
assert(base((*result).begin()) == array.data());
}
// Test going forward and then backward on the same iterator
{
std::array array{7, 8, 9, 4, 5, 6, 1, 2, 3, 0};
ChunkByView view = make_chunk_by_view(array);
ChunkByIterator it = view.begin();
++it;
--it;
assert(base((*it).begin()) == array.data());
assert(base((*it).end()) == array.data() + 3);
++it;
++it;
--it;
assert(base((*it).begin()) == array.data() + 3);
assert(base((*it).end()) == array.data() + 6);
++it;
++it;
--it;
assert(base((*it).begin()) == array.data() + 6);
assert(base((*it).end()) == array.data() + 9);
++it;
++it;
--it;
assert(base((*it).begin()) == array.data() + 9);
}
// Decrement an iterator multiple times
if constexpr (std::ranges::common_range<Underlying>) {
std::array array{1, 2, 1, 2, 1};
ChunkByView view = make_chunk_by_view(array);
ChunkByIterator it = view.end();
--it;
--it;
--it;
assert(base((*it).begin()) == array.data());
}
// Test with a predicate that takes by non-const reference
if constexpr (!std::to_underlying(Constant)) {
std::array array{1, 2, 3, -3, -2, -1};
View v{Iter{array.data()}, Sent{Iter{array.data() + array.size()}}};
auto view = std::views::chunk_by(std::move(v), [](int& x, int& y) { return x <= y; });
auto it = std::ranges::next(view.begin());
assert(base((*it).begin()) == array.data() + 3);
--it;
assert(base((*it).begin()) == array.data());
}
// Test with a predicate that is invocable but not callable (i.e. cannot be called like regular function 'f()')
{
std::array array = {1, 2, 3, -3, -2, -1};
auto v = View{Iter{array.data()}, Sent{Iter{array.data() + array.size()}}} |
std::views::transform([](int x) { return IntWrapper{x}; });
auto view = std::views::chunk_by(std::move(v), &IntWrapper::lessEqual);
auto it = std::ranges::next(view.begin());
assert(base((*it).begin().base()) == array.data() + 3);
--it;
assert(base((*it).begin().base()) == array.data());
}
// Make sure we do not make a copy of the predicate when we decrement
if constexpr (std::ranges::common_range<Underlying>) {
bool moved = false, copied = false;
std::array array{1, 2, 1, 3};
View v{Iter(array.data()), Sent(Iter(array.data() + array.size()))};
auto view = std::views::chunk_by(std::move(v), TrackingPred(&moved, &copied));
assert(std::exchange(moved, false));
auto it = view.end();
--it;
it--;
assert(!moved);
assert(!copied);
}
// Check post-decrement
{
std::array array{0, 1, 2, -3, -2, -1, -6, -5, -4};
ChunkByView view = make_chunk_by_view(array);
ChunkByIterator it = std::ranges::next(view.begin(), view.end());
std::same_as<ChunkByIterator> decltype(auto) result = it--;
assert(result != it);
assert(result == std::default_sentinel);
assert(base((*it).begin()) == array.data() + 6);
result = it--;
assert(base((*it).begin()) == array.data() + 3);
assert(base((*result).begin()) == array.data() + 6);
result = it--;
assert(base((*it).begin()) == array.data());
assert(base((*result).begin()) == array.data() + 3);
}
}
template <class Iterator, IsConst Constant>
constexpr void test_with_pair() {
// Test with pair of iterators
test<Iterator, Constant>();
// Test with iterator-sentinel pair
test<Iterator, Constant, Iterator>();
}
constexpr bool tests() {
test_with_pair<bidirectional_iterator<int*>, IsConst::no>();
test_with_pair<random_access_iterator<int*>, IsConst::no>();
test_with_pair<contiguous_iterator<int*>, IsConst::no>();
test_with_pair<int*, IsConst::no>();
test_with_pair<bidirectional_iterator<int const*>, IsConst::yes>();
test_with_pair<random_access_iterator<int const*>, IsConst::yes>();
test_with_pair<contiguous_iterator<int const*>, IsConst::yes>();
test_with_pair<int const*, IsConst::yes>();
// Make sure `operator--` isn't provided for non bidirectional ranges
{
using ForwardView = View<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>;
using ChunkByView = std::ranges::chunk_by_view<ForwardView, std::ranges::less_equal>;
static_assert(!HasPreDecrement<std::ranges::iterator_t<ChunkByView>>);
static_assert(!HasPostDecrement<std::ranges::iterator_t<ChunkByView>>);
}
return true;
}
int main(int, char**) {
tests();
static_assert(tests());
return 0;
}
Codebase Browser
llvm