webrtc/base/safe_minmax_unittest.cc

/*
 *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <algorithm>
#include <limits>

#include "webrtc/base/safe_minmax.h"
#include "webrtc/test/gtest.h"

namespace rtc {

namespace {

// Functions that check that SafeMin() and SafeMax() return the specified type.
// The functions that end in "R" use an explicitly given return type.

template <typename T1, typename T2, typename Tmin, typename Tmax>
constexpr bool TypeCheckMinMax() {
  return std::is_same<decltype(SafeMin(std::declval<T1>(), std::declval<T2>())),
                      Tmin>::value &&
         std::is_same<decltype(SafeMax(std::declval<T1>(), std::declval<T2>())),
                      Tmax>::value;
}

template <typename T1, typename T2, typename R>
constexpr bool TypeCheckMinR() {
  return std::is_same<
      decltype(SafeMin<R>(std::declval<T1>(), std::declval<T2>())), R>::value;
}

template <typename T1, typename T2, typename R>
constexpr bool TypeCheckMaxR() {
  return std::is_same<
      decltype(SafeMax<R>(std::declval<T1>(), std::declval<T2>())), R>::value;
}

// clang-format off

// SafeMin/SafeMax: Check that all combinations of signed/unsigned 8/64 bits
// give the correct default result type.
static_assert(TypeCheckMinMax<  int8_t,   int8_t,   int8_t,   int8_t>(), "");
static_assert(TypeCheckMinMax<  int8_t,  uint8_t,   int8_t,  uint8_t>(), "");
static_assert(TypeCheckMinMax<  int8_t,  int64_t,  int64_t,  int64_t>(), "");
static_assert(TypeCheckMinMax<  int8_t, uint64_t,   int8_t, uint64_t>(), "");
static_assert(TypeCheckMinMax< uint8_t,   int8_t,   int8_t,  uint8_t>(), "");
static_assert(TypeCheckMinMax< uint8_t,  uint8_t,  uint8_t,  uint8_t>(), "");
static_assert(TypeCheckMinMax< uint8_t,  int64_t,  int64_t,  int64_t>(), "");
static_assert(TypeCheckMinMax< uint8_t, uint64_t,  uint8_t, uint64_t>(), "");
static_assert(TypeCheckMinMax< int64_t,   int8_t,  int64_t,  int64_t>(), "");
static_assert(TypeCheckMinMax< int64_t,  uint8_t,  int64_t,  int64_t>(), "");
static_assert(TypeCheckMinMax< int64_t,  int64_t,  int64_t,  int64_t>(), "");
static_assert(TypeCheckMinMax< int64_t, uint64_t,  int64_t, uint64_t>(), "");
static_assert(TypeCheckMinMax<uint64_t,   int8_t,   int8_t, uint64_t>(), "");
static_assert(TypeCheckMinMax<uint64_t,  uint8_t,  uint8_t, uint64_t>(), "");
static_assert(TypeCheckMinMax<uint64_t,  int64_t,  int64_t, uint64_t>(), "");
static_assert(TypeCheckMinMax<uint64_t, uint64_t, uint64_t, uint64_t>(), "");

enum DefaultE { kFoo = -17 };
enum UInt8E : uint8_t { kBar = 17 };

// SafeMin/SafeMax: Check that we can use enum types.
static_assert(TypeCheckMinMax<unsigned, unsigned, unsigned, unsigned>(), "");
static_assert(TypeCheckMinMax<unsigned, DefaultE,      int, unsigned>(), "");
static_assert(TypeCheckMinMax<unsigned,   UInt8E,  uint8_t, unsigned>(), "");
static_assert(TypeCheckMinMax<DefaultE, unsigned,      int, unsigned>(), "");
static_assert(TypeCheckMinMax<DefaultE, DefaultE,      int,      int>(), "");
static_assert(TypeCheckMinMax<DefaultE,   UInt8E,      int,      int>(), "");
static_assert(TypeCheckMinMax<  UInt8E, unsigned,  uint8_t, unsigned>(), "");
static_assert(TypeCheckMinMax<  UInt8E, DefaultE,     int,       int>(), "");
static_assert(TypeCheckMinMax<  UInt8E,   UInt8E,  uint8_t,  uint8_t>(), "");

using ld = long double;

// SafeMin/SafeMax: Check that all floating-point combinations give the
// correct result type.
static_assert(TypeCheckMinMax< float,  float,  float,  float>(), "");
static_assert(TypeCheckMinMax< float, double, double, double>(), "");
static_assert(TypeCheckMinMax< float,     ld,     ld,     ld>(), "");
static_assert(TypeCheckMinMax<double,  float, double, double>(), "");
static_assert(TypeCheckMinMax<double, double, double, double>(), "");
static_assert(TypeCheckMinMax<double,     ld,     ld,     ld>(), "");
static_assert(TypeCheckMinMax<    ld,  float,     ld,     ld>(), "");
static_assert(TypeCheckMinMax<    ld, double,     ld,     ld>(), "");
static_assert(TypeCheckMinMax<    ld,     ld,     ld,     ld>(), "");

// clang-format on

// SafeMin/SafeMax: Check some cases of explicitly specified return type. The
// commented-out lines give compilation errors due to the requested return type
// being too small or requiring an int<->float conversion.
static_assert(TypeCheckMinR<int8_t, int8_t, int16_t>(), "");
// static_assert(TypeCheckMinR<int8_t, int8_t, float>(), "");
static_assert(TypeCheckMinR<uint32_t, uint64_t, uint32_t>(), "");
// static_assert(TypeCheckMaxR<uint64_t, float, float>(), "");
// static_assert(TypeCheckMaxR<uint64_t, double, float>(), "");
static_assert(TypeCheckMaxR<uint32_t, int32_t, uint32_t>(), "");
// static_assert(TypeCheckMaxR<uint32_t, int32_t, int32_t>(), "");

template <typename T1, typename T2, typename Tmin, typename Tmax>
constexpr bool CheckMinMax(T1 a, T2 b, Tmin min, Tmax max) {
  return TypeCheckMinMax<T1, T2, Tmin, Tmax>() && SafeMin(a, b) == min &&
         SafeMax(a, b) == max;
}

// SafeMin/SafeMax: Check a few values.
static_assert(CheckMinMax(int8_t{1}, int8_t{-1}, int8_t{-1}, int8_t{1}), "");
static_assert(CheckMinMax(uint8_t{1}, int8_t{-1}, int8_t{-1}, uint8_t{1}), "");
static_assert(CheckMinMax(uint8_t{5}, uint64_t{2}, uint8_t{2}, uint64_t{5}),
              "");
static_assert(CheckMinMax(std::numeric_limits<int32_t>::min(),
                          std::numeric_limits<uint32_t>::max(),
                          std::numeric_limits<int32_t>::min(),
                          std::numeric_limits<uint32_t>::max()),
              "");
static_assert(CheckMinMax(std::numeric_limits<int32_t>::min(),
                          std::numeric_limits<uint16_t>::max(),
                          std::numeric_limits<int32_t>::min(),
                          int32_t{std::numeric_limits<uint16_t>::max()}),
              "");
// static_assert(CheckMinMax(1.f, 2, 1.f, 2.f), "");
static_assert(CheckMinMax(1.f, 0.0, 0.0, 1.0), "");

}  // namespace

// clang-format off

// These functions aren't used in the tests, but it's useful to look at the
// compiler output for them, and verify that (1) the same-signedness *Safe
// functions result in exactly the same code as their *Ref counterparts, and
// that (2) the mixed-signedness *Safe functions have just a few extra
// arithmetic and logic instructions (but no extra control flow instructions).
int32_t  TestMinRef(  int32_t a,  int32_t b) { return std::min(a, b); }
uint32_t TestMinRef( uint32_t a, uint32_t b) { return std::min(a, b); }
int32_t  TestMinSafe( int32_t a,  int32_t b) { return SafeMin(a, b); }
int32_t  TestMinSafe( int32_t a, uint32_t b) { return SafeMin(a, b); }
int32_t  TestMinSafe(uint32_t a,  int32_t b) { return SafeMin(a, b); }
uint32_t TestMinSafe(uint32_t a, uint32_t b) { return SafeMin(a, b); }

// clang-format on

}  // namespace rtc