Assert on NaN, -NaN, Inf, -Inf (#39)

* Patch: Fix a bug where one could assign Nan, Inf or -Inf to a float64 metric.

NEWS.rst

@@ -6,7 +6,7 @@ every change, see the Git log.
 
 Latest
 ------
-* tbd
+* Patch: Fix a bug where one could assign Nan, Inf or -Inf to a float64 metric.
 
 6.0.0
 -----

src/abacus/metric.hpp

@@ -6,6 +6,7 @@
 #pragma once
 
 #include <cassert>
+#include <cmath>
 #include <cstdint>
 
 #include "type.hpp"
@@ -220,6 +221,15 @@ class metric<abacus::type::float64>
     auto operator=(double value) -> metric<abacus::type::float64>&
     {
         assert(is_initialized());
+        // We don't allow assignment to NaN or Inf/-Inf
+        assert(!std::isnan(value) && "Cannot assign a "
+                                     "NaN "
+                                     "value to a "
+                                     "float metric");
+        assert(!std::isinf(value) && "Cannot assign an "
+                                     "Inf/-Inf "
+                                     "value to a "
+                                     "float metric");
         *m_memory = value;
         return *this;
     }
@@ -230,6 +240,15 @@ class metric<abacus::type::float64>
     auto operator+=(double value) -> metric<abacus::type::float64>&
     {
         assert(is_initialized());
+        // We don't allow assignment to NaN or Inf/-Inf
+        assert(!std::isnan(value) && "Cannot assign a "
+                                     "NaN "
+                                     "value to a "
+                                     "float metric");
+        assert(!std::isinf(value) && "Cannot assign an "
+                                     "Inf/-Inf "
+                                     "value to a "
+                                     "float metric");
         *m_memory += value;
         return *this;
     }
@@ -240,6 +259,16 @@ class metric<abacus::type::float64>
     auto operator-=(double value) -> metric<abacus::type::float64>&
     {
         assert(is_initialized());
+        // We don't allow assignment to NaN or Inf/-Inf
+        assert(!std::isnan(value) && "Cannot assign a "
+                                     "NaN "
+                                     "value to a "
+                                     "float metric");
+        assert(!std::isinf(value) && "Cannot assign an "
+                                     "Inf/-Inf "
+                                     "value to a "
+                                     "float metric");
+
         *m_memory -= value;
         return *this;
     }

test/src/test_metric.cpp

@@ -3,6 +3,11 @@
 //
 // Distributed under the "BSD License". See the accompanying LICENSE.rst file.
 
+// Pragma needed to be able to compile code, that divides by literal zero with
+// MSVC
+#pragma fenv_access(on)
+
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <gtest/gtest.h>
@@ -28,3 +33,41 @@ TEST(test_metric, constructor)
     abacus::metric<abacus::type::boolean> bool_metric(&bool_count);
     EXPECT_TRUE(bool_metric.is_initialized());
 }
+
+TEST(test_metric, float_assignment)
+{
+    double double_count = 1123.12;
+    abacus::metric<abacus::type::float64> double_metric(&double_count);
+    EXPECT_TRUE(double_metric.is_initialized());
+    EXPECT_DOUBLE_EQ(double_metric.value(), 1123.12);
+
+    // Assignment
+    // Check that assignment to NaN is not allowed
+    EXPECT_DEATH(double_metric = 0.0 / 0.0, "");
+    // Check that that assignment to -NaN is not allowed
+    EXPECT_DEATH(double_metric = -0.0 / 0.0, "");
+    // Check that that assignment to +Inf is not allowed
+    EXPECT_DEATH(double_metric = 1 / 0.0, "");
+    // Check that that assignment to -Inf is not allowed
+    EXPECT_DEATH(double_metric = 1 / -0.0, "");
+
+    // Add and Assign
+    // Check that assignment to NaN is not allowed
+    EXPECT_DEATH(double_metric += 0.0 / 0.0, "");
+    // Check that that assignment to -NaN is not allowed
+    EXPECT_DEATH(double_metric += -0.0 / 0.0, "");
+    // Check that that assignment to +Inf is not allowed
+    EXPECT_DEATH(double_metric += 1 / 0.0, "");
+    // Check that that assignment to -Inf is not allowed
+    EXPECT_DEATH(double_metric += 1 / -0.0, "");
+
+    // Subtract and Assign
+    // Check that assignment to NaN is not allowed
+    EXPECT_DEATH(double_metric -= 0.0 / 0.0, "");
+    // Check that that assignment to -NaN is not allowed
+    EXPECT_DEATH(double_metric -= -0.0 / 0.0, "");
+    // Check that that assignment to +Inf is not allowed
+    EXPECT_DEATH(double_metric -= 1 / 0.0, "");
+    // Check that that assignment to -Inf is not allowed
+    EXPECT_DEATH(double_metric -= 1 / -0.0, "");
+}