ClassTestUtils.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
// Standard-library-only utilities owned by the class-test framework (no libOpenMS
// dependency). Two mirror libOpenMS behavior and must not drift:
//  * detail::appendNumeric <-> StringUtils' appendNumeric (StringUtils.cpp): so
//    TEST_EQUAL(std::string, <number>) formats exactly like StringUtils::toStr().
//  * writtenDigits <-> OpenMS::writtenDigits (OpenMS/CONCEPT/Types.h).
 
#include <charconv>
#include <cmath>
#include <cstring>
#include <filesystem>
#include <limits>
#include <ostream>
#include <ranges>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace OpenMS
{
  namespace Internal
  {
    namespace ClassTest
    {
      template <typename T>
      constexpr int writtenDigits(const T& = T())
      {
        using C = std::remove_cvref_t<T>;
        if constexpr (std::is_floating_point_v<C>)
        {
          return std::numeric_limits<C>::digits10;
        }
        else if constexpr (std::is_integral_v<C>)
        {
          return std::numeric_limits<C>::digits10;
        }
        else if constexpr (std::is_class_v<C> && std::is_convertible_v<const C&, double>)
        {
          return std::numeric_limits<double>::digits10;
        }
        else
        {
          return 6; // default precision of an ostream (27.4.4.1), like OpenMS::writtenDigits
        }
      }
 
      template <typename T>
      constexpr bool isRealType(const T&)
      {
        using C = std::remove_cvref_t<T>;
        return std::is_floating_point_v<C> || (std::is_class_v<C> && std::is_convertible_v<const C&, double>);
      }
 
      namespace detail
      {
        inline void trim(std::string& s)
        {
          const char* ws = " \t\n\r";
          const size_t b = s.find_first_not_of(ws);
          if (b == std::string::npos)
          {
            s.clear();
            return;
          }
          const size_t e = s.find_last_not_of(ws);
          s = s.substr(b, e - b + 1);
        }
 
        inline std::vector<std::string> split(const std::string& s, char splitter)
        {
          std::vector<std::string> out;
          if (s.empty()) return out;
          size_t begin = 0;
          for (size_t i = 0; i < s.size(); ++i)
          {
            if (s[i] == splitter)
            {
              out.emplace_back(s, begin, i - begin);
              begin = i + 1;
            }
          }
          out.emplace_back(s, begin, s.size() - begin);
          return out;
        }
 
        inline std::string join(const std::vector<std::string>& v, const char* sep)
        {
          std::string out;
          for (size_t i = 0; i < v.size(); ++i)
          {
            if (i) out += sep;
            out += v[i];
          }
          return out;
        }
 
        template <typename T>
        inline void appendNumeric(T value, std::string& target, int precision, bool fixed_format)
        {
          if (std::isnan(value)) { target += "NaN"; return; }
          if (std::isinf(value)) { target += (value < T(0)) ? "-inf" : "inf"; return; }
          char buf[64];
          std::to_chars_result fc;
 
          // Determine format: use scientific for extreme values or when fixed_format is requested
          // but the value is too small/large for fixed notation
          T abs_val = (value < 0) ? -value : value;
          bool use_scientific = fixed_format
            ? (abs_val != T(0) && (abs_val >= T(1e4) || abs_val < T(1e-2)))
            : (abs_val != T(0) && (abs_val >= T(1e4) || abs_val < T(1e-2)));
 
          if (use_scientific)
          {
            if (fixed_format)
            {
              fc = std::to_chars(buf, buf + sizeof(buf), value, std::chars_format::scientific, 3);
            }
            else
            {
              // Shortest round-trip representation (no explicit precision): the unique shortest
              // decimal that round-trips back to the same double, hence platform-independent.
              fc = std::to_chars(buf, buf + sizeof(buf), value, std::chars_format::scientific);
            }
          }
          else if (fixed_format)
          {
            fc = std::to_chars(buf, buf + sizeof(buf), value, std::chars_format::fixed, precision);
          }
          else
          {
            fc = std::to_chars(buf, buf + sizeof(buf), value, std::chars_format::fixed, precision);
          }
 
          if (fc.ec == std::errc{})
          {
            const char* end = fc.ptr;
 
            // For scientific notation: post-process "1.234e+04" into the historical "1.234e04"
            const char* e_pos = reinterpret_cast<const char*>(std::memchr(buf, 'e', end - buf));
            if (e_pos)
            {
              const char* e_orig = e_pos; // save before mantissa trimming
 
              // Trim trailing zeros from mantissa (before 'e')
              const char* dot = reinterpret_cast<const char*>(std::memchr(buf, '.', e_orig - buf));
              if (dot)
              {
                while (e_pos > dot + 1 && *(e_pos - 1) == '0') --e_pos;
                if (e_pos == dot + 1) e_pos = dot + 2; // keep at least one digit after dot
              }
              target.append(buf, static_cast<size_t>(e_pos - buf));
              if (!dot) target += ".0";
              target += 'e';
 
              // Fix exponent format: "+04" -> "04" (remove '+', keep '-' and zero-padding).
              const char* exp_start = e_orig + 1; // skip 'e'
              if (exp_start < end && *exp_start == '+')
                ++exp_start; // skip '+'
              size_t exp_len = static_cast<size_t>(end - exp_start);
              target.append(exp_start, exp_len);
              return;
            }
 
            // For fixed notation: trim trailing zeros after decimal point
            const char* dot = reinterpret_cast<const char*>(std::memchr(buf, '.', end - buf));
            if (dot)
            {
              while (end > dot + 1 && *(end - 1) == '0') --end;
              if (end == dot + 1) end = dot + 2; // keep at least one digit after dot
            }
            else if constexpr (std::is_floating_point_v<T>)
            {
              target.append(buf, static_cast<size_t>(end - buf));
              target += ".0";
              return;
            }
            target.append(buf, static_cast<size_t>(end - buf));
          }
          else
          {
            target += std::to_string(static_cast<double>(value));
          }
        }
 
 
        inline std::string toString(const std::string& s) { return s; }
        inline std::string toString(std::string_view sv) { return std::string(sv); }
        inline std::string toString(const char* s) { return std::string(s); }
        inline std::string toString(char c) { return std::string(1, c); }
        template <typename T>
        inline std::string toString(const T& v)
        {
          static_assert(std::is_arithmetic_v<T>,
                        "TEST_EQUAL(std::string, x): x must be a string, character or number. "
                        "For other types, stringify explicitly in the test.");
          std::string r;
          if constexpr (std::is_same_v<T, bool>)
          {
            r = v ? "1" : "0";
          }
          else if constexpr (std::is_floating_point_v<T>)
          {
            appendNumeric(v, r, std::numeric_limits<T>::digits10, false); // full precision, like toStr(v, true)
          }
          else
          {
            char buf[32];
            auto [p, ec] = std::to_chars(buf, buf + sizeof(buf), v);
            if (ec == std::errc{}) r.append(buf, p);
          }
          return r;
        }
 
        template <typename T>
        concept Streamable = requires(std::ostream& os, const T& t) { os << t; };
 
        template <typename T>
        void printValue(std::ostream& os, const T& v)
        {
          using C = std::remove_cvref_t<T>;
          if constexpr (Streamable<C>)
          {
            os << v;
          }
          else if constexpr (std::ranges::input_range<C>)
          {
            os << '[';
            bool first = true;
            for (const auto& e : v)
            {
              if (!first) os << ", ";
              first = false;
              using E = std::remove_cvref_t<decltype(e)>;
              if constexpr (std::is_arithmetic_v<E>)
              {
                os << toString(e); // numbers like ListUtilsIO (via toStr)
              }
              else if constexpr (Streamable<E>)
              {
                os << e;
              }
              else
              {
                os << "<?>";
              }
            }
            os << ']';
          }
          else
          {
            os << "<value of unprintable type - provide operator<< or compare via TEST_TRUE>";
          }
        }
 
        inline std::filesystem::path to_path(const std::string& s)
        {
#ifdef _WIN32
          try
          {
            return std::filesystem::path(std::u8string(reinterpret_cast<const char8_t*>(s.data()), s.size()));
          }
          catch (const std::system_error&)
          {
            return std::filesystem::path(s);
          }
#else
          return std::filesystem::path(std::u8string(reinterpret_cast<const char8_t*>(s.data()), s.size()));
#endif
        }
      } // namespace detail
 
      template <typename FloatingPointType>
      struct PrecisionWrapped
      {
        FloatingPointType value;
      };
 
      template <typename FloatingPointType>
      inline PrecisionWrapped<FloatingPointType> precisionWrapper(const FloatingPointType value)
      {
        return PrecisionWrapped<FloatingPointType> {value};
      }
 
      template <typename FloatingPointType>
      inline std::ostream& operator<<(std::ostream& os, const PrecisionWrapped<FloatingPointType>& p)
      {
        os << detail::toString(p.value);
        return os;
      }
    } // namespace ClassTest
  } // namespace Internal
} // namespace OpenMS