libcxx/test/std/algorithms/alg.sorting/alg.clamp/clamp.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 // <algorithm>
  10 // XFAIL: c++03, c++11, c++14
  11
  12 // template<class T>
  13 //   const T&
  14 //   clamp(const T& v, const T& lo, const T& hi);
  15
  16 #include <algorithm>
  17 #include <cassert>
  18
  19 #include "test_macros.h"
  20
  21 struct Tag {
  22     Tag() : val(0), tag("Default") {}
  23     Tag(int a, const char *b) : val(a), tag(b) {}
  24     ~Tag() {}
  25
  26     int val;
  27     const char *tag;
  28     };
  29
  30 bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
  31 // bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
  32 bool operator< (const Tag& rhs, const Tag& lhs) { return rhs.val <  lhs.val; }
  33
  34 template <class T>
  35 void
  36 test(const T& a, const T& lo, const T& hi, const T& x)
  37 {
  38     assert(&std::clamp(a, lo, hi) == &x);
  39 }
  40
  41 int main(int, char**)
  42 {
  43     {
  44     int x = 0;
  45     int y = 0;
  46     int z = 0;
  47     test(x, y, z, x);
  48     test(y, x, z, y);
  49     }
  50     {
  51     int x = 0;
  52     int y = 1;
  53     int z = 2;
  54     test(x, y, z, y);
  55     test(y, x, z, y);
  56     }
  57     {
  58     int x = 1;
  59     int y = 0;
  60     int z = 1;
  61     test(x, y, z, x);
  62     test(y, x, z, x);
  63     }
  64
  65     {
  66 //  If they're all the same, we should get the value back.
  67     Tag x{0, "Zero-x"};
  68     Tag y{0, "Zero-y"};
  69     Tag z{0, "Zero-z"};
  70     assert(eq(std::clamp(x, y, z), x));
  71     assert(eq(std::clamp(y, x, z), y));
  72     }
  73
  74     {
  75 //  If it's the same as the lower bound, we get the value back.
  76     Tag x{0, "Zero-x"};
  77     Tag y{0, "Zero-y"};
  78     Tag z{1, "One-z"};
  79     assert(eq(std::clamp(x, y, z), x));
  80     assert(eq(std::clamp(y, x, z), y));
  81     }
  82
  83     {
  84 //  If it's the same as the upper bound, we get the value back.
  85     Tag x{1, "One-x"};
  86     Tag y{0, "Zero-y"};
  87     Tag z{1, "One-z"};
  88     assert(eq(std::clamp(x, y, z), x));
  89     assert(eq(std::clamp(z, y, x), z));
  90     }
  91
  92     {
  93 //  If the value is between, we should get the value back
  94     Tag x{1, "One-x"};
  95     Tag y{0, "Zero-y"};
  96     Tag z{2, "Two-z"};
  97     assert(eq(std::clamp(x, y, z), x));
  98     assert(eq(std::clamp(y, x, z), x));
  99     }
 100
 101     {
 102 //  If the value is less than the 'lo', we should get the lo back.
 103     Tag x{0, "Zero-x"};
 104     Tag y{1, "One-y"};
 105     Tag z{2, "Two-z"};
 106     assert(eq(std::clamp(x, y, z), y));
 107     assert(eq(std::clamp(y, x, z), y));
 108     }
 109     {
 110 //  If the value is greater than 'hi', we should get hi back.
 111     Tag x{2, "Two-x"};
 112     Tag y{0, "Zero-y"};
 113     Tag z{1, "One-z"};
 114     assert(eq(std::clamp(x, y, z), z));
 115     assert(eq(std::clamp(y, z, x), z));
 116     }
 117
 118     {
 119     typedef int T;
 120     constexpr T x = 1;
 121     constexpr T y = 0;
 122     constexpr T z = 1;
 123     static_assert(std::clamp(x, y, z) == x, "" );
 124     static_assert(std::clamp(y, x, z) == x, "" );
 125     }
 126
 127   return 0;
 128 }