Merge pull request #1248 from cppalliance/1198

mborland · web-flow · commit 3b9c322cd8af · 2025-11-17T13:53:14.000+01:00
Remove LCOV exclusions for lines that could theoretically be taken
diff --git a/include/boost/decimal/charconv.hpp b/include/boost/decimal/charconv.hpp
@@ -190,7 +190,7 @@ constexpr auto to_chars_nonfinite(char* first, char* last, const TargetDecimalTy
                 }
             }
 
-            return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE : Should be unreachable
+            return {last, std::errc::value_too_large};
         case FP_NAN:
             if (issignaling(value) && buffer_len >= 9)
             {
@@ -238,7 +238,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
     // Dummy check the bounds
     if (BOOST_DECIMAL_UNLIKELY(buffer_size < real_precision))
     {
-        return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE
+        return {last, std::errc::value_too_large};
     }
 
     using uint_type = std::conditional_t<(std::numeric_limits<typename TargetDecimalType::significand_type>::digits >
@@ -253,7 +253,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
     // which we have already checked for
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
-        return r; // LCOV_EXCL_LINE
+        return r;
     }
 
     auto current_digits {r.ptr - (first + 1)};
@@ -273,7 +273,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
     const auto total_length {total_buffer_length<TargetDecimalType>(static_cast<int>(current_digits), exp, is_neg)};
     if (BOOST_DECIMAL_UNLIKELY(total_length > buffer_size))
     {
-        return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE
+        return {last, std::errc::value_too_large};
     }
 
     // Insert our decimal point (or don't in the 1 digit case)
@@ -309,7 +309,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
 
     if (BOOST_DECIMAL_UNLIKELY(!exp_r))
     {
-        return exp_r; // LCOV_EXCL_LINE
+        return exp_r;
     }
 
     return {exp_r.ptr, std::errc{}};
@@ -374,7 +374,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
             }
             else if (significand_digits > local_precision + 1)
             {
-                const auto original_sig = significand; // LCOV_EXCL_LINE : False negative
+                const auto original_sig = significand;
                 fenv_round<TargetDecimalType>(significand);
                 if (remove_trailing_zeros(original_sig + 1U).trimmed_number == 1U)
                 {
@@ -406,7 +406,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
     // Only real reason we will hit this is a buffer overflow
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
-        return r; // LCOV_EXCL_LINE
+        return r;
     }
 
     const auto current_digits = r.ptr - (first + 1) - 1;
@@ -478,7 +478,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec
     r = to_chars_integer_impl<int>(first, last, abs_exp);
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
-        return r; // LCOV_EXCL_LINE
+        return r;
     }
 
     return {r.ptr, std::errc()};
@@ -520,7 +520,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT
 
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
-        return r; // LCOV_EXCL_LINE
+        return r;
     }
 
     const auto num_digits {r.ptr - current};
@@ -536,7 +536,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT
     {
         if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + num_digits + exp))
         {
-            return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE
+            return {last, std::errc::value_too_large};
         }
 
         detail::memset(r.ptr, '0', static_cast<std::size_t>(exp));
@@ -546,7 +546,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT
     {
         if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + num_digits + 1))
         {
-            return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE
+            return {last, std::errc::value_too_large};
         }
 
         const auto decimal_pos {num_digits - abs_exp};
@@ -560,7 +560,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT
         const auto leading_zeros {abs_exp - num_digits};
         if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + 2 + leading_zeros + num_digits))
         {
-            return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE
+            return {last, std::errc::value_too_large};
         }
 
         detail::memmove(current + 2 + leading_zeros, current, static_cast<std::size_t>(num_digits));
diff --git a/include/boost/decimal/cstdio.hpp b/include/boost/decimal/cstdio.hpp
@@ -216,10 +216,8 @@ inline auto snprintf_impl(char* buffer, const std::size_t buf_size, const char*
 
         if (!r)
         {
-            // LCOV_EXCL_START
             errno = static_cast<int>(r.ec);
             return -1;
-            // LCOV_EXCL_STOP
         }
 
         // Adjust the capitalization and locale
@@ -287,7 +285,6 @@ inline auto fprintf(std::FILE* buffer, const char* format, const T... values) no
     }
     else
     {
-        // LCOV_EXCL_START
         // Add 50% overage in case we need to do locale conversion
         std::unique_ptr<char[]> longer_char_buffer(new(std::nothrow) char[(3 * (format_len + value_space + 1)) / 2]);
         if (longer_char_buffer == nullptr)
@@ -301,7 +298,6 @@ inline auto fprintf(std::FILE* buffer, const char* format, const T... values) no
         {
             bytes += static_cast<int>(std::fwrite(longer_char_buffer.get(), sizeof(char), static_cast<std::size_t>(bytes), buffer));
         }
-        // LCOV_EXCL_STOP
     }
 
     return bytes;
diff --git a/include/boost/decimal/cstdlib.hpp b/include/boost/decimal/cstdlib.hpp
@@ -73,7 +73,7 @@ inline auto strtod_calculation(const char* str, char** endptr, char* buffer, con
         {
             if (significand)
             {
-                d = std::numeric_limits<TargetDecimalType>::signaling_NaN(); // LCOV_EXCL_LINE : False negative
+                d = std::numeric_limits<TargetDecimalType>::signaling_NaN();
             }
             else
             {
@@ -125,11 +125,8 @@ inline auto strtod_impl(const char* str, char** endptr) noexcept -> TargetDecima
     std::unique_ptr<char[]> buffer(new(std::nothrow) char[str_length + 1]);
     if (buffer == nullptr)
     {
-        // Hard to get coverage on memory exhaustion
-        // LCOV_EXCL_START
         errno = ENOMEM;
         return std::numeric_limits<TargetDecimalType>::quiet_NaN();
-        // LCOV_EXCL_STOP
     }
 
     auto d = strtod_calculation<TargetDecimalType>(str, endptr, buffer.get(), str_length);
@@ -148,7 +145,7 @@ inline auto wcstod_calculation(const wchar_t* str, wchar_t** endptr, char* buffe
         if (BOOST_DECIMAL_UNLIKELY(val > 255))
         {
             // Character can not be converted
-            return std::numeric_limits<TargetDecimalType>::quiet_NaN(); // LCOV_EXCL_LINE
+            return std::numeric_limits<TargetDecimalType>::quiet_NaN();
         }
 
         buffer[i] = static_cast<char>(val);
@@ -188,11 +185,8 @@ inline auto wcstod_impl(const wchar_t* str, wchar_t** endptr) noexcept -> Target
     std::unique_ptr<char[]> buffer(new(std::nothrow) char[str_length + 1]);
     if (buffer == nullptr)
     {
-        // Hard to get coverage on memory exhaustion
-        // LCOV_EXCL_START
         errno = ENOMEM;
         return std::numeric_limits<TargetDecimalType>::quiet_NaN();
-        // LCOV_EXCL_STOP
     }
 
     return wcstod_calculation<TargetDecimalType>(str, endptr, buffer.get(), str_length);
diff --git a/include/boost/decimal/detail/cmath/atan.hpp b/include/boost/decimal/detail/cmath/atan.hpp
@@ -48,7 +48,7 @@ constexpr auto atan_impl(const T x) noexcept
     #ifndef BOOST_DECIMAL_FAST_MATH
     else if (fpc == FP_INFINITE)
     {
-        result = my_pi_half; // LCOV_EXCL_LINE False negative
+        result = my_pi_half;
     }
     #endif
     else
diff --git a/include/boost/decimal/detail/cmath/tgamma.hpp b/include/boost/decimal/detail/cmath/tgamma.hpp
@@ -50,15 +50,15 @@ constexpr auto tgamma_impl(const T x) noexcept
         }
         else
         {
-            result = x; // LCOV_EXCL_LINE : False negative
+            result = x;
         }
         #endif
     }
     else if (is_pure_int && is_neg)
     {
         // Pure negative integer argument.
         #ifndef BOOST_DECIMAL_FAST_MATH
-        result = std::numeric_limits<T>::quiet_NaN(); // LCOV_EXCL_LINE : False negative
+        result = std::numeric_limits<T>::quiet_NaN();
         #else
         result = T{0};
         #endif
diff --git a/include/boost/decimal/detail/fast_float/compute_float80_128.hpp b/include/boost/decimal/detail/fast_float/compute_float80_128.hpp
@@ -152,10 +152,8 @@ constexpr auto compute_float80_128(std::int64_t q, const Unsigned_Integer &w,
 
     if (BOOST_DECIMAL_UNLIKELY(ld == std::numeric_limits<long double>::infinity()))
     {
-        // LCOV_EXCL_START
         success = false;
         ld = 0.0L;
-        // LCOV_EXCL_STOP
     }
 
     return ld;
diff --git a/include/boost/decimal/detail/fenv_rounding.hpp b/include/boost/decimal/detail/fenv_rounding.hpp
@@ -229,7 +229,7 @@ constexpr auto coefficient_rounding(T1& coeff, T2& exp, T3& biased_exp, const bo
         if (coeff < std::numeric_limits<demoted_integer_type>::max())
         {
             const auto smaller_coeff {static_cast<demoted_integer_type>(coeff)};
-            const auto div_res {impl::divmod(smaller_coeff, static_cast<demoted_integer_type>(shift_pow_ten))}; // LCOV_EXCL_LINE : False negative since above and below are hit
+            const auto div_res {impl::divmod(smaller_coeff, static_cast<demoted_integer_type>(shift_pow_ten))};
             shifted_coeff = static_cast<demoted_integer_type>(div_res.quotient);
             const auto trailing_digits {div_res.remainder};
             sticky = trailing_digits != 0U;
diff --git a/include/boost/decimal/detail/io.hpp b/include/boost/decimal/detail/io.hpp
@@ -51,7 +51,6 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)
 
     if (BOOST_DECIMAL_UNLIKELY(t_buffer_len > static_buffer_size))
     {
-        // LCOV_EXCL_START
         longer_char_buffer = std::unique_ptr<char[]>(new(std::nothrow) char[t_buffer_len]);
         if (longer_char_buffer.get() == nullptr)
         {
@@ -60,7 +59,6 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)
         }
 
         buffer = longer_char_buffer.get();
-        // LCOV_EXCL_STOP
     }
 
     BOOST_DECIMAL_IF_CONSTEXPR (!std::is_same<charT, char>::value)
@@ -108,7 +106,7 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)
 
     if (BOOST_DECIMAL_UNLIKELY(r.ec == std::errc::not_supported))
     {
-        d = std::numeric_limits<DecimalType>::signaling_NaN(); // LCOV_EXCL_LINE
+        d = std::numeric_limits<DecimalType>::signaling_NaN();
     }
     else if (static_cast<int>(r.ec) == EINVAL)
     {
@@ -166,7 +164,7 @@ auto operator<<(std::basic_ostream<charT, traits>& os, const DecimalType& d)
 
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
-        errno = static_cast<int>(r.ec); // LCOV_EXCL_LINE
+        errno = static_cast<int>(r.ec);
     }
 
     *r.ptr = '\0';
diff --git a/include/boost/decimal/detail/parser.hpp b/include/boost/decimal/detail/parser.hpp
@@ -286,13 +286,10 @@ constexpr auto parser(const char* first, const char* last, bool& sign, Unsigned_
         const from_chars_result r {from_chars_dispatch(significand_buffer, significand_buffer + offset, significand, base)};
         switch (r.ec)
         {
-            // The two invalid cases are here for completeness, but I don't think we can actually hit them
-            // LCOV_EXCL_START
             case std::errc::invalid_argument:
                 return {first, std::errc::invalid_argument};
             case std::errc::result_out_of_range:
                 return {next, std::errc::result_out_of_range};
-            // LCOV_EXCL_STOP
             default:
                 return {next, std::errc()};
         }
@@ -372,11 +369,8 @@ constexpr auto parser(const char* first, const char* last, bool& sign, Unsigned_
         const from_chars_result r {from_chars_dispatch(significand_buffer, significand_buffer + offset, significand, base)};
         switch (r.ec)
         {
-            // Out of range included for completeness, but I don't think we can actually reach it
-            // LCOV_EXCL_START
             case std::errc::result_out_of_range:
                 return {next, std::errc::result_out_of_range};
-            // LCOV_EXCL_STOP
             case std::errc::invalid_argument:
                 return {first, std::errc::invalid_argument};
             default:
@@ -418,12 +412,10 @@ constexpr auto parser(const char* first, const char* last, bool& sign, Unsigned_
             from_chars_result r = from_chars_dispatch(significand_buffer, significand_buffer + offset, significand, base);
             switch (r.ec)
             {
-                // LCOV_EXCL_START
                 case std::errc::invalid_argument:
                     return {first, std::errc::invalid_argument};
                 case std::errc::result_out_of_range:
                     return {next, std::errc::result_out_of_range};
-                // LCOV_EXCL_STOP
                 default:
                     break;
             }
diff --git a/include/boost/decimal/detail/to_float.hpp b/include/boost/decimal/detail/to_float.hpp
@@ -94,10 +94,8 @@ BOOST_DECIMAL_CXX20_CONSTEXPR auto to_float(Decimal val) noexcept
 
     if (BOOST_DECIMAL_UNLIKELY(!success))
     {
-        // LCOV_EXCL_START
         errno = EINVAL;
         return 0;
-        // LCOV_EXCL_STOP
     }
 
     return result;
diff --git a/include/boost/decimal/dpd_conversion.hpp b/include/boost/decimal/dpd_conversion.hpp
@@ -761,7 +761,7 @@ constexpr auto to_dpd_d128(const DecimalType val) noexcept
         temp_sig /= 10U;
     }
     BOOST_DECIMAL_ASSERT(d[0] >= 0 && d[0] <= 9);
-    BOOST_DECIMAL_ASSERT(temp_sig == 0U); // LCOV_EXCL_LINE : False Negative
+    BOOST_DECIMAL_ASSERT(temp_sig == 0U);
 
     constexpr std::uint64_t leading_two_exp_bits_mask {0b11000000000000};
     const auto leading_two_bits {(exp & leading_two_exp_bits_mask) >> 12U};
@@ -778,14 +778,12 @@ constexpr auto to_dpd_d128(const DecimalType val) noexcept
         const auto d0_is_nine {d[0] == 9};
         switch (leading_two_bits)
         {
-            // LCOV_EXCL_START
             // The decimal128_t case never uses the combination field like the other types,
             // since the significand always fits inside the allotted number of bits.
             // I don't believe this path will ever be taken, but it's correct
             case 0U:
                 combination_field_bits = d0_is_nine ? 0b11001 : 0b11000;
                 break;
-            // LCOV_EXCL_STOP
             case 1U:
                 combination_field_bits = d0_is_nine ? 0b11011 : 0b11010;
                 break;

Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ constexpr auto to_chars_nonfinite(char* first, char* last, const TargetDecimalTy`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
`193`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE : Should be unreachable`
	`193`	`+ return {last, std::errc::value_too_large};`
`194`	`194`	`case FP_NAN:`
`195`	`195`	`if (issignaling(value) && buffer_len >= 9)`
`196`	`196`	`{`
`@@ -238,7 +238,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`238`	`238`	`// Dummy check the bounds`
`239`	`239`	`if (BOOST_DECIMAL_UNLIKELY(buffer_size < real_precision))`
`240`	`240`	`{`
`241`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE`
	`241`	`+ return {last, std::errc::value_too_large};`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`using uint_type = std::conditional_t<(std::numeric_limits<typename TargetDecimalType::significand_type>::digits >`
`@@ -253,7 +253,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`253`	`253`	`// which we have already checked for`
`254`	`254`	`if (BOOST_DECIMAL_UNLIKELY(!r))`
`255`	`255`	`{`
`256`		`- return r; // LCOV_EXCL_LINE`
	`256`	`+ return r;`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`auto current_digits {r.ptr - (first + 1)};`
`@@ -273,7 +273,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`273`	`273`	`const auto total_length {total_buffer_length<TargetDecimalType>(static_cast<int>(current_digits), exp, is_neg)};`
`274`	`274`	`if (BOOST_DECIMAL_UNLIKELY(total_length > buffer_size))`
`275`	`275`	`{`
`276`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE`
	`276`	`+ return {last, std::errc::value_too_large};`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`// Insert our decimal point (or don't in the 1 digit case)`
`@@ -309,7 +309,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`309`	`309`
`310`	`310`	`if (BOOST_DECIMAL_UNLIKELY(!exp_r))`
`311`	`311`	`{`
`312`		`- return exp_r; // LCOV_EXCL_LINE`
	`312`	`+ return exp_r;`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`return {exp_r.ptr, std::errc{}};`
`@@ -374,7 +374,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`374`	`374`	`}`
`375`	`375`	`else if (significand_digits > local_precision + 1)`
`376`	`376`	`{`
`377`		`- const auto original_sig = significand; // LCOV_EXCL_LINE : False negative`
	`377`	`+ const auto original_sig = significand;`
`378`	`378`	`fenv_round<TargetDecimalType>(significand);`
`379`	`379`	`if (remove_trailing_zeros(original_sig + 1U).trimmed_number == 1U)`
`380`	`380`	`{`
`@@ -406,7 +406,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`406`	`406`	`// Only real reason we will hit this is a buffer overflow`
`407`	`407`	`if (BOOST_DECIMAL_UNLIKELY(!r))`
`408`	`408`	`{`
`409`		`- return r; // LCOV_EXCL_LINE`
	`409`	`+ return r;`
`410`	`410`	`}`
`411`	`411`
`412`	`412`	`const auto current_digits = r.ptr - (first + 1) - 1;`
`@@ -478,7 +478,7 @@ constexpr auto to_chars_scientific_impl(char* first, char* last, const TargetDec`
`478`	`478`	`r = to_chars_integer_impl<int>(first, last, abs_exp);`
`479`	`479`	`if (BOOST_DECIMAL_UNLIKELY(!r))`
`480`	`480`	`{`
`481`		`- return r; // LCOV_EXCL_LINE`
	`481`	`+ return r;`
`482`	`482`	`}`
`483`	`483`
`484`	`484`	`return {r.ptr, std::errc()};`
`@@ -520,7 +520,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT`
`520`	`520`
`521`	`521`	`if (BOOST_DECIMAL_UNLIKELY(!r))`
`522`	`522`	`{`
`523`		`- return r; // LCOV_EXCL_LINE`
	`523`	`+ return r;`
`524`	`524`	`}`
`525`	`525`
`526`	`526`	`const auto num_digits {r.ptr - current};`
`@@ -536,7 +536,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT`
`536`	`536`	`{`
`537`	`537`	`if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + num_digits + exp))`
`538`	`538`	`{`
`539`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE`
	`539`	`+ return {last, std::errc::value_too_large};`
`540`	`540`	`}`
`541`	`541`
`542`	`542`	`detail::memset(r.ptr, '0', static_cast<std::size_t>(exp));`
`@@ -546,7 +546,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT`
`546`	`546`	`{`
`547`	`547`	`if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + num_digits + 1))`
`548`	`548`	`{`
`549`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE`
	`549`	`+ return {last, std::errc::value_too_large};`
`550`	`550`	`}`
`551`	`551`
`552`	`552`	`const auto decimal_pos {num_digits - abs_exp};`
`@@ -560,7 +560,7 @@ constexpr auto to_chars_fixed_impl(char* first, char* last, const TargetDecimalT`
`560`	`560`	`const auto leading_zeros {abs_exp - num_digits};`
`561`	`561`	`if (BOOST_DECIMAL_UNLIKELY(buffer_size < (current - first) + 2 + leading_zeros + num_digits))`
`562`	`562`	`{`
`563`		`- return {last, std::errc::value_too_large}; // LCOV_EXCL_LINE`
	`563`	`+ return {last, std::errc::value_too_large};`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`detail::memmove(current + 2 + leading_zeros, current, static_cast<std::size_t>(num_digits));`
Original file line number	Diff line number	Diff line change
`@@ -216,10 +216,8 @@ inline auto snprintf_impl(char* buffer, const std::size_t buf_size, const char*`
`216`	`216`
`217`	`217`	`if (!r)`
`218`	`218`	`{`
`219`		`- // LCOV_EXCL_START`
`220`	`219`	`errno = static_cast<int>(r.ec);`
`221`	`220`	`return -1;`
`222`		`- // LCOV_EXCL_STOP`
`223`	`221`	`}`
`224`	`222`
`225`	`223`	`// Adjust the capitalization and locale`
`@@ -287,7 +285,6 @@ inline auto fprintf(std::FILE* buffer, const char* format, const T... values) no`
`287`	`285`	`}`
`288`	`286`	`else`
`289`	`287`	`{`
`290`		`- // LCOV_EXCL_START`
`291`	`288`	`// Add 50% overage in case we need to do locale conversion`
`292`	`289`	`std::unique_ptr<char[]> longer_char_buffer(new(std::nothrow) char[(3 * (format_len + value_space + 1)) / 2]);`
`293`	`290`	`if (longer_char_buffer == nullptr)`
`@@ -301,7 +298,6 @@ inline auto fprintf(std::FILE* buffer, const char* format, const T... values) no`
`301`	`298`	`{`
`302`	`299`	`bytes += static_cast<int>(std::fwrite(longer_char_buffer.get(), sizeof(char), static_cast<std::size_t>(bytes), buffer));`
`303`	`300`	`}`
`304`		`- // LCOV_EXCL_STOP`
`305`	`301`	`}`
`306`	`302`
`307`	`303`	`return bytes;`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ inline auto strtod_calculation(const char* str, char** endptr, char* buffer, con`
`73`	`73`	`{`
`74`	`74`	`if (significand)`
`75`	`75`	`{`
`76`		`- d = std::numeric_limits<TargetDecimalType>::signaling_NaN(); // LCOV_EXCL_LINE : False negative`
	`76`	`+ d = std::numeric_limits<TargetDecimalType>::signaling_NaN();`
`77`	`77`	`}`
`78`	`78`	`else`
`79`	`79`	`{`
`@@ -125,11 +125,8 @@ inline auto strtod_impl(const char* str, char** endptr) noexcept -> TargetDecima`
`125`	`125`	`std::unique_ptr<char[]> buffer(new(std::nothrow) char[str_length + 1]);`
`126`	`126`	`if (buffer == nullptr)`
`127`	`127`	`{`
`128`		`- // Hard to get coverage on memory exhaustion`
`129`		`- // LCOV_EXCL_START`
`130`	`128`	`errno = ENOMEM;`
`131`	`129`	`return std::numeric_limits<TargetDecimalType>::quiet_NaN();`
`132`		`- // LCOV_EXCL_STOP`
`133`	`130`	`}`
`134`	`131`
`135`	`132`	`auto d = strtod_calculation<TargetDecimalType>(str, endptr, buffer.get(), str_length);`
`@@ -148,7 +145,7 @@ inline auto wcstod_calculation(const wchar_t* str, wchar_t** endptr, char* buffe`
`148`	`145`	`if (BOOST_DECIMAL_UNLIKELY(val > 255))`
`149`	`146`	`{`
`150`	`147`	`// Character can not be converted`
`151`		`- return std::numeric_limits<TargetDecimalType>::quiet_NaN(); // LCOV_EXCL_LINE`
	`148`	`+ return std::numeric_limits<TargetDecimalType>::quiet_NaN();`
`152`	`149`	`}`
`153`	`150`
`154`	`151`	`buffer[i] = static_cast<char>(val);`
`@@ -188,11 +185,8 @@ inline auto wcstod_impl(const wchar_t* str, wchar_t** endptr) noexcept -> Target`
`188`	`185`	`std::unique_ptr<char[]> buffer(new(std::nothrow) char[str_length + 1]);`
`189`	`186`	`if (buffer == nullptr)`
`190`	`187`	`{`
`191`		`- // Hard to get coverage on memory exhaustion`
`192`		`- // LCOV_EXCL_START`
`193`	`188`	`errno = ENOMEM;`
`194`	`189`	`return std::numeric_limits<TargetDecimalType>::quiet_NaN();`
`195`		`- // LCOV_EXCL_STOP`
`196`	`190`	`}`
`197`	`191`
`198`	`192`	`return wcstod_calculation<TargetDecimalType>(str, endptr, buffer.get(), str_length);`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ constexpr auto atan_impl(const T x) noexcept`
`48`	`48`	`#ifndef BOOST_DECIMAL_FAST_MATH`
`49`	`49`	`else if (fpc == FP_INFINITE)`
`50`	`50`	`{`
`51`		`- result = my_pi_half; // LCOV_EXCL_LINE False negative`
	`51`	`+ result = my_pi_half;`
`52`	`52`	`}`
`53`	`53`	`#endif`
`54`	`54`	`else`
Original file line number	Diff line number	Diff line change
`@@ -50,15 +50,15 @@ constexpr auto tgamma_impl(const T x) noexcept`
`50`	`50`	`}`
`51`	`51`	`else`
`52`	`52`	`{`
`53`		`- result = x; // LCOV_EXCL_LINE : False negative`
	`53`	`+ result = x;`
`54`	`54`	`}`
`55`	`55`	`#endif`
`56`	`56`	`}`
`57`	`57`	`else if (is_pure_int && is_neg)`
`58`	`58`	`{`
`59`	`59`	`// Pure negative integer argument.`
`60`	`60`	`#ifndef BOOST_DECIMAL_FAST_MATH`
`61`		`- result = std::numeric_limits<T>::quiet_NaN(); // LCOV_EXCL_LINE : False negative`
	`61`	`+ result = std::numeric_limits<T>::quiet_NaN();`
`62`	`62`	`#else`
`63`	`63`	`result = T{0};`
`64`	`64`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -152,10 +152,8 @@ constexpr auto compute_float80_128(std::int64_t q, const Unsigned_Integer &w,`
`152`	`152`
`153`	`153`	`if (BOOST_DECIMAL_UNLIKELY(ld == std::numeric_limits<long double>::infinity()))`
`154`	`154`	`{`
`155`		`- // LCOV_EXCL_START`
`156`	`155`	`success = false;`
`157`	`156`	`ld = 0.0L;`
`158`		`- // LCOV_EXCL_STOP`
`159`	`157`	`}`
`160`	`158`
`161`	`159`	`return ld;`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ constexpr auto coefficient_rounding(T1& coeff, T2& exp, T3& biased_exp, const bo`
`229`	`229`	`if (coeff < std::numeric_limits<demoted_integer_type>::max())`
`230`	`230`	`{`
`231`	`231`	`const auto smaller_coeff {static_cast<demoted_integer_type>(coeff)};`
`232`		`- const auto div_res {impl::divmod(smaller_coeff, static_cast<demoted_integer_type>(shift_pow_ten))}; // LCOV_EXCL_LINE : False negative since above and below are hit`
	`232`	`+ const auto div_res {impl::divmod(smaller_coeff, static_cast<demoted_integer_type>(shift_pow_ten))};`
`233`	`233`	`shifted_coeff = static_cast<demoted_integer_type>(div_res.quotient);`
`234`	`234`	`const auto trailing_digits {div_res.remainder};`
`235`	`235`	`sticky = trailing_digits != 0U;`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)`
`51`	`51`
`52`	`52`	`if (BOOST_DECIMAL_UNLIKELY(t_buffer_len > static_buffer_size))`
`53`	`53`	`{`
`54`		`- // LCOV_EXCL_START`
`55`	`54`	`longer_char_buffer = std::unique_ptr<char[]>(new(std::nothrow) char[t_buffer_len]);`
`56`	`55`	`if (longer_char_buffer.get() == nullptr)`
`57`	`56`	`{`
`@@ -60,7 +59,6 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)`
`60`	`59`	`}`
`61`	`60`
`62`	`61`	`buffer = longer_char_buffer.get();`
`63`		`- // LCOV_EXCL_STOP`
`64`	`62`	`}`
`65`	`63`
`66`	`64`	`BOOST_DECIMAL_IF_CONSTEXPR (!std::is_same<charT, char>::value)`
`@@ -108,7 +106,7 @@ auto operator>>(std::basic_istream<charT, traits>& is, DecimalType& d)`
`108`	`106`
`109`	`107`	`if (BOOST_DECIMAL_UNLIKELY(r.ec == std::errc::not_supported))`
`110`	`108`	`{`
`111`		`- d = std::numeric_limits<DecimalType>::signaling_NaN(); // LCOV_EXCL_LINE`
	`109`	`+ d = std::numeric_limits<DecimalType>::signaling_NaN();`
`112`	`110`	`}`
`113`	`111`	`else if (static_cast<int>(r.ec) == EINVAL)`
`114`	`112`	`{`
`@@ -166,7 +164,7 @@ auto operator<<(std::basic_ostream<charT, traits>& os, const DecimalType& d)`
`166`	`164`
`167`	`165`	`if (BOOST_DECIMAL_UNLIKELY(!r))`
`168`	`166`	`{`
`169`		`- errno = static_cast<int>(r.ec); // LCOV_EXCL_LINE`
	`167`	`+ errno = static_cast<int>(r.ec);`
`170`	`168`	`}`
`171`	`169`
`172`	`170`	`*r.ptr = '\0';`
Original file line number	Diff line number	Diff line change
`@@ -94,10 +94,8 @@ BOOST_DECIMAL_CXX20_CONSTEXPR auto to_float(Decimal val) noexcept`
`94`	`94`
`95`	`95`	`if (BOOST_DECIMAL_UNLIKELY(!success))`
`96`	`96`	`{`
`97`		`- // LCOV_EXCL_START`
`98`	`97`	`errno = EINVAL;`
`99`	`98`	`return 0;`
`100`		`- // LCOV_EXCL_STOP`
`101`	`99`	`}`
`102`	`100`
`103`	`101`	`return result;`