text: //===----------------------------------------------------------------------===//
  //
  // 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<InputIterator Iter1, InputIterator Iter2, CopyConstructible Compare>
  //   requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
  //         && Predicate<Compare, Iter2::value_type, Iter1::value_type>
  //   constexpr bool             // constexpr after C++17
  //   lexicographical_compare(Iter1 first1, Iter1 last1,
  //                           Iter2 first2, Iter2 last2, Compare comp);
  
  #include "algorithm.h"
  #include <catch2/catch.hpp>
  #include <functional>
  #include <cassert>
  
  #include "test_macros.h"
  #include "test_iterators.h"
  
  namespace test_lexicographical_compare_pred {
  #if TEST_STD_VER > 17
      TEST_CONSTEXPR bool test_constexpr() {
          int ia[] = {1, 2, 3};
          int ib[] = {1, 3, 5, 2, 4, 6};
      
          std::greater<int> pred{};
          return !ddstl::lexicographical_compare(std::begin(ia), std::end(ia), std::begin(ib), std::end(ib), pred)
              &&  ddstl::lexicographical_compare(std::begin(ib), std::end(ib), std::begin(ia), std::end(ia), pred)
                 ;
          }
  #endif
  
      template<class Iter1, class Iter2>
      void
      test() {
          int ia[] = {1, 2, 3, 4};
          const unsigned sa = sizeof(ia) / sizeof(ia[0]);
          int ib[] = {1, 2, 3};
          typedef std::greater<int> C;
          C c;
          assert(!ddstl::lexicographical_compare(Iter1(ia), Iter1(ia + sa), Iter2(ib), Iter2(ib + 2), c));
          assert(ddstl::lexicographical_compare(Iter1(ib), Iter1(ib + 2), Iter2(ia), Iter2(ia + sa), c));
          assert(!ddstl::lexicographical_compare(Iter1(ia), Iter1(ia + sa), Iter2(ib), Iter2(ib + 3), c));
          assert(ddstl::lexicographical_compare(Iter1(ib), Iter1(ib + 3), Iter2(ia), Iter2(ia + sa), c));
          assert(!ddstl::lexicographical_compare(Iter1(ia), Iter1(ia + sa), Iter2(ib + 1), Iter2(ib + 3), c));
          assert(ddstl::lexicographical_compare(Iter1(ib + 1), Iter1(ib + 3), Iter2(ia), Iter2(ia + sa), c));
      }
  }
  
  TEST_CASE("test std::lexicographical_compare pred pass", "") {
      using namespace test_lexicographical_compare_pred;
      test<input_iterator<const int *>, input_iterator<const int *> >();
      test<input_iterator<const int *>, forward_iterator<const int *> >();
      test<input_iterator<const int *>, bidirectional_iterator<const int *> >();
      test<input_iterator<const int *>, random_access_iterator<const int *> >();
      test<input_iterator<const int *>, const int *>();
  
      test<forward_iterator<const int *>, input_iterator<const int *> >();
      test<forward_iterator<const int *>, forward_iterator<const int *> >();
      test<forward_iterator<const int *>, bidirectional_iterator<const int *> >();
      test<forward_iterator<const int *>, random_access_iterator<const int *> >();
      test<forward_iterator<const int *>, const int *>();
  
      test<bidirectional_iterator<const int *>, input_iterator<const int *> >();
      test<bidirectional_iterator<const int *>, forward_iterator<const int *> >();
      test<bidirectional_iterator<const int *>, bidirectional_iterator<const int *> >();
      test<bidirectional_iterator<const int *>, random_access_iterator<const int *> >();
      test<bidirectional_iterator<const int *>, const int *>();
  
      test<random_access_iterator<const int *>, input_iterator<const int *> >();
      test<random_access_iterator<const int *>, forward_iterator<const int *> >();
      test<random_access_iterator<const int *>, bidirectional_iterator<const int *> >();
      test<random_access_iterator<const int *>, random_access_iterator<const int *> >();
      test<random_access_iterator<const int *>, const int *>();
  
      test<const int *, input_iterator<const int *> >();
      test<const int *, forward_iterator<const int *> >();
      test<const int *, bidirectional_iterator<const int *> >();
      test<const int *, random_access_iterator<const int *> >();
      test<const int *, const int *>();
  
  #if TEST_STD_VER > 17
      static_assert(test_constexpr());
  #endif
  }