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