211 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++1710// REQUIRES: stdlib=libc++11 12// [alg.func.obj]13// [algorithms.requirements]/214// [range.iter.ops.general]/215 16#include <algorithm>17#include <concepts>18#include <functional>19#include <iterator>20#include <memory>21#include <random>22#include <ranges>23#include <type_traits>24#include <utility>25 26#include "test_macros.h"27 28// Before P3136R1, niebloids were pedantically not CPOs, and they were *not* required to be semiregular or29// even to have a declared type at all; they were specified as "magic" overload sets30// whose names are not found by argument-dependent lookup and31// which inhibit argument-dependent lookup if they are found via a `using`-declaration.32//33// As of P3136R1, niebloids (formally known as algorithm function objects) are required to be CPOs.34//35// libc++ implements niebloids in the same way as CPOs since LLVM 14;36// therefore this file should stay in sync with ./cpo.compile.pass.cpp.37 38template <class CPO, class... Args>39constexpr bool test(CPO& o, Args&&...) {40 static_assert(std::is_const_v<CPO>);41 static_assert(std::is_class_v<CPO>);42 static_assert(std::is_trivially_copyable_v<CPO>);43 static_assert(std::is_trivially_default_constructible_v<CPO>);44 45 auto p = o;46 using T = decltype(p);47 48 // The type of a customization point object, ignoring cv-qualifiers, shall model semiregular.49 static_assert(std::semiregular<T>);50 51 // The type T of a customization point object, ignoring cv-qualifiers, shall model...52 static_assert(std::invocable<T&, Args...>);53 static_assert(std::invocable<const T&, Args...>);54 static_assert(std::invocable<T, Args...>);55 static_assert(std::invocable<const T, Args...>);56 57 return true;58}59 60int *p;61int a[10];62auto odd = [](int x) { return x % 2 != 0; };63auto triple = [](int x) { return 3*x; };64auto gen = [] { return 42; };65std::mt19937 g;66 67// [algorithm.syn]68 69static_assert(test(std::ranges::adjacent_find, a));70static_assert(test(std::ranges::all_of, a, odd));71static_assert(test(std::ranges::any_of, a, odd));72static_assert(test(std::ranges::binary_search, a, 42));73static_assert(test(std::ranges::clamp, 42, 42, 42));74#if TEST_STD_VER >= 2375static_assert(test(std::ranges::contains, a, 42));76static_assert(test(std::ranges::contains_subrange, a, a));77#endif78static_assert(test(std::ranges::copy, a, a));79static_assert(test(std::ranges::copy_backward, a, a));80static_assert(test(std::ranges::copy_if, a, a, odd));81static_assert(test(std::ranges::copy_n, a, 10, a));82static_assert(test(std::ranges::count, a, 42));83static_assert(test(std::ranges::count_if, a, odd));84#if TEST_STD_VER >= 2385static_assert(test(std::ranges::ends_with, a, a));86#endif87static_assert(test(std::ranges::equal, a, a));88static_assert(test(std::ranges::equal_range, a, 42));89static_assert(test(std::ranges::fill, a, 42));90static_assert(test(std::ranges::fill_n, a, 10, 42));91static_assert(test(std::ranges::find, a, 42));92static_assert(test(std::ranges::find_end, a, a));93static_assert(test(std::ranges::find_first_of, a, a));94static_assert(test(std::ranges::find_if, a, odd));95static_assert(test(std::ranges::find_if_not, a, odd));96#if TEST_STD_VER >= 2397static_assert(test(std::ranges::find_last, a, 42));98static_assert(test(std::ranges::find_last_if, a, odd));99static_assert(test(std::ranges::find_last_if_not, a, odd));100static_assert(test(std::ranges::fold_left, a, 0, std::plus()));101static_assert(test(std::ranges::fold_left_with_iter, a, 0, std::plus()));102#endif103static_assert(test(std::ranges::for_each, a, odd));104static_assert(test(std::ranges::for_each_n, a, 10, odd));105static_assert(test(std::ranges::generate, a, gen));106static_assert(test(std::ranges::generate_n, a, 10, gen));107static_assert(test(std::ranges::includes, a, a));108static_assert(test(std::ranges::inplace_merge, a, a+5));109static_assert(test(std::ranges::is_heap, a));110static_assert(test(std::ranges::is_heap_until, a));111static_assert(test(std::ranges::is_partitioned, a, odd));112static_assert(test(std::ranges::is_permutation, a, a));113static_assert(test(std::ranges::is_sorted, a));114static_assert(test(std::ranges::is_sorted_until, a));115static_assert(test(std::ranges::lexicographical_compare, a, a));116static_assert(test(std::ranges::lower_bound, a, 42));117static_assert(test(std::ranges::make_heap, a));118static_assert(test(std::ranges::max, a));119static_assert(test(std::ranges::max_element, a));120static_assert(test(std::ranges::merge, a, a, a));121static_assert(test(std::ranges::min, a));122static_assert(test(std::ranges::min_element, a));123static_assert(test(std::ranges::minmax, a));124static_assert(test(std::ranges::minmax_element, a));125static_assert(test(std::ranges::mismatch, a, a));126static_assert(test(std::ranges::move, a, a));127static_assert(test(std::ranges::move_backward, a, a));128static_assert(test(std::ranges::next_permutation, a));129static_assert(test(std::ranges::none_of, a, odd));130static_assert(test(std::ranges::nth_element, a, a+5));131static_assert(test(std::ranges::partial_sort, a, a+5));132static_assert(test(std::ranges::partial_sort_copy, a, a));133static_assert(test(std::ranges::partition, a, odd));134static_assert(test(std::ranges::partition_copy, a, a, a, odd));135static_assert(test(std::ranges::partition_point, a, odd));136static_assert(test(std::ranges::pop_heap, a));137static_assert(test(std::ranges::prev_permutation, a));138static_assert(test(std::ranges::push_heap, a));139static_assert(test(std::ranges::remove, a, 42));140static_assert(test(std::ranges::remove_copy, a, a, 42));141static_assert(test(std::ranges::remove_copy_if, a, a, odd));142static_assert(test(std::ranges::remove_if, a, odd));143static_assert(test(std::ranges::replace, a, 42, 43));144static_assert(test(std::ranges::replace_copy, a, a, 42, 43));145static_assert(test(std::ranges::replace_copy_if, a, a, odd, 43));146static_assert(test(std::ranges::replace_if, a, odd, 43));147static_assert(test(std::ranges::reverse, a));148static_assert(test(std::ranges::reverse_copy, a, a));149static_assert(test(std::ranges::rotate, a, a+5));150static_assert(test(std::ranges::rotate_copy, a, a+5, a));151static_assert(test(std::ranges::sample, a, a, 5, g));152static_assert(test(std::ranges::search, a, a));153static_assert(test(std::ranges::search_n, a, 10, 42));154static_assert(test(std::ranges::set_difference, a, a, a));155static_assert(test(std::ranges::set_intersection, a, a, a));156static_assert(test(std::ranges::set_symmetric_difference, a, a, a));157static_assert(test(std::ranges::set_union, a, a, a));158static_assert(test(std::ranges::shuffle, a, g));159static_assert(test(std::ranges::sort, a));160static_assert(test(std::ranges::sort_heap, a));161static_assert(test(std::ranges::stable_partition, a, odd));162static_assert(test(std::ranges::stable_sort, a));163#if TEST_STD_VER > 20164static_assert(test(std::ranges::starts_with, a, a));165#endif166static_assert(test(std::ranges::swap_ranges, a, a));167static_assert(test(std::ranges::transform, a, a, triple));168static_assert(test(std::ranges::unique, a));169static_assert(test(std::ranges::unique_copy, a, a));170static_assert(test(std::ranges::upper_bound, a, 42));171 172// [memory.syn]173 174static_assert(test(std::ranges::construct_at, a, 42));175static_assert(test(std::ranges::destroy, a));176static_assert(test(std::ranges::destroy, a, a+10));177static_assert(test(std::ranges::destroy_at, a));178static_assert(test(std::ranges::destroy_n, a, 10));179static_assert(test(std::ranges::uninitialized_copy, a, a));180static_assert(test(std::ranges::uninitialized_copy, a, a+10, a, a+10));181static_assert(test(std::ranges::uninitialized_copy_n, a, 10, a, a+10));182static_assert(test(std::ranges::uninitialized_default_construct, a));183static_assert(test(std::ranges::uninitialized_default_construct, a, a+10));184static_assert(test(std::ranges::uninitialized_default_construct_n, a, 10));185static_assert(test(std::ranges::uninitialized_fill, a, 42));186static_assert(test(std::ranges::uninitialized_fill, a, a+10, 42));187static_assert(test(std::ranges::uninitialized_fill_n, a, 10, 42));188static_assert(test(std::ranges::uninitialized_move, a, a));189static_assert(test(std::ranges::uninitialized_move, a, a+10, a, a+10));190static_assert(test(std::ranges::uninitialized_move_n, a, 10, a, a+10));191static_assert(test(std::ranges::uninitialized_value_construct, a));192static_assert(test(std::ranges::uninitialized_value_construct, a, a+10));193static_assert(test(std::ranges::uninitialized_value_construct_n, a, 10));194 195// [numeric.ops.overview] currently has no ranges algorithms. See P1813, P2214196 197// [range.iter.ops]198 199static_assert(test(std::ranges::advance, p, 5));200static_assert(test(std::ranges::advance, p, 5, a+10));201static_assert(test(std::ranges::advance, p, a+10));202static_assert(test(std::ranges::distance, a));203static_assert(test(std::ranges::distance, a, a+10));204static_assert(test(std::ranges::next, a));205static_assert(test(std::ranges::next, a, 5));206static_assert(test(std::ranges::next, a, 5, a+10));207static_assert(test(std::ranges::next, a, a+10));208static_assert(test(std::ranges::prev, a+10));209static_assert(test(std::ranges::prev, a+10, 5));210static_assert(test(std::ranges::prev, a+10, 5, a));211