From 93ecc5dad05b6996ce42ead407ba0e769ce5b370 Mon Sep 17 00:00:00 2001 From: kwiberg Date: Mon, 26 Jun 2017 01:31:31 -0700 Subject: [PATCH] Rename safe_cmp::{Eq,Ne,Lt,Le,Ge,Gt} to Safe{Eq,Ne,Lt,Le,Ge,Gt} For consistency with SafeMin(), SafeMax(), and SafeClamp(). And so that we avoid introducing a namespace. BUG=webrtc:7459 Review-Url: https://codereview.webrtc.org/2802423002 Cr-Commit-Position: refs/heads/master@{#18756} --- webrtc/base/checks.h | 6 +- webrtc/base/safe_compare.h | 21 +- webrtc/base/safe_compare_unittest.cc | 532 +++++++++++++-------------- webrtc/base/safe_minmax.h | 28 +- 4 files changed, 291 insertions(+), 296 deletions(-) diff --git a/webrtc/base/checks.h b/webrtc/base/checks.h index c15a08c2c5..b86fb15919 100644 --- a/webrtc/base/checks.h +++ b/webrtc/base/checks.h @@ -99,7 +99,7 @@ namespace rtc { // values of the same types as |a| and |b| can't be compared with the given // operation, and that would evaluate |a| and |b| if evaluated. #define RTC_EAT_STREAM_PARAMETERS_OP(op, a, b) \ - RTC_EAT_STREAM_PARAMETERS(((void)rtc::safe_cmp::op(a, b))) + RTC_EAT_STREAM_PARAMETERS(((void)rtc::Safe##op(a, b))) // RTC_CHECK dies with a fatal error if condition is not true. It is *not* // controlled by NDEBUG or anything else, so the check will be executed @@ -162,13 +162,13 @@ std::string* MakeCheckOpString( template \ inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \ const char* names) { \ - if (rtc::safe_cmp::name(v1, v2)) \ + if (rtc::Safe##name(v1, v2)) \ return nullptr; \ else \ return rtc::MakeCheckOpString(v1, v2, names); \ } \ inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \ - if (rtc::safe_cmp::name(v1, v2)) \ + if (rtc::Safe##name(v1, v2)) \ return nullptr; \ else \ return rtc::MakeCheckOpString(v1, v2, names); \ diff --git a/webrtc/base/safe_compare.h b/webrtc/base/safe_compare.h index 0350d5df81..a57f08293a 100644 --- a/webrtc/base/safe_compare.h +++ b/webrtc/base/safe_compare.h @@ -10,12 +10,12 @@ // This file defines six constexpr functions: // -// rtc::safe_cmp::Eq // == -// rtc::safe_cmp::Ne // != -// rtc::safe_cmp::Lt // < -// rtc::safe_cmp::Le // <= -// rtc::safe_cmp::Gt // > -// rtc::safe_cmp::Ge // >= +// rtc::SafeEq // == +// rtc::SafeNe // != +// rtc::SafeLt // < +// rtc::SafeLe // <= +// rtc::SafeGt // > +// rtc::SafeGe // >= // // They each accept two arguments of arbitrary types, and in almost all cases, // they simply call the appropriate comparison operator. However, if both @@ -40,7 +40,6 @@ #include "webrtc/base/type_traits.h" namespace rtc { -namespace safe_cmp { namespace safe_cmp_impl { @@ -153,16 +152,15 @@ RTC_SAFECMP_MAKE_OP(GeOp, >=) template \ constexpr \ typename std::enable_if::value && IsIntlike::value, \ - bool>::type \ - name(T1 a, T2 b) { \ + bool>::type Safe##name(T1 a, T2 b) { \ /* Unary plus here turns enums into real integral types. */ \ return safe_cmp_impl::Cmp(+a, +b); \ } \ template \ constexpr \ typename std::enable_if::value || !IsIntlike::value, \ - bool>::type \ - name(const T1& a, const T2& b) { \ + bool>::type Safe##name(const T1& a, \ + const T2& b) { \ return safe_cmp_impl::name##Op::Op(a, b); \ } RTC_SAFECMP_MAKE_FUN(Eq) @@ -173,7 +171,6 @@ RTC_SAFECMP_MAKE_FUN(Gt) RTC_SAFECMP_MAKE_FUN(Ge) #undef RTC_SAFECMP_MAKE_FUN -} // namespace safe_cmp } // namespace rtc #endif // WEBRTC_BASE_SAFE_COMPARE_H_ diff --git a/webrtc/base/safe_compare_unittest.cc b/webrtc/base/safe_compare_unittest.cc index 9663164e30..1ebb7222e2 100644 --- a/webrtc/base/safe_compare_unittest.cc +++ b/webrtc/base/safe_compare_unittest.cc @@ -40,10 +40,10 @@ static const std::pair p2(1, 2); // arithmetic and logic instructions (but no extra control flow instructions). bool TestLessThanRef( int a, int b) { return a < b; } bool TestLessThanRef( unsigned a, unsigned b) { return a < b; } -bool TestLessThanSafe( int a, int b) { return safe_cmp::Lt(a, b); } -bool TestLessThanSafe(unsigned a, unsigned b) { return safe_cmp::Lt(a, b); } -bool TestLessThanSafe(unsigned a, int b) { return safe_cmp::Lt(a, b); } -bool TestLessThanSafe( int a, unsigned b) { return safe_cmp::Lt(a, b); } +bool TestLessThanSafe( int a, int b) { return SafeLt(a, b); } +bool TestLessThanSafe(unsigned a, unsigned b) { return SafeLt(a, b); } +bool TestLessThanSafe(unsigned a, int b) { return SafeLt(a, b); } +bool TestLessThanSafe( int a, unsigned b) { return SafeLt(a, b); } // For these, we expect the *Ref and *Safe functions to result in identical // code, except for the ones that compare a signed variable with an unsigned @@ -54,326 +54,326 @@ bool TestLessThan17Ref( int a) { return a < 17; } bool TestLessThan17Ref( unsigned a) { return a < 17; } bool TestLessThan17uRef( int a) { return static_cast(a) < 17u; } bool TestLessThan17uRef( unsigned a) { return a < 17u; } -bool TestLessThan17Safe( int a) { return safe_cmp::Lt(a, 17); } -bool TestLessThan17Safe( unsigned a) { return safe_cmp::Lt(a, 17); } -bool TestLessThan17uSafe( int a) { return safe_cmp::Lt(a, 17u); } -bool TestLessThan17uSafe(unsigned a) { return safe_cmp::Lt(a, 17u); } +bool TestLessThan17Safe( int a) { return SafeLt(a, 17); } +bool TestLessThan17Safe( unsigned a) { return SafeLt(a, 17); } +bool TestLessThan17uSafe( int a) { return SafeLt(a, 17u); } +bool TestLessThan17uSafe(unsigned a) { return SafeLt(a, 17u); } // Cases where we can't convert to a larger signed type. -bool TestLessThanMax( intmax_t a, uintmax_t b) { return safe_cmp::Lt(a, b); } -bool TestLessThanMax(uintmax_t a, intmax_t b) { return safe_cmp::Lt(a, b); } -bool TestLessThanMax17u( intmax_t a) { return safe_cmp::Lt(a, uintmax_t{17}); } -bool TestLessThanMax17( uintmax_t a) { return safe_cmp::Lt(a, intmax_t{17}); } +bool TestLessThanMax( intmax_t a, uintmax_t b) { return SafeLt(a, b); } +bool TestLessThanMax(uintmax_t a, intmax_t b) { return SafeLt(a, b); } +bool TestLessThanMax17u( intmax_t a) { return SafeLt(a, uintmax_t{17}); } +bool TestLessThanMax17( uintmax_t a) { return SafeLt(a, intmax_t{17}); } // Cases where the compiler should be able to compute the result at compile // time. -bool TestLessThanConst1() { return safe_cmp::Lt( -1, 1); } -bool TestLessThanConst2() { return safe_cmp::Lt( m1, umax); } -bool TestLessThanConst3() { return safe_cmp::Lt(umax, imin); } -bool TestLessThanConst4(unsigned a) { return safe_cmp::Lt( a, -1); } -bool TestLessThanConst5(unsigned a) { return safe_cmp::Lt(-1, a); } -bool TestLessThanConst6(unsigned a) { return safe_cmp::Lt( a, a); } +bool TestLessThanConst1() { return SafeLt( -1, 1); } +bool TestLessThanConst2() { return SafeLt( m1, umax); } +bool TestLessThanConst3() { return SafeLt(umax, imin); } +bool TestLessThanConst4(unsigned a) { return SafeLt( a, -1); } +bool TestLessThanConst5(unsigned a) { return SafeLt(-1, a); } +bool TestLessThanConst6(unsigned a) { return SafeLt( a, a); } // clang-format on TEST(SafeCmpTest, Eq) { - static_assert(!safe_cmp::Eq(-1, 2), ""); - static_assert(!safe_cmp::Eq(-1, 2u), ""); - static_assert(!safe_cmp::Eq(2, -1), ""); - static_assert(!safe_cmp::Eq(2u, -1), ""); + static_assert(!SafeEq(-1, 2), ""); + static_assert(!SafeEq(-1, 2u), ""); + static_assert(!SafeEq(2, -1), ""); + static_assert(!SafeEq(2u, -1), ""); - static_assert(!safe_cmp::Eq(1, 2), ""); - static_assert(!safe_cmp::Eq(1, 2u), ""); - static_assert(!safe_cmp::Eq(1u, 2), ""); - static_assert(!safe_cmp::Eq(1u, 2u), ""); - static_assert(!safe_cmp::Eq(2, 1), ""); - static_assert(!safe_cmp::Eq(2, 1u), ""); - static_assert(!safe_cmp::Eq(2u, 1), ""); - static_assert(!safe_cmp::Eq(2u, 1u), ""); + static_assert(!SafeEq(1, 2), ""); + static_assert(!SafeEq(1, 2u), ""); + static_assert(!SafeEq(1u, 2), ""); + static_assert(!SafeEq(1u, 2u), ""); + static_assert(!SafeEq(2, 1), ""); + static_assert(!SafeEq(2, 1u), ""); + static_assert(!SafeEq(2u, 1), ""); + static_assert(!SafeEq(2u, 1u), ""); - static_assert(safe_cmp::Eq(2, 2), ""); - static_assert(safe_cmp::Eq(2, 2u), ""); - static_assert(safe_cmp::Eq(2u, 2), ""); - static_assert(safe_cmp::Eq(2u, 2u), ""); + static_assert(SafeEq(2, 2), ""); + static_assert(SafeEq(2, 2u), ""); + static_assert(SafeEq(2u, 2), ""); + static_assert(SafeEq(2u, 2u), ""); - static_assert(safe_cmp::Eq(imin, imin), ""); - static_assert(!safe_cmp::Eq(imin, umax), ""); - static_assert(!safe_cmp::Eq(umax, imin), ""); - static_assert(safe_cmp::Eq(umax, umax), ""); + static_assert(SafeEq(imin, imin), ""); + static_assert(!SafeEq(imin, umax), ""); + static_assert(!SafeEq(umax, imin), ""); + static_assert(SafeEq(umax, umax), ""); - static_assert(safe_cmp::Eq(m1, m1), ""); - static_assert(!safe_cmp::Eq(m1, umax), ""); - static_assert(!safe_cmp::Eq(umax, m1), ""); - static_assert(safe_cmp::Eq(umax, umax), ""); + static_assert(SafeEq(m1, m1), ""); + static_assert(!SafeEq(m1, umax), ""); + static_assert(!SafeEq(umax, m1), ""); + static_assert(SafeEq(umax, umax), ""); - static_assert(!safe_cmp::Eq(1, 2), ""); - static_assert(!safe_cmp::Eq(1, 2.0), ""); - static_assert(!safe_cmp::Eq(1.0, 2), ""); - static_assert(!safe_cmp::Eq(1.0, 2.0), ""); - static_assert(!safe_cmp::Eq(2, 1), ""); - static_assert(!safe_cmp::Eq(2, 1.0), ""); - static_assert(!safe_cmp::Eq(2.0, 1), ""); - static_assert(!safe_cmp::Eq(2.0, 1.0), ""); + static_assert(!SafeEq(1, 2), ""); + static_assert(!SafeEq(1, 2.0), ""); + static_assert(!SafeEq(1.0, 2), ""); + static_assert(!SafeEq(1.0, 2.0), ""); + static_assert(!SafeEq(2, 1), ""); + static_assert(!SafeEq(2, 1.0), ""); + static_assert(!SafeEq(2.0, 1), ""); + static_assert(!SafeEq(2.0, 1.0), ""); - static_assert(safe_cmp::Eq(2, 2), ""); - static_assert(safe_cmp::Eq(2, 2.0), ""); - static_assert(safe_cmp::Eq(2.0, 2), ""); - static_assert(safe_cmp::Eq(2.0, 2.0), ""); + static_assert(SafeEq(2, 2), ""); + static_assert(SafeEq(2, 2.0), ""); + static_assert(SafeEq(2.0, 2), ""); + static_assert(SafeEq(2.0, 2.0), ""); - EXPECT_TRUE(safe_cmp::Eq(p1, p1)); - EXPECT_FALSE(safe_cmp::Eq(p1, p2)); - EXPECT_FALSE(safe_cmp::Eq(p2, p1)); - EXPECT_TRUE(safe_cmp::Eq(p2, p2)); + EXPECT_TRUE(SafeEq(p1, p1)); + EXPECT_FALSE(SafeEq(p1, p2)); + EXPECT_FALSE(SafeEq(p2, p1)); + EXPECT_TRUE(SafeEq(p2, p2)); } TEST(SafeCmpTest, Ne) { - static_assert(safe_cmp::Ne(-1, 2), ""); - static_assert(safe_cmp::Ne(-1, 2u), ""); - static_assert(safe_cmp::Ne(2, -1), ""); - static_assert(safe_cmp::Ne(2u, -1), ""); + static_assert(SafeNe(-1, 2), ""); + static_assert(SafeNe(-1, 2u), ""); + static_assert(SafeNe(2, -1), ""); + static_assert(SafeNe(2u, -1), ""); - static_assert(safe_cmp::Ne(1, 2), ""); - static_assert(safe_cmp::Ne(1, 2u), ""); - static_assert(safe_cmp::Ne(1u, 2), ""); - static_assert(safe_cmp::Ne(1u, 2u), ""); - static_assert(safe_cmp::Ne(2, 1), ""); - static_assert(safe_cmp::Ne(2, 1u), ""); - static_assert(safe_cmp::Ne(2u, 1), ""); - static_assert(safe_cmp::Ne(2u, 1u), ""); + static_assert(SafeNe(1, 2), ""); + static_assert(SafeNe(1, 2u), ""); + static_assert(SafeNe(1u, 2), ""); + static_assert(SafeNe(1u, 2u), ""); + static_assert(SafeNe(2, 1), ""); + static_assert(SafeNe(2, 1u), ""); + static_assert(SafeNe(2u, 1), ""); + static_assert(SafeNe(2u, 1u), ""); - static_assert(!safe_cmp::Ne(2, 2), ""); - static_assert(!safe_cmp::Ne(2, 2u), ""); - static_assert(!safe_cmp::Ne(2u, 2), ""); - static_assert(!safe_cmp::Ne(2u, 2u), ""); + static_assert(!SafeNe(2, 2), ""); + static_assert(!SafeNe(2, 2u), ""); + static_assert(!SafeNe(2u, 2), ""); + static_assert(!SafeNe(2u, 2u), ""); - static_assert(!safe_cmp::Ne(imin, imin), ""); - static_assert(safe_cmp::Ne(imin, umax), ""); - static_assert(safe_cmp::Ne(umax, imin), ""); - static_assert(!safe_cmp::Ne(umax, umax), ""); + static_assert(!SafeNe(imin, imin), ""); + static_assert(SafeNe(imin, umax), ""); + static_assert(SafeNe(umax, imin), ""); + static_assert(!SafeNe(umax, umax), ""); - static_assert(!safe_cmp::Ne(m1, m1), ""); - static_assert(safe_cmp::Ne(m1, umax), ""); - static_assert(safe_cmp::Ne(umax, m1), ""); - static_assert(!safe_cmp::Ne(umax, umax), ""); + static_assert(!SafeNe(m1, m1), ""); + static_assert(SafeNe(m1, umax), ""); + static_assert(SafeNe(umax, m1), ""); + static_assert(!SafeNe(umax, umax), ""); - static_assert(safe_cmp::Ne(1, 2), ""); - static_assert(safe_cmp::Ne(1, 2.0), ""); - static_assert(safe_cmp::Ne(1.0, 2), ""); - static_assert(safe_cmp::Ne(1.0, 2.0), ""); - static_assert(safe_cmp::Ne(2, 1), ""); - static_assert(safe_cmp::Ne(2, 1.0), ""); - static_assert(safe_cmp::Ne(2.0, 1), ""); - static_assert(safe_cmp::Ne(2.0, 1.0), ""); + static_assert(SafeNe(1, 2), ""); + static_assert(SafeNe(1, 2.0), ""); + static_assert(SafeNe(1.0, 2), ""); + static_assert(SafeNe(1.0, 2.0), ""); + static_assert(SafeNe(2, 1), ""); + static_assert(SafeNe(2, 1.0), ""); + static_assert(SafeNe(2.0, 1), ""); + static_assert(SafeNe(2.0, 1.0), ""); - static_assert(!safe_cmp::Ne(2, 2), ""); - static_assert(!safe_cmp::Ne(2, 2.0), ""); - static_assert(!safe_cmp::Ne(2.0, 2), ""); - static_assert(!safe_cmp::Ne(2.0, 2.0), ""); + static_assert(!SafeNe(2, 2), ""); + static_assert(!SafeNe(2, 2.0), ""); + static_assert(!SafeNe(2.0, 2), ""); + static_assert(!SafeNe(2.0, 2.0), ""); - EXPECT_FALSE(safe_cmp::Ne(p1, p1)); - EXPECT_TRUE(safe_cmp::Ne(p1, p2)); - EXPECT_TRUE(safe_cmp::Ne(p2, p1)); - EXPECT_FALSE(safe_cmp::Ne(p2, p2)); + EXPECT_FALSE(SafeNe(p1, p1)); + EXPECT_TRUE(SafeNe(p1, p2)); + EXPECT_TRUE(SafeNe(p2, p1)); + EXPECT_FALSE(SafeNe(p2, p2)); } TEST(SafeCmpTest, Lt) { - static_assert(safe_cmp::Lt(-1, 2), ""); - static_assert(safe_cmp::Lt(-1, 2u), ""); - static_assert(!safe_cmp::Lt(2, -1), ""); - static_assert(!safe_cmp::Lt(2u, -1), ""); + static_assert(SafeLt(-1, 2), ""); + static_assert(SafeLt(-1, 2u), ""); + static_assert(!SafeLt(2, -1), ""); + static_assert(!SafeLt(2u, -1), ""); - static_assert(safe_cmp::Lt(1, 2), ""); - static_assert(safe_cmp::Lt(1, 2u), ""); - static_assert(safe_cmp::Lt(1u, 2), ""); - static_assert(safe_cmp::Lt(1u, 2u), ""); - static_assert(!safe_cmp::Lt(2, 1), ""); - static_assert(!safe_cmp::Lt(2, 1u), ""); - static_assert(!safe_cmp::Lt(2u, 1), ""); - static_assert(!safe_cmp::Lt(2u, 1u), ""); + static_assert(SafeLt(1, 2), ""); + static_assert(SafeLt(1, 2u), ""); + static_assert(SafeLt(1u, 2), ""); + static_assert(SafeLt(1u, 2u), ""); + static_assert(!SafeLt(2, 1), ""); + static_assert(!SafeLt(2, 1u), ""); + static_assert(!SafeLt(2u, 1), ""); + static_assert(!SafeLt(2u, 1u), ""); - static_assert(!safe_cmp::Lt(2, 2), ""); - static_assert(!safe_cmp::Lt(2, 2u), ""); - static_assert(!safe_cmp::Lt(2u, 2), ""); - static_assert(!safe_cmp::Lt(2u, 2u), ""); + static_assert(!SafeLt(2, 2), ""); + static_assert(!SafeLt(2, 2u), ""); + static_assert(!SafeLt(2u, 2), ""); + static_assert(!SafeLt(2u, 2u), ""); - static_assert(!safe_cmp::Lt(imin, imin), ""); - static_assert(safe_cmp::Lt(imin, umax), ""); - static_assert(!safe_cmp::Lt(umax, imin), ""); - static_assert(!safe_cmp::Lt(umax, umax), ""); + static_assert(!SafeLt(imin, imin), ""); + static_assert(SafeLt(imin, umax), ""); + static_assert(!SafeLt(umax, imin), ""); + static_assert(!SafeLt(umax, umax), ""); - static_assert(!safe_cmp::Lt(m1, m1), ""); - static_assert(safe_cmp::Lt(m1, umax), ""); - static_assert(!safe_cmp::Lt(umax, m1), ""); - static_assert(!safe_cmp::Lt(umax, umax), ""); + static_assert(!SafeLt(m1, m1), ""); + static_assert(SafeLt(m1, umax), ""); + static_assert(!SafeLt(umax, m1), ""); + static_assert(!SafeLt(umax, umax), ""); - static_assert(safe_cmp::Lt(1, 2), ""); - static_assert(safe_cmp::Lt(1, 2.0), ""); - static_assert(safe_cmp::Lt(1.0, 2), ""); - static_assert(safe_cmp::Lt(1.0, 2.0), ""); - static_assert(!safe_cmp::Lt(2, 1), ""); - static_assert(!safe_cmp::Lt(2, 1.0), ""); - static_assert(!safe_cmp::Lt(2.0, 1), ""); - static_assert(!safe_cmp::Lt(2.0, 1.0), ""); + static_assert(SafeLt(1, 2), ""); + static_assert(SafeLt(1, 2.0), ""); + static_assert(SafeLt(1.0, 2), ""); + static_assert(SafeLt(1.0, 2.0), ""); + static_assert(!SafeLt(2, 1), ""); + static_assert(!SafeLt(2, 1.0), ""); + static_assert(!SafeLt(2.0, 1), ""); + static_assert(!SafeLt(2.0, 1.0), ""); - static_assert(!safe_cmp::Lt(2, 2), ""); - static_assert(!safe_cmp::Lt(2, 2.0), ""); - static_assert(!safe_cmp::Lt(2.0, 2), ""); - static_assert(!safe_cmp::Lt(2.0, 2.0), ""); + static_assert(!SafeLt(2, 2), ""); + static_assert(!SafeLt(2, 2.0), ""); + static_assert(!SafeLt(2.0, 2), ""); + static_assert(!SafeLt(2.0, 2.0), ""); - EXPECT_FALSE(safe_cmp::Lt(p1, p1)); - EXPECT_TRUE(safe_cmp::Lt(p1, p2)); - EXPECT_FALSE(safe_cmp::Lt(p2, p1)); - EXPECT_FALSE(safe_cmp::Lt(p2, p2)); + EXPECT_FALSE(SafeLt(p1, p1)); + EXPECT_TRUE(SafeLt(p1, p2)); + EXPECT_FALSE(SafeLt(p2, p1)); + EXPECT_FALSE(SafeLt(p2, p2)); } TEST(SafeCmpTest, Le) { - static_assert(safe_cmp::Le(-1, 2), ""); - static_assert(safe_cmp::Le(-1, 2u), ""); - static_assert(!safe_cmp::Le(2, -1), ""); - static_assert(!safe_cmp::Le(2u, -1), ""); + static_assert(SafeLe(-1, 2), ""); + static_assert(SafeLe(-1, 2u), ""); + static_assert(!SafeLe(2, -1), ""); + static_assert(!SafeLe(2u, -1), ""); - static_assert(safe_cmp::Le(1, 2), ""); - static_assert(safe_cmp::Le(1, 2u), ""); - static_assert(safe_cmp::Le(1u, 2), ""); - static_assert(safe_cmp::Le(1u, 2u), ""); - static_assert(!safe_cmp::Le(2, 1), ""); - static_assert(!safe_cmp::Le(2, 1u), ""); - static_assert(!safe_cmp::Le(2u, 1), ""); - static_assert(!safe_cmp::Le(2u, 1u), ""); + static_assert(SafeLe(1, 2), ""); + static_assert(SafeLe(1, 2u), ""); + static_assert(SafeLe(1u, 2), ""); + static_assert(SafeLe(1u, 2u), ""); + static_assert(!SafeLe(2, 1), ""); + static_assert(!SafeLe(2, 1u), ""); + static_assert(!SafeLe(2u, 1), ""); + static_assert(!SafeLe(2u, 1u), ""); - static_assert(safe_cmp::Le(2, 2), ""); - static_assert(safe_cmp::Le(2, 2u), ""); - static_assert(safe_cmp::Le(2u, 2), ""); - static_assert(safe_cmp::Le(2u, 2u), ""); + static_assert(SafeLe(2, 2), ""); + static_assert(SafeLe(2, 2u), ""); + static_assert(SafeLe(2u, 2), ""); + static_assert(SafeLe(2u, 2u), ""); - static_assert(safe_cmp::Le(imin, imin), ""); - static_assert(safe_cmp::Le(imin, umax), ""); - static_assert(!safe_cmp::Le(umax, imin), ""); - static_assert(safe_cmp::Le(umax, umax), ""); + static_assert(SafeLe(imin, imin), ""); + static_assert(SafeLe(imin, umax), ""); + static_assert(!SafeLe(umax, imin), ""); + static_assert(SafeLe(umax, umax), ""); - static_assert(safe_cmp::Le(m1, m1), ""); - static_assert(safe_cmp::Le(m1, umax), ""); - static_assert(!safe_cmp::Le(umax, m1), ""); - static_assert(safe_cmp::Le(umax, umax), ""); + static_assert(SafeLe(m1, m1), ""); + static_assert(SafeLe(m1, umax), ""); + static_assert(!SafeLe(umax, m1), ""); + static_assert(SafeLe(umax, umax), ""); - static_assert(safe_cmp::Le(1, 2), ""); - static_assert(safe_cmp::Le(1, 2.0), ""); - static_assert(safe_cmp::Le(1.0, 2), ""); - static_assert(safe_cmp::Le(1.0, 2.0), ""); - static_assert(!safe_cmp::Le(2, 1), ""); - static_assert(!safe_cmp::Le(2, 1.0), ""); - static_assert(!safe_cmp::Le(2.0, 1), ""); - static_assert(!safe_cmp::Le(2.0, 1.0), ""); + static_assert(SafeLe(1, 2), ""); + static_assert(SafeLe(1, 2.0), ""); + static_assert(SafeLe(1.0, 2), ""); + static_assert(SafeLe(1.0, 2.0), ""); + static_assert(!SafeLe(2, 1), ""); + static_assert(!SafeLe(2, 1.0), ""); + static_assert(!SafeLe(2.0, 1), ""); + static_assert(!SafeLe(2.0, 1.0), ""); - static_assert(safe_cmp::Le(2, 2), ""); - static_assert(safe_cmp::Le(2, 2.0), ""); - static_assert(safe_cmp::Le(2.0, 2), ""); - static_assert(safe_cmp::Le(2.0, 2.0), ""); + static_assert(SafeLe(2, 2), ""); + static_assert(SafeLe(2, 2.0), ""); + static_assert(SafeLe(2.0, 2), ""); + static_assert(SafeLe(2.0, 2.0), ""); - EXPECT_TRUE(safe_cmp::Le(p1, p1)); - EXPECT_TRUE(safe_cmp::Le(p1, p2)); - EXPECT_FALSE(safe_cmp::Le(p2, p1)); - EXPECT_TRUE(safe_cmp::Le(p2, p2)); + EXPECT_TRUE(SafeLe(p1, p1)); + EXPECT_TRUE(SafeLe(p1, p2)); + EXPECT_FALSE(SafeLe(p2, p1)); + EXPECT_TRUE(SafeLe(p2, p2)); } TEST(SafeCmpTest, Gt) { - static_assert(!safe_cmp::Gt(-1, 2), ""); - static_assert(!safe_cmp::Gt(-1, 2u), ""); - static_assert(safe_cmp::Gt(2, -1), ""); - static_assert(safe_cmp::Gt(2u, -1), ""); + static_assert(!SafeGt(-1, 2), ""); + static_assert(!SafeGt(-1, 2u), ""); + static_assert(SafeGt(2, -1), ""); + static_assert(SafeGt(2u, -1), ""); - static_assert(!safe_cmp::Gt(1, 2), ""); - static_assert(!safe_cmp::Gt(1, 2u), ""); - static_assert(!safe_cmp::Gt(1u, 2), ""); - static_assert(!safe_cmp::Gt(1u, 2u), ""); - static_assert(safe_cmp::Gt(2, 1), ""); - static_assert(safe_cmp::Gt(2, 1u), ""); - static_assert(safe_cmp::Gt(2u, 1), ""); - static_assert(safe_cmp::Gt(2u, 1u), ""); + static_assert(!SafeGt(1, 2), ""); + static_assert(!SafeGt(1, 2u), ""); + static_assert(!SafeGt(1u, 2), ""); + static_assert(!SafeGt(1u, 2u), ""); + static_assert(SafeGt(2, 1), ""); + static_assert(SafeGt(2, 1u), ""); + static_assert(SafeGt(2u, 1), ""); + static_assert(SafeGt(2u, 1u), ""); - static_assert(!safe_cmp::Gt(2, 2), ""); - static_assert(!safe_cmp::Gt(2, 2u), ""); - static_assert(!safe_cmp::Gt(2u, 2), ""); - static_assert(!safe_cmp::Gt(2u, 2u), ""); + static_assert(!SafeGt(2, 2), ""); + static_assert(!SafeGt(2, 2u), ""); + static_assert(!SafeGt(2u, 2), ""); + static_assert(!SafeGt(2u, 2u), ""); - static_assert(!safe_cmp::Gt(imin, imin), ""); - static_assert(!safe_cmp::Gt(imin, umax), ""); - static_assert(safe_cmp::Gt(umax, imin), ""); - static_assert(!safe_cmp::Gt(umax, umax), ""); + static_assert(!SafeGt(imin, imin), ""); + static_assert(!SafeGt(imin, umax), ""); + static_assert(SafeGt(umax, imin), ""); + static_assert(!SafeGt(umax, umax), ""); - static_assert(!safe_cmp::Gt(m1, m1), ""); - static_assert(!safe_cmp::Gt(m1, umax), ""); - static_assert(safe_cmp::Gt(umax, m1), ""); - static_assert(!safe_cmp::Gt(umax, umax), ""); + static_assert(!SafeGt(m1, m1), ""); + static_assert(!SafeGt(m1, umax), ""); + static_assert(SafeGt(umax, m1), ""); + static_assert(!SafeGt(umax, umax), ""); - static_assert(!safe_cmp::Gt(1, 2), ""); - static_assert(!safe_cmp::Gt(1, 2.0), ""); - static_assert(!safe_cmp::Gt(1.0, 2), ""); - static_assert(!safe_cmp::Gt(1.0, 2.0), ""); - static_assert(safe_cmp::Gt(2, 1), ""); - static_assert(safe_cmp::Gt(2, 1.0), ""); - static_assert(safe_cmp::Gt(2.0, 1), ""); - static_assert(safe_cmp::Gt(2.0, 1.0), ""); + static_assert(!SafeGt(1, 2), ""); + static_assert(!SafeGt(1, 2.0), ""); + static_assert(!SafeGt(1.0, 2), ""); + static_assert(!SafeGt(1.0, 2.0), ""); + static_assert(SafeGt(2, 1), ""); + static_assert(SafeGt(2, 1.0), ""); + static_assert(SafeGt(2.0, 1), ""); + static_assert(SafeGt(2.0, 1.0), ""); - static_assert(!safe_cmp::Gt(2, 2), ""); - static_assert(!safe_cmp::Gt(2, 2.0), ""); - static_assert(!safe_cmp::Gt(2.0, 2), ""); - static_assert(!safe_cmp::Gt(2.0, 2.0), ""); + static_assert(!SafeGt(2, 2), ""); + static_assert(!SafeGt(2, 2.0), ""); + static_assert(!SafeGt(2.0, 2), ""); + static_assert(!SafeGt(2.0, 2.0), ""); - EXPECT_FALSE(safe_cmp::Gt(p1, p1)); - EXPECT_FALSE(safe_cmp::Gt(p1, p2)); - EXPECT_TRUE(safe_cmp::Gt(p2, p1)); - EXPECT_FALSE(safe_cmp::Gt(p2, p2)); + EXPECT_FALSE(SafeGt(p1, p1)); + EXPECT_FALSE(SafeGt(p1, p2)); + EXPECT_TRUE(SafeGt(p2, p1)); + EXPECT_FALSE(SafeGt(p2, p2)); } TEST(SafeCmpTest, Ge) { - static_assert(!safe_cmp::Ge(-1, 2), ""); - static_assert(!safe_cmp::Ge(-1, 2u), ""); - static_assert(safe_cmp::Ge(2, -1), ""); - static_assert(safe_cmp::Ge(2u, -1), ""); + static_assert(!SafeGe(-1, 2), ""); + static_assert(!SafeGe(-1, 2u), ""); + static_assert(SafeGe(2, -1), ""); + static_assert(SafeGe(2u, -1), ""); - static_assert(!safe_cmp::Ge(1, 2), ""); - static_assert(!safe_cmp::Ge(1, 2u), ""); - static_assert(!safe_cmp::Ge(1u, 2), ""); - static_assert(!safe_cmp::Ge(1u, 2u), ""); - static_assert(safe_cmp::Ge(2, 1), ""); - static_assert(safe_cmp::Ge(2, 1u), ""); - static_assert(safe_cmp::Ge(2u, 1), ""); - static_assert(safe_cmp::Ge(2u, 1u), ""); + static_assert(!SafeGe(1, 2), ""); + static_assert(!SafeGe(1, 2u), ""); + static_assert(!SafeGe(1u, 2), ""); + static_assert(!SafeGe(1u, 2u), ""); + static_assert(SafeGe(2, 1), ""); + static_assert(SafeGe(2, 1u), ""); + static_assert(SafeGe(2u, 1), ""); + static_assert(SafeGe(2u, 1u), ""); - static_assert(safe_cmp::Ge(2, 2), ""); - static_assert(safe_cmp::Ge(2, 2u), ""); - static_assert(safe_cmp::Ge(2u, 2), ""); - static_assert(safe_cmp::Ge(2u, 2u), ""); + static_assert(SafeGe(2, 2), ""); + static_assert(SafeGe(2, 2u), ""); + static_assert(SafeGe(2u, 2), ""); + static_assert(SafeGe(2u, 2u), ""); - static_assert(safe_cmp::Ge(imin, imin), ""); - static_assert(!safe_cmp::Ge(imin, umax), ""); - static_assert(safe_cmp::Ge(umax, imin), ""); - static_assert(safe_cmp::Ge(umax, umax), ""); + static_assert(SafeGe(imin, imin), ""); + static_assert(!SafeGe(imin, umax), ""); + static_assert(SafeGe(umax, imin), ""); + static_assert(SafeGe(umax, umax), ""); - static_assert(safe_cmp::Ge(m1, m1), ""); - static_assert(!safe_cmp::Ge(m1, umax), ""); - static_assert(safe_cmp::Ge(umax, m1), ""); - static_assert(safe_cmp::Ge(umax, umax), ""); + static_assert(SafeGe(m1, m1), ""); + static_assert(!SafeGe(m1, umax), ""); + static_assert(SafeGe(umax, m1), ""); + static_assert(SafeGe(umax, umax), ""); - static_assert(!safe_cmp::Ge(1, 2), ""); - static_assert(!safe_cmp::Ge(1, 2.0), ""); - static_assert(!safe_cmp::Ge(1.0, 2), ""); - static_assert(!safe_cmp::Ge(1.0, 2.0), ""); - static_assert(safe_cmp::Ge(2, 1), ""); - static_assert(safe_cmp::Ge(2, 1.0), ""); - static_assert(safe_cmp::Ge(2.0, 1), ""); - static_assert(safe_cmp::Ge(2.0, 1.0), ""); + static_assert(!SafeGe(1, 2), ""); + static_assert(!SafeGe(1, 2.0), ""); + static_assert(!SafeGe(1.0, 2), ""); + static_assert(!SafeGe(1.0, 2.0), ""); + static_assert(SafeGe(2, 1), ""); + static_assert(SafeGe(2, 1.0), ""); + static_assert(SafeGe(2.0, 1), ""); + static_assert(SafeGe(2.0, 1.0), ""); - static_assert(safe_cmp::Ge(2, 2), ""); - static_assert(safe_cmp::Ge(2, 2.0), ""); - static_assert(safe_cmp::Ge(2.0, 2), ""); - static_assert(safe_cmp::Ge(2.0, 2.0), ""); + static_assert(SafeGe(2, 2), ""); + static_assert(SafeGe(2, 2.0), ""); + static_assert(SafeGe(2.0, 2), ""); + static_assert(SafeGe(2.0, 2.0), ""); - EXPECT_TRUE(safe_cmp::Ge(p1, p1)); - EXPECT_FALSE(safe_cmp::Ge(p1, p2)); - EXPECT_TRUE(safe_cmp::Ge(p2, p1)); - EXPECT_TRUE(safe_cmp::Ge(p2, p2)); + EXPECT_TRUE(SafeGe(p1, p1)); + EXPECT_FALSE(SafeGe(p1, p2)); + EXPECT_TRUE(SafeGe(p2, p1)); + EXPECT_TRUE(SafeGe(p2, p2)); } TEST(SafeCmpTest, Enum) { @@ -381,14 +381,14 @@ TEST(SafeCmpTest, Enum) { enum { e2 = 13 }; enum E3 : unsigned { e3 = 13 }; enum : unsigned { e4 = 13 }; - static_assert(safe_cmp::Eq(13, e1), ""); - static_assert(safe_cmp::Eq(13u, e1), ""); - static_assert(safe_cmp::Eq(13, e2), ""); - static_assert(safe_cmp::Eq(13u, e2), ""); - static_assert(safe_cmp::Eq(13, e3), ""); - static_assert(safe_cmp::Eq(13u, e3), ""); - static_assert(safe_cmp::Eq(13, e4), ""); - static_assert(safe_cmp::Eq(13u, e4), ""); + static_assert(SafeEq(13, e1), ""); + static_assert(SafeEq(13u, e1), ""); + static_assert(SafeEq(13, e2), ""); + static_assert(SafeEq(13u, e2), ""); + static_assert(SafeEq(13, e3), ""); + static_assert(SafeEq(13u, e3), ""); + static_assert(SafeEq(13, e4), ""); + static_assert(SafeEq(13u, e4), ""); } } // namespace rtc diff --git a/webrtc/base/safe_minmax.h b/webrtc/base/safe_minmax.h index 5d6a7d077a..bf1cf43b0c 100644 --- a/webrtc/base/safe_minmax.h +++ b/webrtc/base/safe_minmax.h @@ -142,13 +142,12 @@ struct MType { // the lowest maximum value. In case that too is a tie, the types have the // same range, and we arbitrarily pick T1. using min_t = typename std::conditional< - safe_cmp::Lt(Limits::lowest, Limits::lowest), + SafeLt(Limits::lowest, Limits::lowest), T1, typename std::conditional< - safe_cmp::Gt(Limits::lowest, Limits::lowest), + SafeGt(Limits::lowest, Limits::lowest), T2, - typename std::conditional::max, - Limits::max), + typename std::conditional::max, Limits::max), T1, T2>::type>::type>::type; static_assert(std::is_same::value || @@ -158,11 +157,11 @@ struct MType { // The type with the highest maximum value. In case of a tie, the types have // the same range (because in C++, integer types with the same maximum also // have the same minimum). - static_assert(safe_cmp::Ne(Limits::max, Limits::max) || - safe_cmp::Eq(Limits::lowest, Limits::lowest), + static_assert(SafeNe(Limits::max, Limits::max) || + SafeEq(Limits::lowest, Limits::lowest), "integer types with the same max should have the same min"); using max_t = typename std:: - conditional::max, Limits::max), T1, T2>::type; + conditional::max, Limits::max), T1, T2>::type; static_assert(std::is_same::value || std::is_same::value, ""); @@ -178,8 +177,8 @@ template struct TypeOr { using type = typename std:: conditional::value, B, A>::type; - static_assert(safe_cmp::Le(Limits::lowest, Limits::lowest) && - safe_cmp::Ge(Limits::max, Limits::max), + static_assert(SafeLe(Limits::lowest, Limits::lowest) && + SafeGe(Limits::max, Limits::max), "The specified type isn't large enough"); static_assert(IsIntlike::value == IsIntlike::value && std::is_floating_point::value == @@ -203,7 +202,7 @@ constexpr R2 SafeMin(T1 a, T2 b) { "The first argument must be integral or floating-point"); static_assert(IsIntlike::value || std::is_floating_point::value, "The second argument must be integral or floating-point"); - return safe_cmp::Lt(a, b) ? static_cast(a) : static_cast(b); + return SafeLt(a, b) ? static_cast(a) : static_cast(b); } template < @@ -220,7 +219,7 @@ constexpr R2 SafeMax(T1 a, T2 b) { "The first argument must be integral or floating-point"); static_assert(IsIntlike::value || std::is_floating_point::value, "The second argument must be integral or floating-point"); - return safe_cmp::Gt(a, b) ? static_cast(a) : static_cast(b); + return SafeGt(a, b) ? static_cast(a) : static_cast(b); } namespace safe_minmax_impl { @@ -265,8 +264,7 @@ struct ClampType { sizeof(A) <= sizeof(H) || sizeof(A) <= sizeof(T); static constexpr bool range_contained = - safe_cmp::Le(Limits::lowest, r_min) && - safe_cmp::Le(r_max, Limits::max); + SafeLe(Limits::lowest, r_min) && SafeLe(r_max, Limits::max); public: static constexpr bool value = not_too_large && range_contained; @@ -327,9 +325,9 @@ R2 SafeClamp(T x, L min, H max) { static_assert(IsIntlike::value || std::is_floating_point::value, "The third argument must be integral or floating-point"); RTC_DCHECK_LE(min, max); - return safe_cmp::Le(x, min) + return SafeLe(x, min) ? static_cast(min) - : safe_cmp::Ge(x, max) ? static_cast(max) : static_cast(x); + : SafeGe(x, max) ? static_cast(max) : static_cast(x); } } // namespace rtc