Implementing Property Based Tesing using Hypothesis

tests/unit/test_expression_tree/test_averages.py

@@ -5,29 +5,32 @@
 import numpy as np
 import pybamm
 from tests import assert_domain_equal
+from hypothesis import strategies as st
+from hypothesis import given
 
 
 class TestUnaryOperators:
-    def test_x_average(self):
-        a = pybamm.Scalar(4)
+    @given(st.integers())
+    def test_x_average(self, random_value):
+        a = pybamm.Scalar(random_value)
         average_a = pybamm.x_average(a)
         assert average_a == a
 
         # average of a broadcast is the child
         average_broad_a = pybamm.x_average(
             pybamm.PrimaryBroadcast(a, ["negative electrode"])
         )
-        assert average_broad_a == pybamm.Scalar(4)
+        assert average_broad_a == pybamm.Scalar(random_value)
 
         # average of a number times a broadcast is the number times the child
         average_two_broad_a = pybamm.x_average(
             2 * pybamm.PrimaryBroadcast(a, ["negative electrode"])
         )
-        assert average_two_broad_a == pybamm.Scalar(8)
+        assert average_two_broad_a == pybamm.Scalar(2 * random_value)
         average_t_broad_a = pybamm.x_average(
             pybamm.t * pybamm.PrimaryBroadcast(a, ["negative electrode"])
         )
-        assert average_t_broad_a == (pybamm.t * pybamm.Scalar(4))
+        assert average_t_broad_a == (pybamm.t * random_value)
 
         # full broadcasts
         average_broad_a = pybamm.x_average(
@@ -174,9 +177,10 @@ def test_x_average(self):
         assert pybamm.x_average(a + b) == pybamm.x_average(a) + pybamm.x_average(b)
         assert pybamm.x_average(a - b) == pybamm.x_average(a) - pybamm.x_average(b)
 
-    def test_size_average(self):
+    @given(st.integers(min_value=-(2**63), max_value=2**63 - 1))
+    def test_size_average(self, random_value):
         # no domain
-        a = pybamm.Scalar(1)
+        a = pybamm.Scalar(random_value)
         average_a = pybamm.size_average(a)
         assert average_a == a
 
@@ -193,7 +197,7 @@ def test_size_average(self):
         average_a = pybamm.size_average(
             pybamm.PrimaryBroadcast(a, "negative particle size")
         )
-        assert average_a.evaluate() == np.array([1])
+        assert average_a.evaluate() == np.array([random_value])
 
         a = pybamm.Symbol("a", domain="negative particle")
         average_a = pybamm.size_average(
@@ -267,8 +271,9 @@ def test_r_average(self):
         assert pybamm.r_average(a + b) == pybamm.r_average(a) + pybamm.r_average(b)
         assert pybamm.r_average(a - b) == pybamm.r_average(a) - pybamm.r_average(b)
 
-    def test_yz_average(self):
-        a = pybamm.Scalar(1)
+    @given(st.integers(min_value=-(2**63), max_value=2**63 - 1))
+    def test_yz_average(self, random_value):
+        a = pybamm.Scalar(random_value)
         z_average_a = pybamm.z_average(a)
         yz_average_a = pybamm.yz_average(a)
         assert z_average_a == a
@@ -280,8 +285,8 @@ def test_yz_average(self):
         yz_average_broad_a = pybamm.yz_average(
             pybamm.PrimaryBroadcast(a, ["current collector"])
         )
-        assert z_average_broad_a.evaluate() == np.array([1])
-        assert yz_average_broad_a.evaluate() == np.array([1])
+        assert z_average_broad_a.evaluate() == np.array([random_value])
+        assert yz_average_broad_a.evaluate() == np.array([random_value])
 
         a = pybamm.Variable("a", domain=["current collector"])
         y = pybamm.SpatialVariable("y", ["current collector"])

tests/unit/test_expression_tree/test_unary_operators.py

@@ -9,6 +9,8 @@
 from sympy.vector.operators import Divergence as sympy_Divergence
 from sympy.vector.operators import Gradient as sympy_Gradient
 from tests import assert_domain_equal
+from hypothesis import strategies as st
+from hypothesis import given, settings, HealthCheck
 
 import pybamm
 
@@ -25,15 +27,17 @@ def test_unary_operator(self):
         absval = pybamm.AbsoluteValue(-a)
         assert absval.evaluate(inputs={"a": 10}) == 10
 
-    def test_negation(self, mocker):
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    @given(random_value=st.floats(min_value=-1e3, max_value=1e3))
+    def test_negation(self, mocker, random_value):
         a = pybamm.Symbol("a")
         nega = pybamm.Negate(a)
         assert nega.name == "-"
         assert nega.children[0].name == a.name
 
-        b = pybamm.Scalar(4)
+        b = pybamm.Scalar(random_value)
         negb = pybamm.Negate(b)
-        assert negb.evaluate() == -4
+        assert negb.evaluate() == -random_value
 
         # Test broadcast gets switched
         broad_a = pybamm.PrimaryBroadcast(a, "test")
@@ -65,15 +69,17 @@ def test_negation(self, mocker):
         }
         assert pybamm.Negate._from_json(input_json) == nega
 
-    def test_absolute(self, mocker):
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    @given(random_value=st.floats(min_value=-1e3, max_value=1e3))
+    def test_absolute(self, mocker, random_value):
         a = pybamm.Symbol("a")
         absa = pybamm.AbsoluteValue(a)
         assert absa.name == "abs"
         assert absa.children[0].name == a.name
 
-        b = pybamm.Scalar(-4)
+        b = pybamm.Scalar(-random_value)
         absb = pybamm.AbsoluteValue(b)
-        assert absb.evaluate() == 4
+        assert absb.evaluate() == abs(random_value)
 
         # Test broadcast gets switched
         broad_a = pybamm.PrimaryBroadcast(a, "test")
@@ -116,17 +122,23 @@ def test_smooth_absolute_value(self):
             "/ (exp(10.0 * y[0:1]) + exp(-10.0 * y[0:1]))"
         )
 
-    def test_sign(self):
-        b = pybamm.Scalar(-4)
+    @given(
+        random_value=st.integers(),
+        random_matrix=st.lists(
+            st.floats(min_value=-10, max_value=10), min_size=5, max_size=5
+        ),
+    )
+    def test_sign(self, random_value, random_matrix):
+        b = pybamm.Scalar(random_value)
         signb = pybamm.sign(b)
-        assert signb.evaluate() == -1
+        assert signb.evaluate() == -1 if random_value < 0 else 1
 
-        A = diags(np.linspace(-1, 1, 5))
+        A = diags(random_matrix)
         b = pybamm.Matrix(A)
         signb = pybamm.sign(b)
-        np.testing.assert_array_equal(
-            np.diag(signb.evaluate().toarray()), [-1, -1, 0, 1, 1]
-        )
+        evaluated_sign = signb.evaluate().toarray()
+        expected_sign = np.sign(np.diag(A.toarray()))
+        np.testing.assert_array_equal(np.diag(evaluated_sign), expected_sign)
 
         broad = pybamm.PrimaryBroadcast(-4, "test domain")
         assert pybamm.sign(broad) == pybamm.PrimaryBroadcast(-1, "test domain")
@@ -138,7 +150,7 @@ def test_sign(self):
         )
 
         # Test from_json
-        c = pybamm.Multiplication(pybamm.Variable("a"), pybamm.Scalar(3))
+        c = pybamm.Multiplication(pybamm.Variable("a"), pybamm.Scalar(random_value))
         sign_json = {
             "name": "sign",
             "id": 5341515228900508018,
@@ -153,19 +165,24 @@ def test_sign(self):
 
         assert pybamm.sign(c) == pybamm.Sign._from_json(sign_json)
 
-    def test_floor(self, mocker):
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    @given(
+        random_value1=st.floats(min_value=-1e3, max_value=1e3),
+        random_value2=st.floats(min_value=-1e3, max_value=1e3),
+    )
+    def test_floor(self, mocker, random_value1, random_value2):
         a = pybamm.Symbol("a")
         floora = pybamm.Floor(a)
         assert floora.name == "floor"
         assert floora.children[0].name == a.name
 
-        b = pybamm.Scalar(3.5)
+        b = pybamm.Scalar(random_value1)
         floorb = pybamm.Floor(b)
-        assert floorb.evaluate() == 3
+        assert floorb.evaluate() == np.floor(random_value1)
 
-        c = pybamm.Scalar(-3.2)
+        c = pybamm.Scalar(random_value2)
         floorc = pybamm.Floor(c)
-        assert floorc.evaluate() == -4
+        assert floorc.evaluate() == np.floor(random_value2)
 
         # Test from_json
         input_json = {
@@ -181,19 +198,24 @@ def test_floor(self, mocker):
         }
         assert pybamm.Floor._from_json(input_json) == floora
 
-    def test_ceiling(self, mocker):
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    @given(
+        random_value1=st.floats(min_value=-1e3, max_value=1e3),
+        random_value2=st.floats(min_value=-1e3, max_value=1e3),
+    )
+    def test_ceiling(self, mocker, random_value1, random_value2):
         a = pybamm.Symbol("a")
         ceila = pybamm.Ceiling(a)
         assert ceila.name == "ceil"
         assert ceila.children[0].name == a.name
 
-        b = pybamm.Scalar(3.5)
+        b = pybamm.Scalar(random_value1)
         ceilb = pybamm.Ceiling(b)
-        assert ceilb.evaluate() == 4
+        assert ceilb.evaluate() == np.ceil(random_value1)
 
-        c = pybamm.Scalar(-3.2)
+        c = pybamm.Scalar(random_value2)
         ceilc = pybamm.Ceiling(c)
-        assert ceilc.evaluate() == -3
+        assert ceilc.evaluate() == np.ceil(random_value2)
 
         # Test from_json
         input_json = {
@@ -209,7 +231,8 @@ def test_ceiling(self, mocker):
         }
         assert pybamm.Ceiling._from_json(input_json) == ceila
 
-    def test_gradient(self):
+    @given(st.integers())
+    def test_gradient(self, random_value):
         # gradient of scalar symbol should fail
         a = pybamm.Symbol("a")
         with pytest.raises(
@@ -219,7 +242,7 @@ def test_gradient(self):
             pybamm.Gradient(a)
 
         # gradient of variable evaluating on edges should fail
-        a = pybamm.PrimaryBroadcastToEdges(pybamm.Scalar(1), "test")
+        a = pybamm.PrimaryBroadcastToEdges(pybamm.Scalar(random_value), "test")
         with pytest.raises(TypeError, match="evaluates on edges"):
             pybamm.Gradient(a)
 
@@ -240,7 +263,8 @@ def test_gradient(self):
         assert grad.children[0].name == a.name
         assert grad.domain == a.domain
 
-    def test_div(self):
+    @given(st.integers())
+    def test_div(self, random_value):
         # divergence of scalar symbol should fail
         a = pybamm.Symbol("a")
         with pytest.raises(
@@ -250,7 +274,7 @@ def test_div(self):
             pybamm.Divergence(a)
 
         # divergence of variable evaluating on edges should fail
-        a = pybamm.PrimaryBroadcast(pybamm.Scalar(1), "test")
+        a = pybamm.PrimaryBroadcast(pybamm.Scalar(random_value), "test")
         with pytest.raises(TypeError, match="evaluate on edges"):
             pybamm.Divergence(a)