gtest.hpp

Go to the documentation of this file.

#pragma once
 
 
#include "floating_eq.hpp"
#include "trace.hpp"
#include <gtest/gtest.h>
#include <uni20/core/scalar_io.hpp>
 
namespace uni20::check::detail
{
template <class T> std::string floating_operand_text(T const& value) { return uni20::format_scalar(value); }
 
#if UNI20_HAS_MPREAL
inline std::string floating_operand_text(mpreal const& value)
{
  if (!value.initialized()) return "<unset>";
  auto text = value.to_string();
  return value.is_exact() ? text + " [exact]" : text + " [" + std::to_string(value.precision().bit_count()) + " bits]";
}
#endif
 
template <UlpComparable T>
::testing::AssertionResult floating_eq_assertion(char const* name, char const* left, char const* right, T const& a,
                                                 T const& b, std::int64_t ulps)
{
  if (ulps < 0) return ::testing::AssertionFailure() << name << " requires non-negative ULP tolerance, got " << ulps;
  if (FloatingULP<T>::eq(a, b, ulps)) return ::testing::AssertionSuccess();
 
  auto result = ::testing::AssertionFailure();
  result << name << " failed\n  " << left << " = " << floating_operand_text(a) << "\n  " << right << " = "
         << floating_operand_text(b) << "\n  allowed tolerance: " << ulps << " ULP\n  actual distance: ";
  auto const distance = float_abs_distance(a, b);
  if (distance == std::numeric_limits<long long>::max())
    result << "unrepresentable or exceeds diagnostic range";
  else
    result << distance;
#if UNI20_HAS_MPREAL
  if constexpr (std::same_as<T, mpreal>)
    if (auto reason = compare_mpreal(a, b, ulps).reason) result << "\n  reason: " << reason;
#endif
  return result;
}
} // namespace uni20::check::detail
 
#define EXPECT_FLOATING_EQ(a, b, ...)                                                                                  \
  do                                                                                                                   \
  {                                                                                                                    \
    auto va = (a);                                                                                                     \
    auto vb = (b);                                                                                                     \
    auto ulps = ::trace::detail::get_ulps(va, vb __VA_OPT__(, __VA_ARGS__));                                           \
    auto result = ::uni20::check::detail::floating_eq_assertion("EXPECT_FLOATING_EQ", #a, #b, va, vb, ulps);           \
    if (!result)                                                                                                       \
    {                                                                                                                  \
      ADD_FAILURE() << result.message();                                                                               \
    }                                                                                                                  \
  }                                                                                                                    \
  while (0)
 
#define ASSERT_FLOATING_EQ(a, b, ...)                                                                                  \
  do                                                                                                                   \
  {                                                                                                                    \
    auto va = (a);                                                                                                     \
    auto vb = (b);                                                                                                     \
    auto ulps = ::trace::detail::get_ulps(va, vb __VA_OPT__(, __VA_ARGS__));                                           \
    auto result = ::uni20::check::detail::floating_eq_assertion("ASSERT_FLOATING_EQ", #a, #b, va, vb, ulps);           \
    if (!result)                                                                                                       \
    {                                                                                                                  \
      FAIL() << result.message();                                                                                      \
    }                                                                                                                  \
  }                                                                                                                    \
  while (0)