f1db578f0d
Found while running libc++'s tests with MSVC's STL, where `std::array` iterators are never pointers. Most of these changes are reasonably self-explanatory (the `std::array`s are right there, and the sometimes-slightly-wrapped raw pointer types are a short distance away). A couple of changes are less obvious: In `libcxx/test/std/containers/from_range_helpers.h`, `wrap_input()` is called with `Iter` types that are constructible from raw pointers. It's also sometimes called with an `array` as the `input`, so the first overload was implicitly assuming that `array` iterators are pointers. We can fix this assumption by providing a dedicated overload for `array`, just like the one for `vector` immediately below. Finally, `from_range_helpers.h` should explicitly include both `<array>` and `<vector>`, even though they were apparently being dragged in already. In `libcxx/test/std/containers/views/views.span/span.cons/iterator_sentinel.pass.cpp`, fix `throw_operator_minus`. The error was pretty complicated, caused by the concepts machinery noticing that `value_type` and `element_type` were inconsistent. In the template instantiation context, you can see the critical detail that `throw_operator_minus<std::_Array_iterator>` is being formed. Fortunately, the fix is extremely simple. To produce `element_type` (which retains any cv-qualification, unlike `value_type`), we shouldn't attempt to `remove_pointer` with the iterator type `It`. Instead, we've already obtained the `reference` type, so we can `remove_reference_t`. (This is modern code, where we have access to the alias templates, so I saw no reason to use the older verbose form.)
90 lines
3.1 KiB
C++
90 lines
3.1 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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
|
|
// UNSUPPORTED: libcpp-has-no-incomplete-pstl
|
|
|
|
// template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
|
|
// ForwardIterator2
|
|
// replace_copy(ExecutionPolicy&& exec,
|
|
// ForwardIterator1 first, ForwardIterator1 last,
|
|
// ForwardIterator2 result,
|
|
// const T& old_value, const T& new_value);
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
#include "type_algorithms.h"
|
|
#include "test_execution_policies.h"
|
|
#include "test_iterators.h"
|
|
|
|
template <class Iter>
|
|
struct Test {
|
|
template <class ExecutionPolicy>
|
|
void operator()(ExecutionPolicy&& policy) {
|
|
{ // simple test
|
|
std::array a = {1, 2, 3, 4, 5, 6, 7, 8};
|
|
std::array<int, a.size()> out;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(std::data(out)), 3, 6);
|
|
assert((out == std::array{1, 2, 6, 4, 5, 6, 7, 8}));
|
|
}
|
|
|
|
{ // empty range works
|
|
std::array<int, 0> a = {};
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(std::data(a)), 3, 6);
|
|
}
|
|
|
|
{ // non-empty range without a match works
|
|
std::array a = {1, 2};
|
|
std::array<int, a.size()> out;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(out.data()), 3, 6);
|
|
assert((out == std::array{1, 2}));
|
|
}
|
|
|
|
{ // single element range works
|
|
std::array a = {3};
|
|
std::array<int, a.size()> out;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(std::data(out)), 3, 6);
|
|
assert((out == std::array{6}));
|
|
}
|
|
|
|
{ // two element range works
|
|
std::array a = {3, 4};
|
|
std::array<int, a.size()> out;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(std::data(out)), 3, 6);
|
|
assert((out == std::array{6, 4}));
|
|
}
|
|
|
|
{ // multiple matching elements work
|
|
std::array a = {1, 2, 3, 4, 3, 3, 5, 6, 3};
|
|
std::array<int, a.size()> out;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(std::data(out)), 3, 9);
|
|
assert((out == std::array{1, 2, 9, 4, 9, 9, 5, 6, 9}));
|
|
}
|
|
|
|
{ // large range works
|
|
std::vector<int> a(150, 3);
|
|
std::vector<int> out(a.size());
|
|
a[45] = 5;
|
|
std::replace_copy(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), Iter(out.data()), 3, 6);
|
|
|
|
std::vector<int> comp(150, 6);
|
|
comp[45] = 5;
|
|
assert(std::equal(out.begin(), out.end(), comp.begin()));
|
|
}
|
|
}
|
|
};
|
|
|
|
int main(int, char**) {
|
|
types::for_each(types::forward_iterator_list<int*>{}, TestIteratorWithPolicies<Test>{});
|
|
|
|
return 0;
|
|
}
|