1 /*
2 * Copyright 2017 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "rtc_base/numerics/safe_minmax.h"
12
13 #include <algorithm>
14 #include <limits>
15
16 #include "test/gtest.h"
17
18 namespace rtc {
19
20 namespace {
21
22 // Functions that check that SafeMin(), SafeMax(), and SafeClamp() return the
23 // specified type. The functions that end in "R" use an explicitly given return
24 // type.
25
26 template <typename T1, typename T2, typename Tmin, typename Tmax>
TypeCheckMinMax()27 constexpr bool TypeCheckMinMax() {
28 return std::is_same<decltype(SafeMin(std::declval<T1>(), std::declval<T2>())),
29 Tmin>::value &&
30 std::is_same<decltype(SafeMax(std::declval<T1>(), std::declval<T2>())),
31 Tmax>::value;
32 }
33
34 template <typename T1, typename T2, typename R>
TypeCheckMinR()35 constexpr bool TypeCheckMinR() {
36 return std::is_same<
37 decltype(SafeMin<R>(std::declval<T1>(), std::declval<T2>())), R>::value;
38 }
39
40 template <typename T1, typename T2, typename R>
TypeCheckMaxR()41 constexpr bool TypeCheckMaxR() {
42 return std::is_same<
43 decltype(SafeMax<R>(std::declval<T1>(), std::declval<T2>())), R>::value;
44 }
45
46 template <typename T, typename L, typename H, typename R>
TypeCheckClamp()47 constexpr bool TypeCheckClamp() {
48 return std::is_same<decltype(SafeClamp(std::declval<T>(), std::declval<L>(),
49 std::declval<H>())),
50 R>::value;
51 }
52
53 template <typename T, typename L, typename H, typename R>
TypeCheckClampR()54 constexpr bool TypeCheckClampR() {
55 return std::is_same<decltype(SafeClamp<R>(std::declval<T>(),
56 std::declval<L>(),
57 std::declval<H>())),
58 R>::value;
59 }
60
61 // clang-format off
62
63 // SafeMin/SafeMax: Check that all combinations of signed/unsigned 8/64 bits
64 // give the correct default result type.
65 static_assert(TypeCheckMinMax< int8_t, int8_t, int8_t, int8_t>(), "");
66 static_assert(TypeCheckMinMax< int8_t, uint8_t, int8_t, uint8_t>(), "");
67 static_assert(TypeCheckMinMax< int8_t, int64_t, int64_t, int64_t>(), "");
68 static_assert(TypeCheckMinMax< int8_t, uint64_t, int8_t, uint64_t>(), "");
69 static_assert(TypeCheckMinMax< uint8_t, int8_t, int8_t, uint8_t>(), "");
70 static_assert(TypeCheckMinMax< uint8_t, uint8_t, uint8_t, uint8_t>(), "");
71 static_assert(TypeCheckMinMax< uint8_t, int64_t, int64_t, int64_t>(), "");
72 static_assert(TypeCheckMinMax< uint8_t, uint64_t, uint8_t, uint64_t>(), "");
73 static_assert(TypeCheckMinMax< int64_t, int8_t, int64_t, int64_t>(), "");
74 static_assert(TypeCheckMinMax< int64_t, uint8_t, int64_t, int64_t>(), "");
75 static_assert(TypeCheckMinMax< int64_t, int64_t, int64_t, int64_t>(), "");
76 static_assert(TypeCheckMinMax< int64_t, uint64_t, int64_t, uint64_t>(), "");
77 static_assert(TypeCheckMinMax<uint64_t, int8_t, int8_t, uint64_t>(), "");
78 static_assert(TypeCheckMinMax<uint64_t, uint8_t, uint8_t, uint64_t>(), "");
79 static_assert(TypeCheckMinMax<uint64_t, int64_t, int64_t, uint64_t>(), "");
80 static_assert(TypeCheckMinMax<uint64_t, uint64_t, uint64_t, uint64_t>(), "");
81
82 // SafeClamp: Check that all combinations of signed/unsigned 8/64 bits give the
83 // correct result type.
84 static_assert(TypeCheckClamp< int8_t, int8_t, int8_t, int8_t>(), "");
85 static_assert(TypeCheckClamp< int8_t, int8_t, uint8_t, int8_t>(), "");
86 static_assert(TypeCheckClamp< int8_t, int8_t, int64_t, int8_t>(), "");
87 static_assert(TypeCheckClamp< int8_t, int8_t, uint64_t, int8_t>(), "");
88 static_assert(TypeCheckClamp< int8_t, uint8_t, int8_t, int8_t>(), "");
89 static_assert(TypeCheckClamp< int8_t, uint8_t, uint8_t, uint8_t>(), "");
90 static_assert(TypeCheckClamp< int8_t, uint8_t, int64_t, int16_t>(), "");
91 static_assert(TypeCheckClamp< int8_t, uint8_t, uint64_t, int16_t>(), "");
92 static_assert(TypeCheckClamp< int8_t, int64_t, int8_t, int8_t>(), "");
93 static_assert(TypeCheckClamp< int8_t, int64_t, uint8_t, int16_t>(), "");
94 static_assert(TypeCheckClamp< int8_t, int64_t, int64_t, int64_t>(), "");
95 static_assert(TypeCheckClamp< int8_t, int64_t, uint64_t, int64_t>(), "");
96 static_assert(TypeCheckClamp< int8_t, uint64_t, int8_t, int8_t>(), "");
97 static_assert(TypeCheckClamp< int8_t, uint64_t, uint8_t, int16_t>(), "");
98 static_assert(TypeCheckClamp< int8_t, uint64_t, int64_t, int64_t>(), "");
99 static_assert(TypeCheckClamp< int8_t, uint64_t, uint64_t, uint64_t>(), "");
100 static_assert(TypeCheckClamp< uint8_t, int8_t, int8_t, int8_t>(), "");
101 static_assert(TypeCheckClamp< uint8_t, int8_t, uint8_t, uint8_t>(), "");
102 static_assert(TypeCheckClamp< uint8_t, int8_t, int64_t, int16_t>(), "");
103 static_assert(TypeCheckClamp< uint8_t, int8_t, uint64_t, uint8_t>(), "");
104 static_assert(TypeCheckClamp< uint8_t, uint8_t, int8_t, uint8_t>(), "");
105 static_assert(TypeCheckClamp< uint8_t, uint8_t, uint8_t, uint8_t>(), "");
106 static_assert(TypeCheckClamp< uint8_t, uint8_t, int64_t, uint8_t>(), "");
107 static_assert(TypeCheckClamp< uint8_t, uint8_t, uint64_t, uint8_t>(), "");
108 static_assert(TypeCheckClamp< uint8_t, int64_t, int8_t, int8_t>(), "");
109 static_assert(TypeCheckClamp< uint8_t, int64_t, uint8_t, uint8_t>(), "");
110 static_assert(TypeCheckClamp< uint8_t, int64_t, int64_t, int64_t>(), "");
111 static_assert(TypeCheckClamp< uint8_t, int64_t, uint64_t, uint64_t>(), "");
112 static_assert(TypeCheckClamp< uint8_t, uint64_t, int8_t, uint8_t>(), "");
113 static_assert(TypeCheckClamp< uint8_t, uint64_t, uint8_t, uint8_t>(), "");
114 static_assert(TypeCheckClamp< uint8_t, uint64_t, int64_t, uint64_t>(), "");
115 static_assert(TypeCheckClamp< uint8_t, uint64_t, uint64_t, uint64_t>(), "");
116 static_assert(TypeCheckClamp< int64_t, int8_t, int8_t, int8_t>(), "");
117 static_assert(TypeCheckClamp< int64_t, int8_t, uint8_t, int16_t>(), "");
118 static_assert(TypeCheckClamp< int64_t, int8_t, int64_t, int64_t>(), "");
119 static_assert(TypeCheckClamp< int64_t, int8_t, uint64_t, int64_t>(), "");
120 static_assert(TypeCheckClamp< int64_t, uint8_t, int8_t, int8_t>(), "");
121 static_assert(TypeCheckClamp< int64_t, uint8_t, uint8_t, int16_t>(), "");
122 static_assert(TypeCheckClamp< int64_t, uint8_t, int64_t, int64_t>(), "");
123 static_assert(TypeCheckClamp< int64_t, uint8_t, uint64_t, int64_t>(), "");
124 static_assert(TypeCheckClamp< int64_t, int64_t, int8_t, int64_t>(), "");
125 static_assert(TypeCheckClamp< int64_t, int64_t, uint8_t, int64_t>(), "");
126 static_assert(TypeCheckClamp< int64_t, int64_t, int64_t, int64_t>(), "");
127 static_assert(TypeCheckClamp< int64_t, int64_t, uint64_t, int64_t>(), "");
128 static_assert(TypeCheckClamp< int64_t, uint64_t, int8_t, int8_t>(), "");
129 static_assert(TypeCheckClamp< int64_t, uint64_t, uint8_t, int16_t>(), "");
130 static_assert(TypeCheckClamp< int64_t, uint64_t, int64_t, int64_t>(), "");
131 static_assert(TypeCheckClamp< int64_t, uint64_t, uint64_t, uint64_t>(), "");
132 static_assert(TypeCheckClamp<uint64_t, int8_t, int8_t, int8_t>(), "");
133 static_assert(TypeCheckClamp<uint64_t, int8_t, uint8_t, uint8_t>(), "");
134 static_assert(TypeCheckClamp<uint64_t, int8_t, int64_t, int64_t>(), "");
135 static_assert(TypeCheckClamp<uint64_t, int8_t, uint64_t, uint64_t>(), "");
136 static_assert(TypeCheckClamp<uint64_t, uint8_t, int8_t, uint8_t>(), "");
137 static_assert(TypeCheckClamp<uint64_t, uint8_t, uint8_t, uint8_t>(), "");
138 static_assert(TypeCheckClamp<uint64_t, uint8_t, int64_t, uint64_t>(), "");
139 static_assert(TypeCheckClamp<uint64_t, uint8_t, uint64_t, uint64_t>(), "");
140 static_assert(TypeCheckClamp<uint64_t, int64_t, int8_t, int8_t>(), "");
141 static_assert(TypeCheckClamp<uint64_t, int64_t, uint8_t, uint8_t>(), "");
142 static_assert(TypeCheckClamp<uint64_t, int64_t, int64_t, int64_t>(), "");
143 static_assert(TypeCheckClamp<uint64_t, int64_t, uint64_t, uint64_t>(), "");
144 static_assert(TypeCheckClamp<uint64_t, uint64_t, int8_t, uint8_t>(), "");
145 static_assert(TypeCheckClamp<uint64_t, uint64_t, uint8_t, uint8_t>(), "");
146 static_assert(TypeCheckClamp<uint64_t, uint64_t, int64_t, uint64_t>(), "");
147 static_assert(TypeCheckClamp<uint64_t, uint64_t, uint64_t, uint64_t>(), "");
148
149 enum DefaultE { kFoo = -17 };
150 enum UInt8E : uint8_t { kBar = 17 };
151
152 // SafeMin/SafeMax: Check that we can use enum types.
153 static_assert(TypeCheckMinMax<unsigned, unsigned, unsigned, unsigned>(), "");
154 static_assert(TypeCheckMinMax<unsigned, DefaultE, int, unsigned>(), "");
155 static_assert(TypeCheckMinMax<unsigned, UInt8E, uint8_t, unsigned>(), "");
156 static_assert(TypeCheckMinMax<DefaultE, unsigned, int, unsigned>(), "");
157 static_assert(TypeCheckMinMax<DefaultE, DefaultE, int, int>(), "");
158 static_assert(TypeCheckMinMax<DefaultE, UInt8E, int, int>(), "");
159 static_assert(TypeCheckMinMax< UInt8E, unsigned, uint8_t, unsigned>(), "");
160 static_assert(TypeCheckMinMax< UInt8E, DefaultE, int, int>(), "");
161 static_assert(TypeCheckMinMax< UInt8E, UInt8E, uint8_t, uint8_t>(), "");
162
163 // SafeClamp: Check that we can use enum types.
164 static_assert(TypeCheckClamp<unsigned, unsigned, unsigned, unsigned>(), "");
165 static_assert(TypeCheckClamp<unsigned, unsigned, DefaultE, unsigned>(), "");
166 static_assert(TypeCheckClamp<unsigned, unsigned, UInt8E, uint8_t>(), "");
167 static_assert(TypeCheckClamp<unsigned, DefaultE, unsigned, unsigned>(), "");
168 static_assert(TypeCheckClamp<unsigned, DefaultE, DefaultE, int>(), "");
169 static_assert(TypeCheckClamp<unsigned, DefaultE, UInt8E, uint8_t>(), "");
170 static_assert(TypeCheckClamp<unsigned, UInt8E, unsigned, unsigned>(), "");
171 static_assert(TypeCheckClamp<unsigned, UInt8E, DefaultE, unsigned>(), "");
172 static_assert(TypeCheckClamp<unsigned, UInt8E, UInt8E, uint8_t>(), "");
173 static_assert(TypeCheckClamp<DefaultE, unsigned, unsigned, unsigned>(), "");
174 static_assert(TypeCheckClamp<DefaultE, unsigned, DefaultE, int>(), "");
175 static_assert(TypeCheckClamp<DefaultE, unsigned, UInt8E, int16_t>(), "");
176 static_assert(TypeCheckClamp<DefaultE, DefaultE, unsigned, int>(), "");
177 static_assert(TypeCheckClamp<DefaultE, DefaultE, DefaultE, int>(), "");
178 static_assert(TypeCheckClamp<DefaultE, DefaultE, UInt8E, int>(), "");
179 static_assert(TypeCheckClamp<DefaultE, UInt8E, unsigned, int>(), "");
180 static_assert(TypeCheckClamp<DefaultE, UInt8E, DefaultE, int>(), "");
181 static_assert(TypeCheckClamp<DefaultE, UInt8E, UInt8E, int16_t>(), "");
182 static_assert(TypeCheckClamp< UInt8E, unsigned, unsigned, unsigned>(), "");
183 static_assert(TypeCheckClamp< UInt8E, unsigned, DefaultE, unsigned>(), "");
184 static_assert(TypeCheckClamp< UInt8E, unsigned, UInt8E, uint8_t>(), "");
185 static_assert(TypeCheckClamp< UInt8E, DefaultE, unsigned, unsigned>(), "");
186 static_assert(TypeCheckClamp< UInt8E, DefaultE, DefaultE, int>(), "");
187 static_assert(TypeCheckClamp< UInt8E, DefaultE, UInt8E, uint8_t>(), "");
188 static_assert(TypeCheckClamp< UInt8E, UInt8E, unsigned, uint8_t>(), "");
189 static_assert(TypeCheckClamp< UInt8E, UInt8E, DefaultE, uint8_t>(), "");
190 static_assert(TypeCheckClamp< UInt8E, UInt8E, UInt8E, uint8_t>(), "");
191
192 using ld = long double;
193
194 // SafeMin/SafeMax: Check that all floating-point combinations give the
195 // correct result type.
196 static_assert(TypeCheckMinMax< float, float, float, float>(), "");
197 static_assert(TypeCheckMinMax< float, double, double, double>(), "");
198 static_assert(TypeCheckMinMax< float, ld, ld, ld>(), "");
199 static_assert(TypeCheckMinMax<double, float, double, double>(), "");
200 static_assert(TypeCheckMinMax<double, double, double, double>(), "");
201 static_assert(TypeCheckMinMax<double, ld, ld, ld>(), "");
202 static_assert(TypeCheckMinMax< ld, float, ld, ld>(), "");
203 static_assert(TypeCheckMinMax< ld, double, ld, ld>(), "");
204 static_assert(TypeCheckMinMax< ld, ld, ld, ld>(), "");
205
206 // SafeClamp: Check that all floating-point combinations give the correct
207 // result type.
208 static_assert(TypeCheckClamp< float, float, float, float>(), "");
209 static_assert(TypeCheckClamp< float, float, double, double>(), "");
210 static_assert(TypeCheckClamp< float, float, ld, ld>(), "");
211 static_assert(TypeCheckClamp< float, double, float, double>(), "");
212 static_assert(TypeCheckClamp< float, double, double, double>(), "");
213 static_assert(TypeCheckClamp< float, double, ld, ld>(), "");
214 static_assert(TypeCheckClamp< float, ld, float, ld>(), "");
215 static_assert(TypeCheckClamp< float, ld, double, ld>(), "");
216 static_assert(TypeCheckClamp< float, ld, ld, ld>(), "");
217 static_assert(TypeCheckClamp<double, float, float, double>(), "");
218 static_assert(TypeCheckClamp<double, float, double, double>(), "");
219 static_assert(TypeCheckClamp<double, float, ld, ld>(), "");
220 static_assert(TypeCheckClamp<double, double, float, double>(), "");
221 static_assert(TypeCheckClamp<double, double, double, double>(), "");
222 static_assert(TypeCheckClamp<double, double, ld, ld>(), "");
223 static_assert(TypeCheckClamp<double, ld, float, ld>(), "");
224 static_assert(TypeCheckClamp<double, ld, double, ld>(), "");
225 static_assert(TypeCheckClamp<double, ld, ld, ld>(), "");
226 static_assert(TypeCheckClamp< ld, float, float, ld>(), "");
227 static_assert(TypeCheckClamp< ld, float, double, ld>(), "");
228 static_assert(TypeCheckClamp< ld, float, ld, ld>(), "");
229 static_assert(TypeCheckClamp< ld, double, float, ld>(), "");
230 static_assert(TypeCheckClamp< ld, double, double, ld>(), "");
231 static_assert(TypeCheckClamp< ld, double, ld, ld>(), "");
232 static_assert(TypeCheckClamp< ld, ld, float, ld>(), "");
233 static_assert(TypeCheckClamp< ld, ld, double, ld>(), "");
234 static_assert(TypeCheckClamp< ld, ld, ld, ld>(), "");
235
236 // clang-format on
237
238 // SafeMin/SafeMax: Check some cases of explicitly specified return type. The
239 // commented-out lines give compilation errors due to the requested return type
240 // being too small or requiring an int<->float conversion.
241 static_assert(TypeCheckMinR<int8_t, int8_t, int16_t>(), "");
242 // static_assert(TypeCheckMinR<int8_t, int8_t, float>(), "");
243 static_assert(TypeCheckMinR<uint32_t, uint64_t, uint32_t>(), "");
244 // static_assert(TypeCheckMaxR<uint64_t, float, float>(), "");
245 // static_assert(TypeCheckMaxR<uint64_t, double, float>(), "");
246 static_assert(TypeCheckMaxR<uint32_t, int32_t, uint32_t>(), "");
247 // static_assert(TypeCheckMaxR<uint32_t, int32_t, int32_t>(), "");
248
249 // SafeClamp: Check some cases of explicitly specified return type. The
250 // commented-out lines give compilation errors due to the requested return type
251 // being too small.
252 static_assert(TypeCheckClampR<int16_t, int8_t, uint8_t, int16_t>(), "");
253 static_assert(TypeCheckClampR<int16_t, int8_t, uint8_t, int32_t>(), "");
254 // static_assert(TypeCheckClampR<int16_t, int8_t, uint8_t, uint32_t>(), "");
255
256 template <typename T1, typename T2, typename Tmin, typename Tmax>
CheckMinMax(T1 a,T2 b,Tmin min,Tmax max)257 constexpr bool CheckMinMax(T1 a, T2 b, Tmin min, Tmax max) {
258 return TypeCheckMinMax<T1, T2, Tmin, Tmax>() && SafeMin(a, b) == min &&
259 SafeMax(a, b) == max;
260 }
261
262 template <typename T, typename L, typename H, typename R>
CheckClamp(T x,L min,H max,R clamped)263 bool CheckClamp(T x, L min, H max, R clamped) {
264 return TypeCheckClamp<T, L, H, R>() && SafeClamp(x, min, max) == clamped;
265 }
266
267 // SafeMin/SafeMax: Check a few values.
268 static_assert(CheckMinMax(int8_t{1}, int8_t{-1}, int8_t{-1}, int8_t{1}), "");
269 static_assert(CheckMinMax(uint8_t{1}, int8_t{-1}, int8_t{-1}, uint8_t{1}), "");
270 static_assert(CheckMinMax(uint8_t{5}, uint64_t{2}, uint8_t{2}, uint64_t{5}),
271 "");
272 static_assert(CheckMinMax(std::numeric_limits<int32_t>::min(),
273 std::numeric_limits<uint32_t>::max(),
274 std::numeric_limits<int32_t>::min(),
275 std::numeric_limits<uint32_t>::max()),
276 "");
277 static_assert(CheckMinMax(std::numeric_limits<int32_t>::min(),
278 std::numeric_limits<uint16_t>::max(),
279 std::numeric_limits<int32_t>::min(),
280 int32_t{std::numeric_limits<uint16_t>::max()}),
281 "");
282 // static_assert(CheckMinMax(1.f, 2, 1.f, 2.f), "");
283 static_assert(CheckMinMax(1.f, 0.0, 0.0, 1.0), "");
284
285 // SafeClamp: Check a few values.
TEST(SafeMinmaxTest,Clamp)286 TEST(SafeMinmaxTest, Clamp) {
287 EXPECT_TRUE(CheckClamp(int32_t{-1000000}, std::numeric_limits<int16_t>::min(),
288 std::numeric_limits<int16_t>::max(),
289 std::numeric_limits<int16_t>::min()));
290 EXPECT_TRUE(CheckClamp(uint32_t{1000000}, std::numeric_limits<int16_t>::min(),
291 std::numeric_limits<int16_t>::max(),
292 std::numeric_limits<int16_t>::max()));
293 EXPECT_TRUE(CheckClamp(3.f, -1.0, 1.f, 1.0));
294 EXPECT_TRUE(CheckClamp(3.0, -1.f, 1.f, 1.0));
295 }
296
297 } // namespace
298
299 // These functions aren't used in the tests, but it's useful to look at the
300 // compiler output for them, and verify that (1) the same-signedness Test*Safe
301 // functions result in exactly the same code as their Test*Ref counterparts,
302 // and that (2) the mixed-signedness Test*Safe functions have just a few extra
303 // arithmetic and logic instructions (but no extra control flow instructions).
304
305 // clang-format off
TestMinRef(int32_t a,int32_t b)306 int32_t TestMinRef( int32_t a, int32_t b) { return std::min(a, b); }
TestMinRef(uint32_t a,uint32_t b)307 uint32_t TestMinRef( uint32_t a, uint32_t b) { return std::min(a, b); }
TestMinSafe(int32_t a,int32_t b)308 int32_t TestMinSafe( int32_t a, int32_t b) { return SafeMin(a, b); }
TestMinSafe(int32_t a,uint32_t b)309 int32_t TestMinSafe( int32_t a, uint32_t b) { return SafeMin(a, b); }
TestMinSafe(uint32_t a,int32_t b)310 int32_t TestMinSafe(uint32_t a, int32_t b) { return SafeMin(a, b); }
TestMinSafe(uint32_t a,uint32_t b)311 uint32_t TestMinSafe(uint32_t a, uint32_t b) { return SafeMin(a, b); }
312 // clang-format on
313
TestClampRef(int32_t x,int32_t a,int32_t b)314 int32_t TestClampRef(int32_t x, int32_t a, int32_t b) {
315 return std::max(a, std::min(x, b));
316 }
TestClampRef(uint32_t x,uint32_t a,uint32_t b)317 uint32_t TestClampRef(uint32_t x, uint32_t a, uint32_t b) {
318 return std::max(a, std::min(x, b));
319 }
TestClampSafe(int32_t x,int32_t a,int32_t b)320 int32_t TestClampSafe(int32_t x, int32_t a, int32_t b) {
321 return SafeClamp(x, a, b);
322 }
TestClampSafe(int32_t x,int32_t a,uint32_t b)323 int32_t TestClampSafe(int32_t x, int32_t a, uint32_t b) {
324 return SafeClamp(x, a, b);
325 }
TestClampSafe(int32_t x,uint32_t a,int32_t b)326 int32_t TestClampSafe(int32_t x, uint32_t a, int32_t b) {
327 return SafeClamp(x, a, b);
328 }
TestClampSafe(int32_t x,uint32_t a,uint32_t b)329 uint32_t TestClampSafe(int32_t x, uint32_t a, uint32_t b) {
330 return SafeClamp(x, a, b);
331 }
TestClampSafe(uint32_t x,int32_t a,int32_t b)332 int32_t TestClampSafe(uint32_t x, int32_t a, int32_t b) {
333 return SafeClamp(x, a, b);
334 }
TestClampSafe(uint32_t x,int32_t a,uint32_t b)335 uint32_t TestClampSafe(uint32_t x, int32_t a, uint32_t b) {
336 return SafeClamp(x, a, b);
337 }
TestClampSafe(uint32_t x,uint32_t a,int32_t b)338 int32_t TestClampSafe(uint32_t x, uint32_t a, int32_t b) {
339 return SafeClamp(x, a, b);
340 }
TestClampSafe(uint32_t x,uint32_t a,uint32_t b)341 uint32_t TestClampSafe(uint32_t x, uint32_t a, uint32_t b) {
342 return SafeClamp(x, a, b);
343 }
344
345 } // namespace rtc
346