| //===----------------------------------------------------------------------===// |
| // |
| // 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<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare> |
| // requires CopyConstructible<Compare> |
| // bool |
| // is_sorted(Iter first, Iter last, Compare comp); |
| |
| #include <algorithm> |
| #include <functional> |
| #include <cassert> |
| |
| #include "test_macros.h" |
| #include "test_iterators.h" |
| |
| #if TEST_STD_VER > 17 |
| TEST_CONSTEXPR bool test_constexpr() { |
| int ia[] = {1, 1, 0, 0}; |
| int ib[] = {0, 0, 1, 1}; |
| return std::is_sorted(std::begin(ia), std::end(ia), std::greater<int>()) |
| && !std::is_sorted(std::begin(ib), std::end(ib), std::greater<int>()); |
| } |
| #endif |
| |
| template <class Iter> |
| void |
| test() |
| { |
| { |
| int a[] = {0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a))); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| |
| { |
| int a[] = {0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| |
| { |
| int a[] = {0, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| |
| { |
| int a[] = {0, 0, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 0, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 0, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 0, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {0, 1, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 0, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 0, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 0, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 1, 0}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| { |
| int a[] = {1, 1, 1, 1}; |
| unsigned sa = sizeof(a) / sizeof(a[0]); |
| assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>())); |
| } |
| } |
| |
| int main(int, char**) |
| { |
| test<forward_iterator<const int*> >(); |
| test<bidirectional_iterator<const int*> >(); |
| test<random_access_iterator<const int*> >(); |
| test<const int*>(); |
| |
| #if TEST_STD_VER > 17 |
| static_assert(test_constexpr()); |
| #endif |
| |
| return 0; |
| } |