1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <algorithm>
10
11// UNSUPPORTED: c++03, c++11, c++14, c++17
12
13// template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
14// indirect_unary_predicate<projected<I, Proj>> Pred>
15// requires indirectly_writable<I, const T&>
16// constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
17// template<input_range R, class T, class Proj = identity,
18// indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
19// requires indirectly_writable<iterator_t<R>, const T&>
20// constexpr borrowed_iterator_t<R>
21// ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
22
23#include <algorithm>
24#include <array>
25#include <cassert>
26#include <ranges>
27
28#include "almost_satisfies_types.h"
29#include "test_iterators.h"
30
31struct FalsePredicate {
32 bool operator()(auto&&) { return false; }
33};
34
35template <class Iter, class Sent = sentinel_wrapper<Iter>>
36concept HasReplaceIt = requires(Iter iter, Sent sent) { std::ranges::replace_if(iter, sent, FalsePredicate{}, 0); };
37
38static_assert(HasReplaceIt<int*>);
39static_assert(!HasReplaceIt<InputIteratorNotDerivedFrom>);
40static_assert(!HasReplaceIt<InputIteratorNotIndirectlyReadable>);
41static_assert(!HasReplaceIt<InputIteratorNotInputOrOutputIterator>);
42static_assert(!HasReplaceIt<int*, SentinelForNotSemiregular>);
43static_assert(!HasReplaceIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
44static_assert(!HasReplaceIt<int**>); // not indirectly_writable
45static_assert(!HasReplaceIt<IndirectBinaryPredicateNotIndirectlyReadable>);
46
47template <class Range>
48concept HasReplaceR = requires(Range range) { std::ranges::replace_if(range, FalsePredicate{}, 0); };
49
50static_assert(HasReplaceR<UncheckedRange<int*>>);
51static_assert(!HasReplaceR<InputRangeNotDerivedFrom>);
52static_assert(!HasReplaceR<InputRangeNotIndirectlyReadable>);
53static_assert(!HasReplaceR<InputRangeNotInputOrOutputIterator>);
54static_assert(!HasReplaceR<InputRangeNotSentinelSemiregular>);
55static_assert(!HasReplaceR<InputRangeNotSentinelEqualityComparableWith>);
56static_assert(!HasReplaceR<UncheckedRange<int**>>); // not indirectly_writable
57static_assert(!HasReplaceR<InputRangeIndirectBinaryPredicateNotIndirectlyReadable>);
58
59template <class Iter, class Sent, int N, class Pred>
60constexpr void test(std::array<int, N> a_, Pred pred, int val, std::array<int, N> expected) {
61 {
62 auto a = a_;
63 std::same_as<Iter> auto ret = std::ranges::replace_if(Iter(a.data()), Sent(Iter(a.data() + N)),
64 pred,
65 val);
66 assert(base(ret) == a.data() + N);
67 assert(a == expected);
68 }
69 {
70 auto a = a_;
71 auto range = std::ranges::subrange(Iter(a.data()), Sent(Iter(a.data() + N)));
72 std::same_as<Iter> auto ret = std::ranges::replace_if(range, pred, val);
73 assert(base(ret) == a.data() + N);
74 assert(a == expected);
75 }
76}
77
78template <class Iter, class Sent = Iter>
79constexpr void test_iterators() {
80 // simple test
81 test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 3; }, 23, {23, 23, 3, 4});
82 // no match
83 test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 0; }, 23, {1, 2, 3, 4});
84 // all match
85 test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i > 0; }, 23, {23, 23, 23, 23});
86 // empty range
87 test<Iter, Sent, 0>({}, [](int i) { return i > 0; }, 23, {});
88 // single element range
89 test<Iter, Sent, 1>({1}, [](int i) { return i > 0; }, 2, {2});
90}
91
92constexpr bool test() {
93 test_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
94 test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
95 test_iterators<forward_iterator<int*>>();
96 test_iterators<bidirectional_iterator<int*>>();
97 test_iterators<random_access_iterator<int*>>();
98 test_iterators<contiguous_iterator<int*>>();
99 test_iterators<int*>();
100
101 { // check that the projection is used
102 struct S {
103 constexpr S(int i_) : i(i_) {}
104 int i;
105 };
106 {
107 S a[] = {1, 2, 3, 4};
108 std::ranges::replace_if(a, a + 4, [](int i) { return i == 3; }, S{0}, &S::i);
109 }
110 {
111 S a[] = {1, 2, 3, 4};
112 std::ranges::replace_if(a, [](int i) { return i == 3; }, S{0}, &S::i);
113 }
114 }
115
116 { // check that std::invoke is used
117 struct S {
118 constexpr S(int i_) : i(i_) {}
119 constexpr bool check() const { return false; }
120 constexpr const S& identity() const { return *this; }
121 int i;
122 };
123 {
124 S a[] = {1, 2, 3, 4};
125 auto ret = std::ranges::replace_if(std::begin(a), std::end(a), &S::check, S{2}, &S::identity);
126 assert(ret == std::end(a));
127 }
128 {
129 S a[] = {1, 2, 3, 4};
130 auto ret = std::ranges::replace_if(a, &S::check, S{2}, &S::identity);
131 assert(ret == std::end(a));
132 }
133 }
134
135 { // check that std::ranges::dangling is returned
136 [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
137 std::ranges::replace_if(std::array {1, 2, 3, 4}, [](int) { return false; }, 1);
138 }
139
140 { // check that the complexity requirements are met
141 {
142 int predicateCount = 0;
143 auto pred = [&](int) { ++predicateCount; return false; };
144 auto projectionCount = 0;
145 auto proj = [&](int i) { ++projectionCount; return i; };
146 int a[] = {1, 2, 3, 4, 5};
147 auto ret = std::ranges::replace_if(a, a + 5, pred, 1, proj);
148 assert(ret == a + 5);
149 assert(predicateCount == 5);
150 assert(projectionCount == 5);
151 }
152 {
153 int predicateCount = 0;
154 auto pred = [&](int) { ++predicateCount; return false; };
155 auto projectionCount = 0;
156 auto proj = [&](int i) { ++projectionCount; return i; };
157 int a[] = {1, 2, 3, 4, 5};
158 auto ret = std::ranges::replace_if(a, pred, 1, proj);
159 assert(ret == a + 5);
160 assert(predicateCount == 5);
161 assert(projectionCount == 5);
162 }
163 }
164
165 return true;
166}
167
168int main(int, char**) {
169 test();
170 static_assert(test());
171
172 return 0;
173}
174

source code of libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges.replace_if.pass.cpp