🔨 small refactoring to improve branch coverage

The branch coverage reported by lcov is weird. The code before and after has the same Godbolt assembler, but the code with the lambda has a better branch coverage.

🔨 small refactoring to improve branch coverage
ed6a0686 · Niels Lohmann · c8bfdfd9 · ed6a0686 · ed6a0686
Unverified Commit ed6a0686 authored Jun 23, 2018 by Niels Lohmann
Hide whitespace changes
Inline Side-by-side

Showing with 34 additions and 30 deletions

binary_reader.hpp include/nlohmann/detail/input/binary_reader.hpp +17 -15

json.hpp single_include/nlohmann/json.hpp +17 -15

No files found.
--- a/include/nlohmann/detail/input/binary_reader.hpp
+++ b/include/nlohmann/detail/input/binary_reader.hpp
@@ -408,22 +408,24 @@ class binary_reader
                // half-precision floating-point numbers in the C language
                // is shown in Fig. 3.
                const int half = (byte1 << 8) + byte2;
-                const int exp = (half >> 10) & 0x1F;
+                const double val = [&half]
-                const int mant = half & 0x3FF;
-                double val;
-                if (exp == 0)
                {
-                    val = std::ldexp(mant, -24);
+                    const int exp = (half >> 10) & 0x1F;
-                }
+                    const int mant = half & 0x3FF;
-                else if (exp != 31)
+                    assert(0 <= exp and exp <= 32);
-                {
+                    assert(0 <= mant and mant <= 1024);
-                    val = std::ldexp(mant + 1024, exp - 25);
+                    switch (exp)
-                }
+                    {
-                else
+                        case 0:
-                {
+                            return std::ldexp(mant, -24);
-                    val = (mant == 0) ? std::numeric_limits<double>::infinity()
+                        case 31:
-                          : std::numeric_limits<double>::quiet_NaN();
+                            return (mant == 0)
-                }
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
                return sax->number_float((half & 0x8000) != 0
                                         ? static_cast<number_float_t>(-val)
                                         : static_cast<number_float_t>(val), "");

--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -6041,22 +6041,24 @@ class binary_reader
                // half-precision floating-point numbers in the C language
                // is shown in Fig. 3.
                const int half = (byte1 << 8) + byte2;
-                const int exp = (half >> 10) & 0x1F;
+                const double val = [&half]
-                const int mant = half & 0x3FF;
-                double val;
-                if (exp == 0)
                {
-                    val = std::ldexp(mant, -24);
+                    const int exp = (half >> 10) & 0x1F;
-                }
+                    assert(0 <= exp and exp <= 32);
-                else if (exp != 31)
+                    const int mant = half & 0x3FF;
-                {
+                    assert(0 <= mant and mant <= 1024);
-                    val = std::ldexp(mant + 1024, exp - 25);
+                    switch (exp)
-                }
+                    {
-                else
+                        case 0:
-                {
+                            return std::ldexp(mant, -24);
-                    val = (mant == 0) ? std::numeric_limits<double>::infinity()
+                        case 31:
-                          : std::numeric_limits<double>::quiet_NaN();
+                            return (mant == 0)
-                }
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
                return sax->number_float((half & 0x8000) != 0
                                         ? static_cast<number_float_t>(-val)
                                         : static_cast<number_float_t>(val), "");