fix utils: proper handling of infinite floating point values in numeric_cast

Fixes numeric\_cast of infinite floating type values.

Adds extra numeric\_cast tests for infinte and NaN values.
commit_hash:580336e395481c234735d78da6cdbfee2a58d10a

Author: lexeyo

universal/include/userver/utils/numeric_cast.hpp

@@ -3,6 +3,7 @@
 /// @file userver/utils/numeric_cast.hpp
 /// @brief @copybrief utils::numeric_cast
 
+#include <cmath>
 #include <limits>
 #include <stdexcept>
 
@@ -50,13 +51,17 @@ constexpr To numeric_cast(From input) {  // NOLINT(readability-identifier-naming
 
     if constexpr (check_positive_overflow) {
         if (input > static_cast<From>(ToLimits::max())) {
-            overflow_type = "positive";
+            if (!FromLimits::has_infinity || !std::isinf(input)) {
+                overflow_type = "positive";
+            }
         }
     }
 
     if constexpr (check_negative_overflow) {
         if (input < static_cast<From>(ToLimits::lowest())) {
-            overflow_type = "negative";
+            if (!FromLimits::has_infinity || !std::isinf(input)) {
+                overflow_type = "negative";
+            }
         }
     }
 

universal/src/utils/numeric_cast_test.cpp

@@ -1,6 +1,8 @@
+#include <cmath>
 #include <limits>
 
 #include <gmock/gmock.h>
+#include <gtest/gtest.h>
 #include <userver/utest/assert_macros.hpp>
 
 #include <userver/utils/numeric_cast.hpp>
@@ -9,6 +11,29 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
+template <typename TFrom, typename TTo>
+struct CastTypes {
+    using From = TFrom;
+    using To = TTo;
+};
+
+using FloatingPointCastTypes = ::testing::Types<
+    CastTypes<float, float>,
+    CastTypes<float, double>,
+    CastTypes<float, long double>,
+    CastTypes<double, float>,
+    CastTypes<double, double>,
+    CastTypes<double, long double>,
+    CastTypes<long double, float>,
+    CastTypes<long double, double>,
+    CastTypes<long double, long double>>;
+
+template <typename CastTypes>
+class NumericCastFloatingPoint : public ::testing::Test {
+    using From = typename CastTypes::From;
+    using To = typename CastTypes::To;
+};
+
 TEST(NumericCast, CompileTime) {
     static_assert(utils::numeric_cast<unsigned int>(1) == 1u);
     static_assert(utils::numeric_cast<float>(1.0) == 1.0f);
@@ -33,6 +58,29 @@ TEST(NumericCast, Smoke) {
     EXPECT_EQ(utils::numeric_cast<long double>(1.0L), 1.0L);
 }
 
+TYPED_TEST_SUITE(NumericCastFloatingPoint, FloatingPointCastTypes);
+
+TYPED_TEST(NumericCastFloatingPoint, Nan) {
+    using Limits = std::numeric_limits<typename TypeParam::From>;
+
+    if constexpr (Limits::has_quiet_NaN) {
+        EXPECT_TRUE(std::isnan(utils::numeric_cast<typename TypeParam::To>(Limits::quiet_NaN())));
+    }
+}
+
+TYPED_TEST(NumericCastFloatingPoint, Infinity) {
+    using To = typename TypeParam::To;
+    using FromLimits = std::numeric_limits<typename TypeParam::From>;
+    using ToLimits = std::numeric_limits<To>;
+
+    if constexpr (FromLimits::has_infinity) {
+        // +inf
+        EXPECT_EQ(utils::numeric_cast<To>(FromLimits::infinity()), ToLimits::infinity());
+        // -inf
+        EXPECT_EQ(utils::numeric_cast<To>(-FromLimits::infinity()), -ToLimits::infinity());
+    }
+}
+
 TEST(NumericCast, SignedToUnsignedOverflow) {
     /// [Sample utils::numeric_cast usage]
     EXPECT_EQ(utils::numeric_cast<std::uint16_t>(0xffff), 0xffffu);