1 // -*- C++ -*- 2 //===-- replace.pass.cpp --------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "support/pstl_test_config.h" 11 12 #ifdef PSTL_STANDALONE_TESTS 13 #include "pstl/execution" 14 #include "pstl/algorithm" 15 #else 16 #include <execution> 17 #include <algorithm> 18 #endif // PSTL_STANDALONE_TESTS 19 20 #include "support/utils.h" 21 22 using namespace TestUtils; 23 24 // This class is needed to check the self-copying 25 struct copy_int 26 { 27 int32_t value; 28 int32_t copied_times = 0; 29 explicit copy_int(int32_t val = 0) { value = val; } 30 31 copy_int& 32 operator=(const copy_int& other) 33 { 34 if (&other == this) 35 copied_times++; 36 else 37 { 38 value = other.value; 39 copied_times = other.copied_times; 40 } 41 return *this; 42 } 43 44 bool 45 operator==(const copy_int& other) const 46 { 47 return (value == other.value); 48 } 49 }; 50 51 template <typename Iterator> 52 struct test_one_policy 53 { 54 std::size_t len; 55 Iterator data_b; 56 Iterator data_e; 57 test_one_policy(Iterator data_, std::size_t len_) 58 { 59 len = len_; 60 data_b = data_; 61 data_e = std::next(data_b, len); 62 } 63 template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename T, typename Predicate> 64 void 65 operator()(ExecutionPolicy&& exec, Iterator1 expected_b, Iterator1 expected_e, Iterator2 actual_b, 66 Iterator2 actual_e, Predicate pred, const T& value, const T& old_value) 67 { 68 using namespace std; 69 70 copy(data_b, data_e, expected_b); 71 copy(data_b, data_e, actual_b); 72 73 replace(expected_b, expected_e, old_value, value); 74 replace(exec, actual_b, actual_e, old_value, value); 75 76 EXPECT_TRUE((check<T, Iterator2>(actual_b, actual_e)), "wrong result of self assignment check"); 77 EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace"); 78 79 copy(data_b, data_e, expected_b); 80 copy(data_b, data_e, actual_b); 81 82 replace_if(expected_b, expected_e, pred, value); 83 replace_if(exec, actual_b, actual_e, pred, value); 84 EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace_if"); 85 } 86 87 template <typename T, typename Iterator1> 88 bool 89 check(Iterator1 b, Iterator1 e) 90 { 91 return true; 92 } 93 94 template <typename T, typename Iterator1> 95 typename std::enable_if<std::is_same<T, copy_int>::value, bool>::type_t 96 check(Iterator1 b, Iterator1 e) 97 { 98 return std::all_of(b, e, [](const copy_int& elem) { return elem.copied_times == 0; }); 99 } 100 }; 101 102 template <typename T1, typename T2, typename Pred> 103 void 104 test(Pred pred) 105 { 106 typedef typename Sequence<T2>::iterator iterator_type; 107 108 const std::size_t max_len = 100000; 109 110 const T1 value = T1(0); 111 const T1 new_value = T1(666); 112 113 Sequence<T2> expected(max_len); 114 Sequence<T2> actual(max_len); 115 116 Sequence<T2> data(max_len, [&value](std::size_t i) { 117 if (i % 3 == 2) 118 { 119 return T1(i); 120 } 121 else 122 { 123 return value; 124 } 125 }); 126 127 for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) 128 { 129 test_one_policy<iterator_type> temp(data.begin(), len); 130 131 invoke_on_all_policies(temp, expected.begin(), expected.begin() + len, actual.begin(), actual.begin() + len, 132 pred, new_value, value); 133 } 134 } 135 136 template <typename T> 137 struct test_non_const 138 { 139 template <typename Policy, typename Iterator> 140 void 141 operator()(Policy&& exec, Iterator iter) 142 { 143 auto is_even = [&](float64_t v) { 144 uint32_t i = (uint32_t)v; 145 return i % 2 == 0; 146 }; 147 invoke_if(exec, [&]() { replace_if(exec, iter, iter, non_const(is_even), T(0)); }); 148 } 149 }; 150 151 int32_t 152 main() 153 { 154 test<int32_t, float32_t>(__pstl::internal::equal_value<int32_t>(666)); 155 test<uint16_t, uint8_t>([](const uint16_t& elem) { return elem % 3 < 2; }); 156 test<float64_t, int64_t>([](const float64_t& elem) { return elem * elem - 3.5 * elem > 10; }); 157 test<copy_int, copy_int>([](const copy_int& val) { return val.value / 5 > 2; }); 158 159 test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); 160 161 std::cout << done() << std::endl; 162 return 0; 163 } 164