shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
Stephan T. Lavavej bf5cdd6358
[libc++][test] Fix issues found by MSVC's STL (#131787) 
* libcxx/test/support/min_allocator.h
+ Fix `tiny_size_allocator::rebind` which mistakenly said `T` instead of
`U`.
*
libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
  + `std::stable_partition` requires bidirectional iterators.
* libcxx/test/std/containers/sequences/vector.bool/max_size.pass.cpp
+ Fix allocator type given to `std::vector<bool>`. The element types are
required to match, [N5008](https://isocpp.org/files/papers/N5008.pdf)
\[container.alloc.reqmts\]/5: "*Mandates:* `allocator_type::value_type`
is the same as `X::value_type`."
* libcxx/test/std/time/time.clock/time.clock.utc/types.compile.pass.cpp
+ Mark `is_steady` as `[[maybe_unused]]`, as it appears within
`LIBCPP_STATIC_ASSERT` only.
*
libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
*
libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
* libcxx/test/std/utilities/utility/utility.swap/swap_array.pass.cpp
+ Fix MSVC warning C4127 "conditional expression is constant".
`TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED` was introduced for this
purpose, so it should be used consistently.
* libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.pass.cpp
+ Fix `gcd()` precondition violation for `signed char`. This test case
was causing `-128` to be passed as a `signed char` to `gcd()`, which is
forbidden.
* libcxx/test/std/containers/sequences/array/assert.iterators.pass.cpp
*
libcxx/test/std/containers/sequences/vector/vector.modifiers/assert.push_back.invalidation.pass.cpp
*
libcxx/test/std/input.output/iostream.format/print.fun/no_file_description.pass.cpp
+ Split some REQUIRES and XFAIL lines. This is a "nice to have" for
MSVC's internal test harness, which is extremely simple and looks for
exact comment matches to skip tests. We can recognize the specific lines
"REQUIRES: has-unix-headers" and "XFAIL: msvc", but it's a headache to
maintain if they're chained with other conditions.
* libcxx/test/support/sized_allocator.h
+ Fix x86 truncation warnings. `std::allocator` takes `std::size_t`, so
we need to `static_cast`.
*
libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/offset_range.pass.cpp
+ Fix x86 truncation warning. `std::min()` is returning
`std::streamoff`, which was being unnecessarily narrowed to
`std::size_t`.
*
libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+ Fix MSVC warning C4127 "conditional expression is constant" for an
always-true branch. This was very recently introduced by #129008 making
`N` constexpr. As it's a local constant just nine lines above, we don't
need to test whether 100 is greater than 0.
2025-03-20 15:53:25 +08:00

465 lines
14 KiB
C++
Raw Blame History

//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// <algorithm>
// template<ShuffleIterator Iter>
// Iter rotate(Iter first, Iter middle, Iter last); // constexpr since C++20
#include <algorithm>
#include <cassert>
#include <memory>
#include <type_traits>
#include <vector>
#include "test_macros.h"
#include "test_iterators.h"
#include "type_algorithms.h"
struct TestIter {
template <class Iter>
TEST_CONSTEXPR_CXX20 void operator()() const {
int ia[] = {0};
const int sa = static_cast<int>(sizeof(ia) / sizeof(ia[0]));
Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia));
assert(base(r) == ia);
assert(ia[0] == 0);
r = std::rotate(Iter(ia), Iter(ia), Iter(ia + sa));
assert(base(r) == ia + sa);
assert(ia[0] == 0);
r = std::rotate(Iter(ia), Iter(ia + sa), Iter(ia + sa));
assert(base(r) == ia);
assert(ia[0] == 0);
int ib[] = {0, 1};
const int sb = static_cast<int>(sizeof(ib) / sizeof(ib[0]));
r = std::rotate(Iter(ib), Iter(ib), Iter(ib + sb));
assert(base(r) == ib + sb);
assert(ib[0] == 0);
assert(ib[1] == 1);
r = std::rotate(Iter(ib), Iter(ib + 1), Iter(ib + sb));
assert(base(r) == ib + 1);
assert(ib[0] == 1);
assert(ib[1] == 0);
r = std::rotate(Iter(ib), Iter(ib + sb), Iter(ib + sb));
assert(base(r) == ib);
assert(ib[0] == 1);
assert(ib[1] == 0);
int ic[] = {0, 1, 2};
const int sc = static_cast<int>(sizeof(ic) / sizeof(ic[0]));
r = std::rotate(Iter(ic), Iter(ic), Iter(ic + sc));
assert(base(r) == ic + sc);
assert(ic[0] == 0);
assert(ic[1] == 1);
assert(ic[2] == 2);
r = std::rotate(Iter(ic), Iter(ic + 1), Iter(ic + sc));
assert(base(r) == ic + 2);
assert(ic[0] == 1);
assert(ic[1] == 2);
assert(ic[2] == 0);
r = std::rotate(Iter(ic), Iter(ic + 2), Iter(ic + sc));
assert(base(r) == ic + 1);
assert(ic[0] == 0);
assert(ic[1] == 1);
assert(ic[2] == 2);
r = std::rotate(Iter(ic), Iter(ic + sc), Iter(ic + sc));
assert(base(r) == ic);
assert(ic[0] == 0);
assert(ic[1] == 1);
assert(ic[2] == 2);
int id[] = {0, 1, 2, 3};
const int sd = static_cast<int>(sizeof(id) / sizeof(id[0]));
r = std::rotate(Iter(id), Iter(id), Iter(id + sd));
assert(base(r) == id + sd);
assert(id[0] == 0);
assert(id[1] == 1);
assert(id[2] == 2);
assert(id[3] == 3);
r = std::rotate(Iter(id), Iter(id + 1), Iter(id + sd));
assert(base(r) == id + 3);
assert(id[0] == 1);
assert(id[1] == 2);
assert(id[2] == 3);
assert(id[3] == 0);
r = std::rotate(Iter(id), Iter(id + 2), Iter(id + sd));
assert(base(r) == id + 2);
assert(id[0] == 3);
assert(id[1] == 0);
assert(id[2] == 1);
assert(id[3] == 2);
r = std::rotate(Iter(id), Iter(id + 3), Iter(id + sd));
assert(base(r) == id + 1);
assert(id[0] == 2);
assert(id[1] == 3);
assert(id[2] == 0);
assert(id[3] == 1);
r = std::rotate(Iter(id), Iter(id + sd), Iter(id + sd));
assert(base(r) == id);
assert(id[0] == 2);
assert(id[1] == 3);
assert(id[2] == 0);
assert(id[3] == 1);
int ie[] = {0, 1, 2, 3, 4};
const int se = static_cast<int>(sizeof(ie) / sizeof(ie[0]));
r = std::rotate(Iter(ie), Iter(ie), Iter(ie + se));
assert(base(r) == ie + se);
assert(ie[0] == 0);
assert(ie[1] == 1);
assert(ie[2] == 2);
assert(ie[3] == 3);
assert(ie[4] == 4);
r = std::rotate(Iter(ie), Iter(ie + 1), Iter(ie + se));
assert(base(r) == ie + 4);
assert(ie[0] == 1);
assert(ie[1] == 2);
assert(ie[2] == 3);
assert(ie[3] == 4);
assert(ie[4] == 0);
r = std::rotate(Iter(ie), Iter(ie + 2), Iter(ie + se));
assert(base(r) == ie + 3);
assert(ie[0] == 3);
assert(ie[1] == 4);
assert(ie[2] == 0);
assert(ie[3] == 1);
assert(ie[4] == 2);
r = std::rotate(Iter(ie), Iter(ie + 3), Iter(ie + se));
assert(base(r) == ie + 2);
assert(ie[0] == 1);
assert(ie[1] == 2);
assert(ie[2] == 3);
assert(ie[3] == 4);
assert(ie[4] == 0);
r = std::rotate(Iter(ie), Iter(ie + 4), Iter(ie + se));
assert(base(r) == ie + 1);
assert(ie[0] == 0);
assert(ie[1] == 1);
assert(ie[2] == 2);
assert(ie[3] == 3);
assert(ie[4] == 4);
r = std::rotate(Iter(ie), Iter(ie + se), Iter(ie + se));
assert(base(r) == ie);
assert(ie[0] == 0);
assert(ie[1] == 1);
assert(ie[2] == 2);
assert(ie[3] == 3);
assert(ie[4] == 4);
int ig[] = {0, 1, 2, 3, 4, 5};
const int sg = static_cast<int>(sizeof(ig) / sizeof(ig[0]));
r = std::rotate(Iter(ig), Iter(ig), Iter(ig + sg));
assert(base(r) == ig + sg);
assert(ig[0] == 0);
assert(ig[1] == 1);
assert(ig[2] == 2);
assert(ig[3] == 3);
assert(ig[4] == 4);
assert(ig[5] == 5);
r = std::rotate(Iter(ig), Iter(ig + 1), Iter(ig + sg));
assert(base(r) == ig + 5);
assert(ig[0] == 1);
assert(ig[1] == 2);
assert(ig[2] == 3);
assert(ig[3] == 4);
assert(ig[4] == 5);
assert(ig[5] == 0);
r = std::rotate(Iter(ig), Iter(ig + 2), Iter(ig + sg));
assert(base(r) == ig + 4);
assert(ig[0] == 3);
assert(ig[1] == 4);
assert(ig[2] == 5);
assert(ig[3] == 0);
assert(ig[4] == 1);
assert(ig[5] == 2);
r = std::rotate(Iter(ig), Iter(ig + 3), Iter(ig + sg));
assert(base(r) == ig + 3);
assert(ig[0] == 0);
assert(ig[1] == 1);
assert(ig[2] == 2);
assert(ig[3] == 3);
assert(ig[4] == 4);
assert(ig[5] == 5);
r = std::rotate(Iter(ig), Iter(ig + 4), Iter(ig + sg));
assert(base(r) == ig + 2);
assert(ig[0] == 4);
assert(ig[1] == 5);
assert(ig[2] == 0);
assert(ig[3] == 1);
assert(ig[4] == 2);
assert(ig[5] == 3);
r = std::rotate(Iter(ig), Iter(ig + 5), Iter(ig + sg));
assert(base(r) == ig + 1);
assert(ig[0] == 3);
assert(ig[1] == 4);
assert(ig[2] == 5);
assert(ig[3] == 0);
assert(ig[4] == 1);
assert(ig[5] == 2);
r = std::rotate(Iter(ig), Iter(ig + sg), Iter(ig + sg));
assert(base(r) == ig);
assert(ig[0] == 3);
assert(ig[1] == 4);
assert(ig[2] == 5);
assert(ig[3] == 0);
assert(ig[4] == 1);
assert(ig[5] == 2);
}
};
#if TEST_STD_VER >= 11
struct TestUniquePtr {
template <class Iter>
TEST_CONSTEXPR_CXX23 void operator()() const {
std::unique_ptr<int> ia[1];
const int sa = static_cast<int>(sizeof(ia) / sizeof(ia[0]));
for (int i = 0; i < sa; ++i)
ia[i].reset(new int(i));
Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia));
assert(base(r) == ia);
assert(*ia[0] == 0);
r = std::rotate(Iter(ia), Iter(ia), Iter(ia + sa));
assert(base(r) == ia + sa);
assert(*ia[0] == 0);
r = std::rotate(Iter(ia), Iter(ia + sa), Iter(ia + sa));
assert(base(r) == ia);
assert(*ia[0] == 0);
std::unique_ptr<int> ib[2];
const int sb = static_cast<int>(sizeof(ib) / sizeof(ib[0]));
for (int i = 0; i < sb; ++i)
ib[i].reset(new int(i));
r = std::rotate(Iter(ib), Iter(ib), Iter(ib + sb));
assert(base(r) == ib + sb);
assert(*ib[0] == 0);
assert(*ib[1] == 1);
r = std::rotate(Iter(ib), Iter(ib + 1), Iter(ib + sb));
assert(base(r) == ib + 1);
assert(*ib[0] == 1);
assert(*ib[1] == 0);
r = std::rotate(Iter(ib), Iter(ib + sb), Iter(ib + sb));
assert(base(r) == ib);
assert(*ib[0] == 1);
assert(*ib[1] == 0);
std::unique_ptr<int> ic[3];
const int sc = static_cast<int>(sizeof(ic) / sizeof(ic[0]));
for (int i = 0; i < sc; ++i)
ic[i].reset(new int(i));
r = std::rotate(Iter(ic), Iter(ic), Iter(ic + sc));
assert(base(r) == ic + sc);
assert(*ic[0] == 0);
assert(*ic[1] == 1);
assert(*ic[2] == 2);
r = std::rotate(Iter(ic), Iter(ic + 1), Iter(ic + sc));
assert(base(r) == ic + 2);
assert(*ic[0] == 1);
assert(*ic[1] == 2);
assert(*ic[2] == 0);
r = std::rotate(Iter(ic), Iter(ic + 2), Iter(ic + sc));
assert(base(r) == ic + 1);
assert(*ic[0] == 0);
assert(*ic[1] == 1);
assert(*ic[2] == 2);
r = std::rotate(Iter(ic), Iter(ic + sc), Iter(ic + sc));
assert(base(r) == ic);
assert(*ic[0] == 0);
assert(*ic[1] == 1);
assert(*ic[2] == 2);
std::unique_ptr<int> id[4];
const int sd = static_cast<int>(sizeof(id) / sizeof(id[0]));
for (int i = 0; i < sd; ++i)
id[i].reset(new int(i));
r = std::rotate(Iter(id), Iter(id), Iter(id + sd));
assert(base(r) == id + sd);
assert(*id[0] == 0);
assert(*id[1] == 1);
assert(*id[2] == 2);
assert(*id[3] == 3);
r = std::rotate(Iter(id), Iter(id + 1), Iter(id + sd));
assert(base(r) == id + 3);
assert(*id[0] == 1);
assert(*id[1] == 2);
assert(*id[2] == 3);
assert(*id[3] == 0);
r = std::rotate(Iter(id), Iter(id + 2), Iter(id + sd));
assert(base(r) == id + 2);
assert(*id[0] == 3);
assert(*id[1] == 0);
assert(*id[2] == 1);
assert(*id[3] == 2);
r = std::rotate(Iter(id), Iter(id + 3), Iter(id + sd));
assert(base(r) == id + 1);
assert(*id[0] == 2);
assert(*id[1] == 3);
assert(*id[2] == 0);
assert(*id[3] == 1);
r = std::rotate(Iter(id), Iter(id + sd), Iter(id + sd));
assert(base(r) == id);
assert(*id[0] == 2);
assert(*id[1] == 3);
assert(*id[2] == 0);
assert(*id[3] == 1);
std::unique_ptr<int> ie[5];
const int se = static_cast<int>(sizeof(ie) / sizeof(ie[0]));
for (int i = 0; i < se; ++i)
ie[i].reset(new int(i));
r = std::rotate(Iter(ie), Iter(ie), Iter(ie + se));
assert(base(r) == ie + se);
assert(*ie[0] == 0);
assert(*ie[1] == 1);
assert(*ie[2] == 2);
assert(*ie[3] == 3);
assert(*ie[4] == 4);
r = std::rotate(Iter(ie), Iter(ie + 1), Iter(ie + se));
assert(base(r) == ie + 4);
assert(*ie[0] == 1);
assert(*ie[1] == 2);
assert(*ie[2] == 3);
assert(*ie[3] == 4);
assert(*ie[4] == 0);
r = std::rotate(Iter(ie), Iter(ie + 2), Iter(ie + se));
assert(base(r) == ie + 3);
assert(*ie[0] == 3);
assert(*ie[1] == 4);
assert(*ie[2] == 0);
assert(*ie[3] == 1);
assert(*ie[4] == 2);
r = std::rotate(Iter(ie), Iter(ie + 3), Iter(ie + se));
assert(base(r) == ie + 2);
assert(*ie[0] == 1);
assert(*ie[1] == 2);
assert(*ie[2] == 3);
assert(*ie[3] == 4);
assert(*ie[4] == 0);
r = std::rotate(Iter(ie), Iter(ie + 4), Iter(ie + se));
assert(base(r) == ie + 1);
assert(*ie[0] == 0);
assert(*ie[1] == 1);
assert(*ie[2] == 2);
assert(*ie[3] == 3);
assert(*ie[4] == 4);
r = std::rotate(Iter(ie), Iter(ie + se), Iter(ie + se));
assert(base(r) == ie);
assert(*ie[0] == 0);
assert(*ie[1] == 1);
assert(*ie[2] == 2);
assert(*ie[3] == 3);
assert(*ie[4] == 4);
std::unique_ptr<int> ig[6];
const int sg = static_cast<int>(sizeof(ig) / sizeof(ig[0]));
for (int i = 0; i < sg; ++i)
ig[i].reset(new int(i));
r = std::rotate(Iter(ig), Iter(ig), Iter(ig + sg));
assert(base(r) == ig + sg);
assert(*ig[0] == 0);
assert(*ig[1] == 1);
assert(*ig[2] == 2);
assert(*ig[3] == 3);
assert(*ig[4] == 4);
assert(*ig[5] == 5);
r = std::rotate(Iter(ig), Iter(ig + 1), Iter(ig + sg));
assert(base(r) == ig + 5);
assert(*ig[0] == 1);
assert(*ig[1] == 2);
assert(*ig[2] == 3);
assert(*ig[3] == 4);
assert(*ig[4] == 5);
assert(*ig[5] == 0);
r = std::rotate(Iter(ig), Iter(ig + 2), Iter(ig + sg));
assert(base(r) == ig + 4);
assert(*ig[0] == 3);
assert(*ig[1] == 4);
assert(*ig[2] == 5);
assert(*ig[3] == 0);
assert(*ig[4] == 1);
assert(*ig[5] == 2);
r = std::rotate(Iter(ig), Iter(ig + 3), Iter(ig + sg));
assert(base(r) == ig + 3);
assert(*ig[0] == 0);
assert(*ig[1] == 1);
assert(*ig[2] == 2);
assert(*ig[3] == 3);
assert(*ig[4] == 4);
assert(*ig[5] == 5);
r = std::rotate(Iter(ig), Iter(ig + 4), Iter(ig + sg));
assert(base(r) == ig + 2);
assert(*ig[0] == 4);
assert(*ig[1] == 5);
assert(*ig[2] == 0);
assert(*ig[3] == 1);
assert(*ig[4] == 2);
assert(*ig[5] == 3);
r = std::rotate(Iter(ig), Iter(ig + 5), Iter(ig + sg));
assert(base(r) == ig + 1);
assert(*ig[0] == 3);
assert(*ig[1] == 4);
assert(*ig[2] == 5);
assert(*ig[3] == 0);
assert(*ig[4] == 1);
assert(*ig[5] == 2);
r = std::rotate(Iter(ig), Iter(ig + sg), Iter(ig + sg));
assert(base(r) == ig);
assert(*ig[0] == 3);
assert(*ig[1] == 4);
assert(*ig[2] == 5);
assert(*ig[3] == 0);
assert(*ig[4] == 1);
assert(*ig[5] == 2);
}
};
#endif // TEST_STD_VER >= 11
template <std::size_t N>
TEST_CONSTEXPR_CXX20 bool test_vector_bool() {
for (int offset = -4; offset <= 4; ++offset) {
std::vector<bool> a(N, false);
std::size_t mid = N / 2 + offset;
for (std::size_t i = mid; i < N; ++i)
a[i] = true;
std::rotate(a.begin(), a.begin() + mid, a.end());
for (std::size_t i = 0; i < N; ++i)
assert(a[i] == (i < N - mid));
}
return true;
};
TEST_CONSTEXPR_CXX20 bool test() {
types::for_each(types::forward_iterator_list<int*>(), TestIter());
#if TEST_STD_VER >= 11
if (TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED)
types::for_each(types::forward_iterator_list<std::unique_ptr<int>*>(), TestUniquePtr());
#endif
test_vector_bool<8>();
test_vector_bool<19>();
test_vector_bool<32>();
test_vector_bool<49>();
test_vector_bool<64>();
test_vector_bool<199>();
test_vector_bool<256>();
return true;
}
int main(int, char**) {
test();
#if TEST_STD_VER >= 20
static_assert(test());
#endif
return 0;
}
Reference in New Issue View Git Blame Copy Permalink