| //===----------------------------------------------------------------------===// |
| // |
| // 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> |
| |
| // UNSUPPORTED: c++03, c++11, c++14, c++17 |
| |
| // template<forward_iterator I, sentinel_for<I> S, class Proj = identity, |
| // indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> |
| // constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {}); |
| // |
| // template<forward_range R, class Proj = identity, |
| // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> |
| // constexpr borrowed_iterator_t<R> ranges::min_element(R&& r, Comp comp = {}, Proj proj = {}); |
| |
| #include <algorithm> |
| #include <array> |
| #include <cassert> |
| #include <functional> |
| #include <random> |
| #include <ranges> |
| |
| #include "test_macros.h" |
| #include "test_iterators.h" |
| |
| template <class T> |
| concept HasMinElement = requires (T t) { std::ranges::min_element(t); }; |
| |
| struct NoLessThanOp {}; |
| struct NotTotallyOrdered { |
| int i; |
| bool operator<(const NotTotallyOrdered& o) const { return i < o.i; } |
| }; |
| |
| static_assert(HasMinElement<std::array<int, 0>>); |
| static_assert(!HasMinElement<int>); |
| static_assert(!HasMinElement<NoLessThanOp>); |
| static_assert(!HasMinElement<NotTotallyOrdered>); |
| |
| template <class Iter> |
| constexpr void test_iterators(Iter first, Iter last) { |
| std::same_as<Iter> auto it = std::ranges::min_element(first, last); |
| if (first != last) { |
| for (Iter j = first; j != last; ++j) |
| assert(!(*j < *it)); |
| } else { |
| assert(it == first); |
| } |
| } |
| |
| template <class Range, class Iter> |
| constexpr void test_range(Range&& rng, Iter begin, Iter end) { |
| std::same_as<Iter> auto it = std::ranges::min_element(std::forward<Range>(rng)); |
| if (begin != end) { |
| for (Iter j = begin; j != end; ++j) |
| assert(!(*j < *it)); |
| } else { |
| assert(it == begin); |
| } |
| } |
| |
| template <class It> |
| constexpr void test(std::initializer_list<int> a, int expected) { |
| const int* first = a.begin(); |
| const int* last = a.end(); |
| { |
| std::same_as<It> auto it = std::ranges::min_element(It(first), It(last)); |
| assert(base(it) == first + expected); |
| } |
| { |
| using Sent = sentinel_wrapper<It>; |
| std::same_as<It> auto it = std::ranges::min_element(It(first), Sent(It(last))); |
| assert(base(it) == first + expected); |
| } |
| { |
| auto range = std::ranges::subrange(It(first), It(last)); |
| std::same_as<It> auto it = std::ranges::min_element(range); |
| assert(base(it) == first + expected); |
| } |
| { |
| using Sent = sentinel_wrapper<It>; |
| auto range = std::ranges::subrange(It(first), Sent(It(last))); |
| std::same_as<It> auto it = std::ranges::min_element(range); |
| assert(base(it) == first + expected); |
| } |
| } |
| |
| template <class It> |
| constexpr bool test() { |
| test<It>({}, 0); |
| test<It>({1}, 0); |
| test<It>({1, 2}, 0); |
| test<It>({2, 1}, 1); |
| test<It>({2, 1, 2}, 1); |
| test<It>({2, 1, 1}, 1); |
| |
| return true; |
| } |
| |
| constexpr void test_borrowed_range_and_sentinel() { |
| int a[] = {7, 6, 1, 3, 5, 1, 2, 4}; |
| |
| int* ret = std::ranges::min_element(std::views::all(a)); |
| assert(ret == a + 2); |
| assert(*ret == 1); |
| } |
| |
| constexpr void test_comparator() { |
| int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; |
| int* ret = std::ranges::min_element(a, std::ranges::greater{}); |
| assert(ret == a + 2); |
| assert(*ret == 9); |
| } |
| |
| constexpr void test_projection() { |
| int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; |
| { |
| int* ret = std::ranges::min_element(a, std::ranges::less{}, [](int i) { return i == 5 ? -100 : i; }); |
| assert(ret == a + 4); |
| assert(*ret == 5); |
| } |
| { |
| int* ret = std::ranges::min_element(a, std::less<int*>{}, [](int& i) { return &i; }); |
| assert(ret == a); |
| assert(*ret == 7); |
| } |
| } |
| |
| struct Immobile { |
| int i; |
| |
| constexpr Immobile(int i_) : i(i_) {} |
| Immobile(const Immobile&) = delete; |
| Immobile(Immobile&&) = delete; |
| |
| auto operator<=>(const Immobile&) const = default; |
| }; |
| |
| constexpr void test_immobile() { |
| |
| Immobile arr[] {1, 2, 3}; |
| assert(std::ranges::min_element(arr) == arr); |
| assert(std::ranges::min_element(arr, arr + 3) == arr); |
| } |
| |
| constexpr void test_dangling() { |
| int compares = 0; |
| int projections = 0; |
| auto comparator = [&](int a, int b) { |
| ++compares; |
| return a < b; |
| }; |
| auto projection = [&](int a) { |
| ++projections; |
| return a; |
| }; |
| [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret = |
| std::ranges::min_element(std::array{1, 2, 3}, comparator, projection); |
| assert(compares == 2); |
| assert(projections == 4); |
| } |
| |
| constexpr bool test() { |
| |
| test<forward_iterator<const int*>>(); |
| test<bidirectional_iterator<const int*>>(); |
| test<random_access_iterator<const int*>>(); |
| test<const int*>(); |
| |
| int a[] = {7, 6, 5, 3, 4, 2, 1, 8}; |
| test_iterators(a, a + 8); |
| int a2[] = {7, 6, 5, 3, 4, 2, 1, 8}; |
| test_range(a2, a2, a2 + 8); |
| |
| test_borrowed_range_and_sentinel(); |
| test_comparator(); |
| test_projection(); |
| test_dangling(); |
| |
| return true; |
| } |
| |
| int main(int, char**) { |
| test(); |
| static_assert(test()); |
| |
| return 0; |
| } |