1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
//===----------------------------------------------------------------------===//
//
// 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
// friend iter_rvalue_reference_t<I> iter_move(const common_iterator& i)
// noexcept(noexcept(ranges::iter_move(declval<const I&>())))
// requires input_iterator<I>;
#include <iterator>
#include <cassert>
#include <type_traits>
#include "test_iterators.h"
#include "test_macros.h"
struct IterMovingIt {
using value_type = int;
using difference_type = int;
explicit IterMovingIt() = default;
IterMovingIt(const IterMovingIt&); // copyable, but this test shouldn't make copies
IterMovingIt(IterMovingIt&&) = default;
IterMovingIt& operator=(const IterMovingIt&);
int& operator*() const;
constexpr IterMovingIt& operator++() { return *this; }
IterMovingIt operator++(int);
friend constexpr int iter_move(const IterMovingIt&) {
return 42;
}
bool operator==(std::default_sentinel_t) const;
};
static_assert(std::input_iterator<IterMovingIt>);
constexpr bool test() {
{
using It = int*;
using CommonIt = std::common_iterator<It, sentinel_wrapper<It>>;
int a[] = {1, 2, 3};
CommonIt it = CommonIt(It(a));
ASSERT_NOEXCEPT(iter_move(it));
ASSERT_NOEXCEPT(std::ranges::iter_move(it));
ASSERT_SAME_TYPE(decltype(iter_move(it)), int&&);
ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(it)), int&&);
assert(iter_move(it) == 1);
if (!std::is_constant_evaluated()) {
++it;
assert(iter_move(it) == 2);
}
}
{
using It = const int*;
using CommonIt = std::common_iterator<It, sentinel_wrapper<It>>;
int a[] = {1, 2, 3};
CommonIt it = CommonIt(It(a));
ASSERT_NOEXCEPT(iter_move(it));
ASSERT_NOEXCEPT(std::ranges::iter_move(it));
ASSERT_SAME_TYPE(decltype(iter_move(it)), const int&&);
ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(it)), const int&&);
assert(iter_move(it) == 1);
if (!std::is_constant_evaluated()) {
++it;
assert(iter_move(it) == 2);
}
}
{
using It = IterMovingIt;
using CommonIt = std::common_iterator<It, std::default_sentinel_t>;
CommonIt it = CommonIt(It());
ASSERT_NOT_NOEXCEPT(iter_move(it));
ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(it));
ASSERT_SAME_TYPE(decltype(iter_move(it)), int);
ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(it)), int);
assert(iter_move(it) == 42);
if (!std::is_constant_evaluated()) {
++it;
assert(iter_move(it) == 42);
}
}
return true;
}
int main(int, char**) {
test();
static_assert(test());
return 0;
}
|
