forked from OSchip/llvm-project
184 lines
8.5 KiB
C++
184 lines
8.5 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
|
|
|
|
// <algorithm>
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
|
|
#include "test_macros.h"
|
|
|
|
struct Incomplete;
|
|
template<class T> struct Holder { T t; };
|
|
|
|
template<class>
|
|
struct Intable {
|
|
TEST_CONSTEXPR operator int() const { return 1; }
|
|
};
|
|
|
|
struct Tester {
|
|
using Element = Holder<Incomplete>*;
|
|
Element data[10];
|
|
};
|
|
|
|
TEST_CONSTEXPR_CXX20 bool test()
|
|
{
|
|
Tester t {};
|
|
Tester u {};
|
|
Tester::Element value = nullptr;
|
|
Intable<Tester::Element> count;
|
|
|
|
// THESE RELY ON ADL SWAP IN PRACTICE:
|
|
// swap_ranges, iter_swap, reverse, rotate, partition
|
|
// sort, nth_element
|
|
// pop_heap, sort_heap, partial_sort, partial_sort_copy
|
|
// next_permutation, prev_permutation
|
|
// stable_partition, stable_sort, inplace_merge
|
|
// THESE RELY ON ADL SWAP IN THEORY:
|
|
// push_heap, make_heap
|
|
|
|
(void)std::all_of(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::any_of(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::copy(t.data, t.data+10, u.data);
|
|
(void)std::copy_n(t.data, count, u.data);
|
|
(void)std::copy_backward(t.data, t.data+10, u.data+10);
|
|
(void)std::count(t.data, t.data+10, value);
|
|
(void)std::count_if(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::distance(t.data, t.data+10);
|
|
(void)std::fill(t.data, t.data+10, value);
|
|
(void)std::fill_n(t.data, count, value);
|
|
(void)std::find_if(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::find_if_not(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::for_each(t.data, t.data+10, [](void*){});
|
|
#if TEST_STD_VER >= 17
|
|
(void)std::for_each_n(t.data, count, [](void*){});
|
|
#endif
|
|
(void)std::generate(t.data, t.data+10, [](){ return nullptr; });
|
|
(void)std::generate_n(t.data, count, [](){ return nullptr; });
|
|
(void)std::is_partitioned(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::move(t.data, t.data+10, u.data);
|
|
(void)std::move_backward(t.data, t.data+10, u.data+10);
|
|
(void)std::none_of(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::partition_copy(t.data, t.data+5, u.data, u.data+5, [](void*){ return true; });
|
|
(void)std::partition_point(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::remove(t.data, t.data+10, value);
|
|
(void)std::remove_copy(t.data, t.data+10, u.data, value);
|
|
(void)std::remove_copy_if(t.data, t.data+10, u.data, [](void*){ return true; });
|
|
(void)std::remove_if(t.data, t.data+10, [](void*){ return true; });
|
|
(void)std::replace(t.data, t.data+10, value, value);
|
|
(void)std::replace_copy(t.data, t.data+10, u.data, value, value);
|
|
(void)std::replace_copy_if(t.data, t.data+10, u.data, [](void*){ return true; }, value);
|
|
(void)std::replace_if(t.data, t.data+10, [](void*){ return true; }, value);
|
|
(void)std::reverse_copy(t.data, t.data+10, u.data);
|
|
(void)std::rotate_copy(t.data, t.data+5, t.data+10, u.data);
|
|
// TODO: shift_left
|
|
// TODO: shift_right
|
|
(void)std::transform(t.data, t.data+10, u.data, [](void*){ return nullptr; });
|
|
|
|
// WITHOUT COMPARATORS
|
|
(void)std::adjacent_find(t.data, t.data+10);
|
|
(void)std::binary_search(t.data, t.data+10, t.data[5]);
|
|
(void)std::equal(t.data, t.data+10, u.data);
|
|
(void)std::equal_range(t.data, t.data+10, t.data[5]);
|
|
(void)std::find_end(t.data, t.data+10, u.data, u.data+5);
|
|
(void)std::includes(t.data, t.data+10, u.data, u.data+10);
|
|
(void)std::is_heap(t.data, t.data+10);
|
|
(void)std::is_heap_until(t.data, t.data+10);
|
|
(void)std::is_permutation(t.data, t.data+10, u.data);
|
|
(void)std::is_sorted(t.data, t.data+10);
|
|
(void)std::is_sorted_until(t.data, t.data+10);
|
|
(void)std::lexicographical_compare(t.data, t.data+10, u.data, u.data+10);
|
|
// TODO: lexicographical_compare_three_way
|
|
(void)std::lower_bound(t.data, t.data+10, t.data[5]);
|
|
(void)std::max(value, value);
|
|
(void)std::max({ value, value });
|
|
(void)std::max_element(t.data, t.data+10);
|
|
(void)std::merge(t.data, t.data+5, t.data+5, t.data+10, u.data);
|
|
(void)std::min(value, value);
|
|
(void)std::min({ value, value });
|
|
(void)std::min_element(t.data, t.data+10);
|
|
(void)std::minmax(value, value);
|
|
(void)std::minmax({ value, value });
|
|
(void)std::minmax_element(t.data, t.data+10);
|
|
(void)std::mismatch(t.data, t.data+10, u.data);
|
|
(void)std::search(t.data, t.data+10, u.data, u.data+5);
|
|
(void)std::search_n(t.data, t.data+10, count, value);
|
|
(void)std::set_difference(t.data, t.data+5, t.data+5, t.data+10, u.data);
|
|
(void)std::set_intersection(t.data, t.data+5, t.data+5, t.data+10, u.data);
|
|
(void)std::set_symmetric_difference(t.data, t.data+5, t.data+5, t.data+10, u.data);
|
|
(void)std::set_union(t.data, t.data+5, t.data+5, t.data+10, u.data);
|
|
(void)std::unique(t.data, t.data+10);
|
|
(void)std::unique_copy(t.data, t.data+10, u.data);
|
|
(void)std::upper_bound(t.data, t.data+10, t.data[5]);
|
|
#if TEST_STD_VER >= 14
|
|
(void)std::equal(t.data, t.data+10, u.data, u.data+10);
|
|
(void)std::is_permutation(t.data, t.data+10, u.data, u.data+10);
|
|
(void)std::mismatch(t.data, t.data+10, u.data, u.data+10);
|
|
#endif
|
|
#if TEST_STD_VER >= 20
|
|
(void)std::clamp(value, value, value);
|
|
#endif
|
|
|
|
// WITH COMPARATORS
|
|
(void)std::adjacent_find(t.data, t.data+10, std::equal_to<void*>());
|
|
(void)std::binary_search(t.data, t.data+10, value, std::less<void*>());
|
|
(void)std::equal(t.data, t.data+10, u.data, std::equal_to<void*>());
|
|
(void)std::equal_range(t.data, t.data+10, value, std::less<void*>());
|
|
(void)std::find_end(t.data, t.data+10, u.data, u.data+5, std::equal_to<void*>());
|
|
(void)std::includes(t.data, t.data+10, u.data, u.data+10, std::less<void*>());
|
|
(void)std::is_heap(t.data, t.data+10, std::less<void*>());
|
|
(void)std::is_heap_until(t.data, t.data+10, std::less<void*>());
|
|
(void)std::is_permutation(t.data, t.data+10, u.data, std::equal_to<void*>());
|
|
(void)std::is_sorted(t.data, t.data+10, std::less<void*>());
|
|
(void)std::is_sorted_until(t.data, t.data+10, std::less<void*>());
|
|
(void)std::lexicographical_compare(t.data, t.data+10, u.data, u.data+10, std::less<void*>());
|
|
// TODO: lexicographical_compare_three_way
|
|
(void)std::lower_bound(t.data, t.data+10, value, std::less<void*>());
|
|
(void)std::max(value, value, std::less<void*>());
|
|
(void)std::max({ value, value }, std::less<void*>());
|
|
(void)std::max_element(t.data, t.data+10, std::less<void*>());
|
|
(void)std::merge(t.data, t.data+5, t.data+5, t.data+10, u.data, std::less<void*>());
|
|
(void)std::min(value, value, std::less<void*>());
|
|
(void)std::min({ value, value }, std::less<void*>());
|
|
(void)std::min_element(t.data, t.data+10, std::less<void*>());
|
|
(void)std::minmax(value, value, std::less<void*>());
|
|
(void)std::minmax({ value, value }, std::less<void*>());
|
|
(void)std::minmax_element(t.data, t.data+10, std::less<void*>());
|
|
(void)std::mismatch(t.data, t.data+10, u.data, std::equal_to<void*>());
|
|
(void)std::search(t.data, t.data+10, u.data, u.data+5, std::equal_to<void*>());
|
|
(void)std::search_n(t.data, t.data+10, count, value, std::equal_to<void*>());
|
|
(void)std::set_difference(t.data, t.data+5, t.data+5, t.data+10, u.data, std::less<void*>());
|
|
(void)std::set_intersection(t.data, t.data+5, t.data+5, t.data+10, u.data, std::less<void*>());
|
|
(void)std::set_symmetric_difference(t.data, t.data+5, t.data+5, t.data+10, u.data, std::less<void*>());
|
|
(void)std::set_union(t.data, t.data+5, t.data+5, t.data+10, u.data, std::less<void*>());
|
|
(void)std::unique(t.data, t.data+10, std::equal_to<void*>());
|
|
(void)std::unique_copy(t.data, t.data+10, u.data, std::equal_to<void*>());
|
|
(void)std::upper_bound(t.data, t.data+10, value, std::less<void*>());
|
|
#if TEST_STD_VER >= 14
|
|
(void)std::equal(t.data, t.data+10, u.data, u.data+10, std::equal_to<void*>());
|
|
(void)std::is_permutation(t.data, t.data+10, u.data, u.data+10, std::equal_to<void*>());
|
|
(void)std::mismatch(t.data, t.data+10, u.data, u.data+10, std::equal_to<void*>());
|
|
#endif
|
|
#if TEST_STD_VER >= 20
|
|
(void)std::clamp(value, value, value, std::less<void*>());
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
int main(int, char**)
|
|
{
|
|
test();
|
|
#if TEST_STD_VER >= 20
|
|
static_assert(test());
|
|
#endif
|
|
return 0;
|
|
}
|