libcxx/test/std/algorithms/ranges_robust_against_differing_projections.pass.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-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17
  10
  11 // <algorithm>
  12 //
  13 // Range algorithms should support the case where the ranges they operate on have different value types and the given
  14 // projection functors are different (each projection applies to a different value type).
  15
  16 #include <algorithm>
  17
  18 #include <array>
  19 #include <functional>
  20 #include <iterator>
  21 #include <ranges>
  22 #include <utility>
  23 #include "test_macros.h"
  24
  25 // (in1, in2, ...)
  26 template <class Func, std::ranges::range Input1, std::ranges::range Input2, class ...Args>
  27 constexpr void test(Func&& func, Input1& in1, Input2& in2, Args&& ...args) {
  28   (void)func(in1.begin(), in1.end(), in2.begin(), in2.end(), std::forward<Args>(args)...);
  29   (void)func(in1, in2, std::forward<Args>(args)...);
  30 }
  31
  32 constexpr bool test_all() {
  33   struct A {
  34     int x = 0;
  35
  36     constexpr A() = default;
  37     constexpr A(int value) : x(value) {}
  38     constexpr operator int() const { return x; }
  39
  40     constexpr auto operator<=>(const A&) const = default;
  41   };
  42
  43   std::array in = {1, 2, 3};
  44   std::array in2 = {A{4}, A{5}, A{6}};
  45
  46   std::array output = {7, 8, 9, 10, 11, 12};
  47   auto out = output.begin();
  48   std::array output2 = {A{7}, A{8}, A{9}, A{10}, A{11}, A{12}};
  49   auto out2 = output2.begin();
  50
  51   std::ranges::equal_to eq;
  52   std::ranges::less less;
  53   auto sum = [](int lhs, A rhs) { return lhs + rhs.x; };
  54   auto proj1 = [](int x) { return x * -1; };
  55   auto proj2 = [](A a) { return a.x * -1; };
  56
  57 #if TEST_STD_VER >= 23
  58   test(std::ranges::ends_with, in, in2, eq, proj1, proj2);
  59 #endif
  60   test(std::ranges::equal, in, in2, eq, proj1, proj2);
  61   test(std::ranges::lexicographical_compare, in, in2, eq, proj1, proj2);
  62   test(std::ranges::is_permutation, in, in2, eq, proj1, proj2);
  63   test(std::ranges::includes, in, in2, less, proj1, proj2);
  64   test(std::ranges::find_first_of, in, in2, eq, proj1, proj2);
  65   test(std::ranges::mismatch, in, in2, eq, proj1, proj2);
  66   test(std::ranges::search, in, in2, eq, proj1, proj2);
  67   test(std::ranges::find_end, in, in2, eq, proj1, proj2);
  68   test(std::ranges::transform, in, in2, out, sum, proj1, proj2);
  69   test(std::ranges::transform, in, in2, out2, sum, proj1, proj2);
  70   test(std::ranges::partial_sort_copy, in, in2, less, proj1, proj2);
  71   test(std::ranges::merge, in, in2, out, less, proj1, proj2);
  72   test(std::ranges::merge, in, in2, out2, less, proj1, proj2);
  73   test(std::ranges::set_intersection, in, in2, out, less, proj1, proj2);
  74   test(std::ranges::set_intersection, in, in2, out2, less, proj1, proj2);
  75   test(std::ranges::set_difference, in, in2, out, less, proj1, proj2);
  76   test(std::ranges::set_difference, in, in2, out2, less, proj1, proj2);
  77   test(std::ranges::set_symmetric_difference, in, in2, out, less, proj1, proj2);
  78   test(std::ranges::set_symmetric_difference, in, in2, out2, less, proj1, proj2);
  79   test(std::ranges::set_union, in, in2, out, less, proj1, proj2);
  80   test(std::ranges::set_union, in, in2, out2, less, proj1, proj2);
  81 #if TEST_STD_VER > 20
  82   test(std::ranges::starts_with, in, in2, eq, proj1, proj2);
  83 #endif
  84
  85   return true;
  86 }
  87
  88 int main(int, char**) {
  89   test_all();
  90   static_assert(test_all());
  91
  92   return 0;
  93 }