xref: /llvm-project/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp (revision 0fa67d44e0abc1c79ed9b3fffcbab4681fbe4d6a)
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 // <numeric>
10 
11 // Became constexpr in C++20
12 // template<InputIterator InIter,
13 //          OutputIterator<auto, const InIter::value_type&> OutIter,
14 //          Callable<auto, const InIter::value_type&, InIter::reference> BinaryOperation>
15 //   requires HasAssign<InIter::value_type, BinaryOperation::result_type>
16 //         && Constructible<InIter::value_type, InIter::reference>
17 //         && CopyConstructible<BinaryOperation>
18 //   OutIter
19 //   partial_sum(InIter first, InIter last, OutIter result, BinaryOperation binary_op);
20 
21 #include <numeric>
22 #include <functional>
23 #include <string>
24 #include <cassert>
25 
26 #include "test_macros.h"
27 #include "test_iterators.h"
28 
29 #if TEST_STD_VER > 17
30 struct rvalue_addable
31 {
32     bool correctOperatorUsed = false;
33 
34     // make sure the predicate is passed an rvalue and an lvalue (so check that the first argument was moved)
operator ()rvalue_addable35     constexpr rvalue_addable operator()(rvalue_addable&& r, rvalue_addable const&) {
36         r.correctOperatorUsed = true;
37         return std::move(r);
38     }
39 };
40 
operator +(rvalue_addable & lhs,rvalue_addable const &)41 constexpr rvalue_addable operator+(rvalue_addable& lhs, rvalue_addable const&)
42 {
43     lhs.correctOperatorUsed = false;
44     return lhs;
45 }
46 
operator +(rvalue_addable && lhs,rvalue_addable const &)47 constexpr rvalue_addable operator+(rvalue_addable&& lhs, rvalue_addable const&)
48 {
49     lhs.correctOperatorUsed = true;
50     return std::move(lhs);
51 }
52 
53 constexpr void
test_use_move()54 test_use_move()
55 {
56     const std::size_t size = 100;
57     rvalue_addable arr[size];
58     rvalue_addable res1[size];
59     rvalue_addable res2[size];
60     std::partial_sum(arr, arr + size, res1);
61     std::partial_sum(arr, arr + size, res2, /*predicate=*/rvalue_addable());
62     // start at 1 because the first element is not moved
63     for (unsigned i = 1; i < size; ++i) assert(res1[i].correctOperatorUsed);
64     for (unsigned i = 1; i < size; ++i) assert(res2[i].correctOperatorUsed);
65 }
66 #endif // TEST_STD_VER > 17
67 
test_string()68 TEST_CONSTEXPR_CXX20 void test_string() {
69     std::string sa[] = {"a", "b", "c"};
70     std::string sr[] = {"a", "ba", "cb"};
71     std::string output[3];
72     std::adjacent_difference(sa, sa + 3, output, std::plus<std::string>());
73     for (unsigned i = 0; i < 3; ++i) assert(output[i] == sr[i]);
74 }
75 
76 template <class InIter, class OutIter>
77 TEST_CONSTEXPR_CXX20 void
test()78 test()
79 {
80     int ia[] = {1, 2, 3, 4, 5};
81     int ir[] = {1, -1, -4, -8, -13};
82     const unsigned s = sizeof(ia) / sizeof(ia[0]);
83     int ib[s] = {0};
84     OutIter r = std::partial_sum(InIter(ia), InIter(ia+s), OutIter(ib), std::minus<int>());
85     assert(base(r) == ib + s);
86     for (unsigned i = 0; i < s; ++i)
87         assert(ib[i] == ir[i]);
88 }
89 
90 TEST_CONSTEXPR_CXX20 bool
test()91 test()
92 {
93     test<cpp17_input_iterator<const int*>, cpp17_output_iterator<int*> >();
94     test<cpp17_input_iterator<const int*>, forward_iterator<int*> >();
95     test<cpp17_input_iterator<const int*>, bidirectional_iterator<int*> >();
96     test<cpp17_input_iterator<const int*>, random_access_iterator<int*> >();
97     test<cpp17_input_iterator<const int*>, int*>();
98 
99     test<forward_iterator<const int*>, cpp17_output_iterator<int*> >();
100     test<forward_iterator<const int*>, forward_iterator<int*> >();
101     test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
102     test<forward_iterator<const int*>, random_access_iterator<int*> >();
103     test<forward_iterator<const int*>, int*>();
104 
105     test<bidirectional_iterator<const int*>, cpp17_output_iterator<int*> >();
106     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
107     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
108     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
109     test<bidirectional_iterator<const int*>, int*>();
110 
111     test<random_access_iterator<const int*>, cpp17_output_iterator<int*> >();
112     test<random_access_iterator<const int*>, forward_iterator<int*> >();
113     test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
114     test<random_access_iterator<const int*>, random_access_iterator<int*> >();
115     test<random_access_iterator<const int*>, int*>();
116 
117     test<const int*, cpp17_output_iterator<int*> >();
118     test<const int*, forward_iterator<int*> >();
119     test<const int*, bidirectional_iterator<int*> >();
120     test<const int*, random_access_iterator<int*> >();
121     test<const int*, int*>();
122 
123 #if TEST_STD_VER > 17
124     test_use_move();
125 #endif // TEST_STD_VER > 17
126 
127     test_string();
128 
129     return true;
130 }
131 
main(int,char **)132 int main(int, char**)
133 {
134     test();
135 #if TEST_STD_VER > 17
136     static_assert(test());
137 #endif
138 
139     return 0;
140 }
141