Hypothesis (#32)

* Introducing hypothesis, which already uncovered several bugs.

* Quantity tests with Hypothesis, and tightening up floating point tolerances
around the test suite.

Author: chrisguidry

.gitignore

@@ -3,6 +3,7 @@
 build
 .coverage
 dist
+.hypothesis
 .mypy_cache
 .profiles
 *.pyc

setup.cfg

@@ -58,6 +58,7 @@ dev =
     cloudpickle
     flake8
     flake8-black
+    hypothesis
     icecream
     isort
     ipython

src/measured/__init__.py

@@ -165,10 +165,11 @@
 from .formatting import superscript
 
 try:
-    from icecream import ic
+    from icecream import _ic
 except ImportError:  # pragma: no cover
-    ic = lambda *a: None if not a else (a[0] if len(a) == 1 else a)  # noqa
+    _ic = lambda *a: None if not a else (a[0] if len(a) == 1 else a)  # noqa
 
+ic = _ic
 
 __version__ = version("measured")
 
@@ -582,6 +583,9 @@ def __new__(
         name: Optional[str] = None,
         symbol: Optional[str] = None,
     ) -> "Prefix":
+        if base != 0 and exponent == 0:
+            return IdentityPrefix
+
         key = (base, exponent)
         if key in cls._known:
             return cls._known[key]
@@ -1074,7 +1078,7 @@ def parse(cls, string: str) -> "Unit":
 
     def __str__(self) -> str:
         if self.symbol:
-            return f"{self.prefix}{self.symbol}"
+            return self.symbol
 
         return str(self.prefix) + "⋅".join(
             f"{unit.prefix}{unit.symbol}{superscript(exponent)}"
@@ -1526,7 +1530,7 @@ def _approximation(self, other: "Quantity") -> Union[Numeric, bool]:
 
         return abs(ratio)
 
-    def approximates(self, other: "Quantity", within: float = 1e-6) -> bool:
+    def approximates(self, other: "Quantity", within: float = 1e-7) -> bool:
         """Indicates whether this Quantity and another Quantity are close enough to
         each other to be considered equal.
 
@@ -1546,7 +1550,7 @@ def approximates(self, other: "Quantity", within: float = 1e-6) -> bool:
 
         return bool(approximation <= within)
 
-    def assert_approximates(self, other: "Quantity", within: float = 1e-6) -> None:
+    def assert_approximates(self, other: "Quantity", within: float = 1e-7) -> None:
         """Asserts whether this Quantity and another Quantity are close enough to
         each other to be considered equal, with a helpful assertion message
 
@@ -1570,7 +1574,7 @@ def assert_approximates(self, other: "Quantity", within: float = 1e-6) -> None:
         if approximation is True:
             return
 
-        assert approximation, f"No conversion between {self} and {other}"
+        assert approximation is not False, f"No conversion between {self} and {other}"
 
         message = " or ".join(
             [

src/measured/hypothesis.py

@@ -0,0 +1,58 @@
+from hypothesis.strategies import (
+    SearchStrategy,
+    builds,
+    floats,
+    integers,
+    one_of,
+    sampled_from,
+)
+
+from measured import systems  # noqa: F401
+from measured import Dimension, Prefix, Quantity, Unit
+
+DIMENSIONS = sorted(Dimension.fundamental(), key=lambda d: d.exponents)
+PREFIXES = sorted(Prefix._known.values(), key=lambda p: (p.base, p.exponent))
+BASE_UNITS = sorted(Unit.base(), key=lambda u: u.name or "")
+UNITS = sorted(Unit._known.values(), key=lambda u: u.name or "")
+for this in BASE_UNITS:
+    UNITS.append(this**2)
+    UNITS.append(this**3)
+    UNITS.append(this**-2)
+    UNITS.append(this**-3)
+    for other in BASE_UNITS:
+        UNITS.append(this / other)
+        UNITS.append(this * other)
+UNITS_WITH_SYMBOLS = [u for u in UNITS if u.symbol]
+
+
+def dimensions() -> SearchStrategy[Dimension]:
+    return sampled_from(DIMENSIONS)
+
+
+def prefixes() -> SearchStrategy[Prefix]:
+    return sampled_from(PREFIXES)
+
+
+def units() -> SearchStrategy[Unit]:
+    return sampled_from(UNITS)
+
+
+def base_units() -> SearchStrategy[Unit]:
+    return sampled_from(BASE_UNITS)
+
+
+def units_with_symbols() -> SearchStrategy[Unit]:
+    return sampled_from(UNITS_WITH_SYMBOLS)
+
+
+def quantities() -> SearchStrategy[Quantity]:
+    return builds(
+        Quantity,
+        magnitude=one_of(
+            floats(min_value=-1e30, max_value=-1e-30),
+            sampled_from([0.0]),
+            floats(min_value=1e-30, max_value=1e-30),
+            integers(),
+        ),
+        unit=units(),
+    )

src/measured/si.py

@@ -189,7 +189,7 @@
 Hertz = Unit.derive(One / Second, name="hertz", symbol="Hz")
 
 Radian = PlaneAngle.unit(name="radian", symbol="rad")
-Steradian = PlaneAngle.unit(name="steradian", symbol="sr")
+Steradian = Unit.derive(Radian**2, name="steradian", symbol="sr")
 
 Newton = Unit.derive((Kilogram) * Meter / Second**2, name="newton", symbol="N")
 Joule = Unit.derive(Meter * Newton, name="joule", symbol="J")

tests/natural/test_planck.py

@@ -32,7 +32,7 @@ def test_hbar() -> None:
 
 def test_length() -> None:
     assert PlanckLength.dimension is Length
-    (1 * PlanckLength).assert_approximates(1.616255e-35 * Meter)
+    (1 * PlanckLength).assert_approximates(1.616255e-35 * Meter, 1.3e-07)
 
 
 def test_mass() -> None:

tests/quantities/test_multiplication.py

@@ -1,44 +1,36 @@
 import pytest
+from hypothesis import assume, given
 
 from measured import One, Quantity
-from measured.si import Hertz, Meter, Second
+from measured.hypothesis import quantities
 
 
-def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
-    examples = [
-        1 * Meter,
-        2 * Second,
-        3 * Hertz,
-        4 * Meter / Second,
-        5 * Meter**2,
-        6 * Meter**2 / Second**2,
-    ]
-
-    for exemplar in ["a", "b", "c"]:
-        if exemplar in metafunc.fixturenames:
-            metafunc.parametrize(exemplar, examples)
-
-
-@pytest.fixture
+@pytest.fixture(scope="module")
 def identity() -> Quantity:
     return 1 * One
 
 
-def test_multiplication_associativity(a: Quantity, b: Quantity, c: Quantity) -> None:
-    assert (a * b) * c == a * (b * c)
+@given(a=quantities(), b=quantities(), c=quantities())
+def test_associativity(a: Quantity, b: Quantity, c: Quantity) -> None:
+    ((a * b) * c).assert_approximates(a * (b * c))
 
 
-def test_multiplication_identity(identity: Quantity, a: Quantity) -> None:
+@given(a=quantities())
+def test_identity(identity: Quantity, a: Quantity) -> None:
     assert a * identity == a
     assert identity * a == a
 
 
-def test_multiplication_inverse(identity: Quantity, a: Quantity) -> None:
+@given(a=quantities())
+def test_inverse(identity: Quantity, a: Quantity) -> None:
+    assume(a.magnitude != 0)
+
     inverse = a**-1
     assert inverse * a == a * inverse
-    assert inverse * a == identity
-    assert identity / a == inverse
+    (inverse * a).assert_approximates(identity)
+    (identity / a).assert_approximates(inverse)
 
 
-def test_multiplication_commutativity(a: Quantity, b: Quantity) -> None:
+@given(a=quantities(), b=quantities())
+def test_commutativity(a: Quantity, b: Quantity) -> None:
     assert a * b == b * a

tests/si/test_angles.py

@@ -36,8 +36,8 @@ def test_steradian_is_dimensionless_but_unique() -> None:
         (2 * π * Radian, 360 * Degree),
         (1 * Arcminute, 60 * Arcsecond),
         (1 * Degree, 60 * Arcminute),
-        (1 * Arcsecond, 0.000004848136 * Radian),
-        (1 * Arcminute, 0.000290888 * Radian),
+        (1 * Arcsecond, 0.000004848136811 * Radian),
+        (1 * Arcminute, 0.000290888208665 * Radian),
     ],
 )
 def test_angle_conversions(left: Quantity, right: Quantity) -> None:

tests/test_dimension.py

@@ -1,6 +1,7 @@
 from fractions import Fraction
 
 import pytest
+from hypothesis import given
 
 from measured import (
     AmountOfSubstance,
@@ -22,25 +23,15 @@
     Time,
     Volume,
 )
+from measured.hypothesis import dimensions
 
 
-def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
-    fundamental = Dimension.fundamental()
-    ids = [d.name for d in fundamental]
-
-    for exemplar in ["a", "b", "c"]:
-        if exemplar in metafunc.fixturenames:
-            metafunc.parametrize(exemplar, fundamental, ids=ids)
-
-    if "dimension" in metafunc.fixturenames:
-        metafunc.parametrize("dimension", fundamental, ids=ids)
-
-
-@pytest.fixture
+@pytest.fixture(scope="module")
 def identity() -> Dimension:
     return Number
 
 
+@given(a=dimensions(), b=dimensions())
 def test_homogenous_under_addition(a: Dimension, b: Dimension) -> None:
     # https://en.wikipedia.org/wiki/Dimensional_analysis#Dimensional_homogeneity
     #
@@ -53,6 +44,7 @@ def test_homogenous_under_addition(a: Dimension, b: Dimension) -> None:
             a + b
 
 
+@given(a=dimensions(), b=dimensions())
 def test_homogenous_under_subtraction(a: Dimension, b: Dimension) -> None:
     # https://en.wikipedia.org/wiki/Dimensional_analysis#Dimensional_homogeneity
     #
@@ -65,41 +57,49 @@ def test_homogenous_under_subtraction(a: Dimension, b: Dimension) -> None:
             a - b
 
 
+@given(a=dimensions(), b=dimensions(), c=dimensions())
 def test_abelian_associativity(a: Dimension, b: Dimension, c: Dimension) -> None:
     # https://en.wikipedia.org/wiki/Abelian_group
     assert (a * b) * c == a * (b * c)
 
 
+@given(a=dimensions())
 def test_abelian_identity(identity: Dimension, a: Dimension) -> None:
     assert identity * a == a
 
 
+@given(a=dimensions())
 def test_abelian_inverse(identity: Dimension, a: Dimension) -> None:
     inverse = a**-1
     assert inverse * a == a * inverse
     assert inverse * a == identity
     assert identity / a == inverse
 
 
+@given(a=dimensions(), b=dimensions())
 def test_abelian_commutativity(a: Dimension, b: Dimension) -> None:
     assert a * b == b * a
 
 
+@given(dimension=dimensions())
 def test_no_dimensional_exponentation(dimension: Dimension) -> None:
     with pytest.raises(TypeError):
         dimension**dimension  # type: ignore
 
 
+@given(dimension=dimensions())
 def test_no_floating_point_exponentation(dimension: Dimension) -> None:
     with pytest.raises(TypeError):
         dimension**0.5  # type: ignore
 
 
+@given(dimension=dimensions())
 def test_no_fractional_exponentation(dimension: Dimension) -> None:
     with pytest.raises(TypeError):
         dimension ** Fraction(1, 2)  # type: ignore
 
 
+@given(dimension=dimensions())
 def test_only_dimensional_multiplication(dimension: Dimension) -> None:
     with pytest.raises(TypeError):
         5 * dimension  # type: ignore
@@ -108,6 +108,7 @@ def test_only_dimensional_multiplication(dimension: Dimension) -> None:
         dimension * 5  # type: ignore
 
 
+@given(dimension=dimensions())
 def test_only_dimensional_division(dimension: Dimension) -> None:
     with pytest.raises(TypeError):
         dimension / 5  # type: ignore
@@ -116,6 +117,7 @@ def test_only_dimensional_division(dimension: Dimension) -> None:
         5 / dimension  # type: ignore
 
 
+@given(dimension=dimensions())
 def test_repr(dimension: Dimension) -> None:
     r = repr(dimension)
     assert r.startswith("Dimension(exponents=(0,")
@@ -124,6 +126,7 @@ def test_repr(dimension: Dimension) -> None:
     assert r.endswith(")")
 
 
+@given(dimension=dimensions())
 def test_repr_roundtrips(dimension: Dimension) -> None:
     assert eval(repr(dimension)) is dimension