summaryrefslogtreecommitdiff
path: root/pint/testsuite/test_util.py
diff options
context:
space:
mode:
Diffstat (limited to 'pint/testsuite/test_util.py')
-rw-r--r--pint/testsuite/test_util.py247
1 files changed, 127 insertions, 120 deletions
diff --git a/pint/testsuite/test_util.py b/pint/testsuite/test_util.py
index 5f71173..d2eebe5 100644
--- a/pint/testsuite/test_util.py
+++ b/pint/testsuite/test_util.py
@@ -3,7 +3,8 @@ import copy
import math
import operator as op
-from pint.testsuite import BaseTestCase, QuantityTestCase
+import pytest
+
from pint.util import (
ParserHelper,
UnitsContainer,
@@ -19,7 +20,7 @@ from pint.util import (
)
-class TestUnitsContainer(QuantityTestCase):
+class TestUnitsContainer:
def _test_inplace(self, operator, value1, value2, expected_result):
value1 = copy.copy(value1)
value2 = copy.copy(value2)
@@ -27,11 +28,11 @@ class TestUnitsContainer(QuantityTestCase):
id2 = id(value2)
value1 = operator(value1, value2)
value2_cpy = copy.copy(value2)
- self.assertEqual(value1, expected_result)
+ assert value1 == expected_result
# Inplace operation creates copies
- self.assertNotEqual(id1, id(value1))
- self.assertEqual(value2, value2_cpy)
- self.assertEqual(id2, id(value2))
+ assert id1 != id(value1)
+ assert value2 == value2_cpy
+ assert id2 == id(value2)
def _test_not_inplace(self, operator, value1, value2, expected_result):
id1 = id(value1)
@@ -42,48 +43,48 @@ class TestUnitsContainer(QuantityTestCase):
result = operator(value1, value2)
- self.assertEqual(expected_result, result)
- self.assertEqual(value1, value1_cpy)
- self.assertEqual(value2, value2_cpy)
- self.assertNotEqual(id(result), id1)
- self.assertNotEqual(id(result), id2)
+ assert expected_result == result
+ assert value1 == value1_cpy
+ assert value2 == value2_cpy
+ assert id(result) != id1
+ assert id(result) != id2
def test_unitcontainer_creation(self):
x = UnitsContainer(meter=1, second=2)
y = UnitsContainer({"meter": 1, "second": 2})
- self.assertIsInstance(x["meter"], int)
- self.assertEqual(x, y)
- self.assertIsNot(x, y)
+ assert isinstance(x["meter"], int)
+ assert x == y
+ assert x is not y
z = copy.copy(x)
- self.assertEqual(x, z)
- self.assertIsNot(x, z)
+ assert x == z
+ assert x is not z
z = UnitsContainer(x)
- self.assertEqual(x, z)
- self.assertIsNot(x, z)
+ assert x == z
+ assert x is not z
def test_unitcontainer_repr(self):
x = UnitsContainer()
- self.assertEqual(str(x), "dimensionless")
- self.assertEqual(repr(x), "<UnitsContainer({})>")
+ assert str(x) == "dimensionless"
+ assert repr(x) == "<UnitsContainer({})>"
x = UnitsContainer(meter=1, second=2)
- self.assertEqual(str(x), "meter * second ** 2")
- self.assertEqual(repr(x), "<UnitsContainer({'meter': 1, 'second': 2})>")
+ assert str(x) == "meter * second ** 2"
+ assert repr(x) == "<UnitsContainer({'meter': 1, 'second': 2})>"
x = UnitsContainer(meter=1, second=2.5)
- self.assertEqual(str(x), "meter * second ** 2.5")
- self.assertEqual(repr(x), "<UnitsContainer({'meter': 1, 'second': 2.5})>")
+ assert str(x) == "meter * second ** 2.5"
+ assert repr(x) == "<UnitsContainer({'meter': 1, 'second': 2.5})>"
def test_unitcontainer_bool(self):
- self.assertTrue(UnitsContainer(meter=1, second=2))
- self.assertFalse(UnitsContainer())
+ assert UnitsContainer(meter=1, second=2)
+ assert not UnitsContainer()
def test_unitcontainer_comp(self):
x = UnitsContainer(meter=1, second=2)
y = UnitsContainer(meter=1.0, second=2)
z = UnitsContainer(meter=1, second=3)
- self.assertTrue(x == y)
- self.assertFalse(x != y)
- self.assertFalse(x == z)
- self.assertTrue(x != z)
+ assert x == y
+ assert not (x != y)
+ assert not (x == z)
+ assert x != z
def test_unitcontainer_arithmetic(self):
x = UnitsContainer(meter=1)
@@ -104,72 +105,75 @@ class TestUnitsContainer(QuantityTestCase):
x = UnitsContainer(meter=1)
y = UnitsContainer(second=1)
z = UnitsContainer(meter=1, second=-2)
- self.assertEqual(x, "meter")
- self.assertEqual("meter", x)
- self.assertNotEqual(x, "meter ** 2")
- self.assertNotEqual(x, "meter * meter")
- self.assertNotEqual(x, "second")
- self.assertEqual(y, "second")
- self.assertEqual(z, "meter/second/second")
+ assert x == "meter"
+ assert "meter" == x
+ assert x != "meter ** 2"
+ assert x != "meter * meter"
+ assert x != "second"
+ assert y == "second"
+ assert z == "meter/second/second"
def test_invalid(self):
- self.assertRaises(TypeError, UnitsContainer, {1: 2})
- self.assertRaises(TypeError, UnitsContainer, {"1": "2"})
+ with pytest.raises(TypeError):
+ UnitsContainer({1: 2})
+ with pytest.raises(TypeError):
+ UnitsContainer({"1": "2"})
d = UnitsContainer()
- self.assertRaises(TypeError, d.__mul__, list())
- self.assertRaises(TypeError, d.__pow__, list())
- self.assertRaises(TypeError, d.__truediv__, list())
- self.assertRaises(TypeError, d.__rtruediv__, list())
+ with pytest.raises(TypeError):
+ d.__mul__(list())
+ with pytest.raises(TypeError):
+ d.__pow__(list())
+ with pytest.raises(TypeError):
+ d.__truediv__(list())
+ with pytest.raises(TypeError):
+ d.__rtruediv__(list())
-class TestToUnitsContainer(BaseTestCase):
+class TestToUnitsContainer:
def test_str_conversion(self):
- self.assertEqual(to_units_container("m"), UnitsContainer(m=1))
+ assert to_units_container("m") == UnitsContainer(m=1)
def test_uc_conversion(self):
a = UnitsContainer(m=1)
- self.assertIs(to_units_container(a), a)
+ assert to_units_container(a) is a
def test_quantity_conversion(self):
from pint.registry import UnitRegistry
ureg = UnitRegistry()
- self.assertEqual(
- to_units_container(ureg.Quantity(1, UnitsContainer(m=1))),
- UnitsContainer(m=1),
- )
+ assert to_units_container(
+ ureg.Quantity(1, UnitsContainer(m=1))
+ ) == UnitsContainer(m=1)
def test_unit_conversion(self):
from pint import Unit
- self.assertEqual(
- to_units_container(Unit(UnitsContainer(m=1))), UnitsContainer(m=1)
- )
+ assert to_units_container(Unit(UnitsContainer(m=1))) == UnitsContainer(m=1)
def test_dict_conversion(self):
- self.assertEqual(to_units_container(dict(m=1)), UnitsContainer(m=1))
+ assert to_units_container(dict(m=1)) == UnitsContainer(m=1)
-class TestParseHelper(BaseTestCase):
+class TestParseHelper:
def test_basic(self):
# Parse Helper ar mutables, so we build one everytime
x = lambda: ParserHelper(1, meter=2)
xp = lambda: ParserHelper(1, meter=2)
y = lambda: ParserHelper(2, meter=2)
- self.assertEqual(x(), xp())
- self.assertNotEqual(x(), y())
- self.assertEqual(ParserHelper.from_string(""), ParserHelper())
- self.assertEqual(repr(x()), "<ParserHelper(1, {'meter': 2})>")
+ assert x() == xp()
+ assert x() != y()
+ assert ParserHelper.from_string("") == ParserHelper()
+ assert repr(x()) == "<ParserHelper(1, {'meter': 2})>"
- self.assertEqual(ParserHelper(2), 2)
+ assert ParserHelper(2) == 2
- self.assertEqual(x(), dict(meter=2))
- self.assertEqual(x(), "meter ** 2")
- self.assertNotEqual(y(), dict(meter=2))
- self.assertNotEqual(y(), "meter ** 2")
+ assert x() == dict(meter=2)
+ assert x() == "meter ** 2"
+ assert y() != dict(meter=2)
+ assert y() != "meter ** 2"
- self.assertNotEqual(xp(), object())
+ assert xp() != object()
def test_calculate(self):
# Parse Helper ar mutables, so we build one everytime
@@ -177,43 +181,43 @@ class TestParseHelper(BaseTestCase):
y = lambda: ParserHelper(2.0, meter=-2)
z = lambda: ParserHelper(2.0, meter=2)
- self.assertEqual(x() * 4.0, ParserHelper(4.0, meter=2))
- self.assertEqual(x() * y(), ParserHelper(2.0))
- self.assertEqual(x() * "second", ParserHelper(1.0, meter=2, second=1))
+ assert x() * 4.0 == ParserHelper(4.0, meter=2)
+ assert x() * y() == ParserHelper(2.0)
+ assert x() * "second" == ParserHelper(1.0, meter=2, second=1)
- self.assertEqual(x() / 4.0, ParserHelper(0.25, meter=2))
- self.assertEqual(x() / "second", ParserHelper(1.0, meter=2, second=-1))
- self.assertEqual(x() / z(), ParserHelper(0.5))
+ assert x() / 4.0 == ParserHelper(0.25, meter=2)
+ assert x() / "second" == ParserHelper(1.0, meter=2, second=-1)
+ assert x() / z() == ParserHelper(0.5)
- self.assertEqual(4.0 / z(), ParserHelper(2.0, meter=-2))
- self.assertEqual("seconds" / z(), ParserHelper(0.5, seconds=1, meter=-2))
- self.assertEqual(dict(seconds=1) / z(), ParserHelper(0.5, seconds=1, meter=-2))
+ assert 4.0 / z() == ParserHelper(2.0, meter=-2)
+ assert "seconds" / z() == ParserHelper(0.5, seconds=1, meter=-2)
+ assert dict(seconds=1) / z() == ParserHelper(0.5, seconds=1, meter=-2)
def _test_eval_token(self, expected, expression, use_decimal=False):
token = next(tokenizer(expression))
actual = ParserHelper.eval_token(token, use_decimal=use_decimal)
- self.assertEqual(expected, actual)
- self.assertEqual(type(expected), type(actual))
+ assert expected == actual
+ assert type(expected) == type(actual)
def test_eval_token(self):
self._test_eval_token(1000.0, "1e3")
self._test_eval_token(1000.0, "1E3")
self._test_eval_token(1000, "1000")
- def test_nan(self):
+ def test_nan(self, subtests):
for s in ("nan", "NAN", "NaN", "123 NaN nan NAN 456"):
- with self.subTest(s):
+ with subtests.test(s):
p = ParserHelper.from_string(s + " kg")
assert math.isnan(p.scale)
- self.assertEqual(dict(p), {"kg": 1})
+ assert dict(p) == {"kg": 1}
-class TestStringProcessor(BaseTestCase):
+class TestStringProcessor:
def _test(self, bef, aft):
for pattern in ("{}", "+{}+"):
b = pattern.format(bef)
a = pattern.format(aft)
- self.assertEqual(string_preprocessor(b), a)
+ assert string_preprocessor(b) == a
def test_square_cube(self):
self._test("bcd^3", "bcd**3")
@@ -267,95 +271,98 @@ class TestStringProcessor(BaseTestCase):
self._test("water_60F", "water_60F")
-class TestGraph(BaseTestCase):
+class TestGraph:
def test_start_not_in_graph(self):
g = collections.defaultdict(set)
g[1] = {2}
g[2] = {3}
- self.assertIs(find_connected_nodes(g, 9), None)
+ assert find_connected_nodes(g, 9) is None
def test_shortest_path(self):
g = collections.defaultdict(set)
g[1] = {2}
g[2] = {3}
p = find_shortest_path(g, 1, 2)
- self.assertEqual(p, [1, 2])
+ assert p == [1, 2]
p = find_shortest_path(g, 1, 3)
- self.assertEqual(p, [1, 2, 3])
+ assert p == [1, 2, 3]
p = find_shortest_path(g, 3, 1)
- self.assertIs(p, None)
+ assert p is None
g = collections.defaultdict(set)
g[1] = {2}
g[2] = {3, 1}
g[3] = {2}
p = find_shortest_path(g, 1, 2)
- self.assertEqual(p, [1, 2])
+ assert p == [1, 2]
p = find_shortest_path(g, 1, 3)
- self.assertEqual(p, [1, 2, 3])
+ assert p == [1, 2, 3]
p = find_shortest_path(g, 3, 1)
- self.assertEqual(p, [3, 2, 1])
+ assert p == [3, 2, 1]
p = find_shortest_path(g, 2, 1)
- self.assertEqual(p, [2, 1])
+ assert p == [2, 1]
-class TestMatrix(BaseTestCase):
+class TestMatrix:
def test_matrix_to_string(self):
- self.assertEqual(
- matrix_to_string([[1, 2], [3, 4]], row_headers=None, col_headers=None),
- "1\t2\n" "3\t4",
+ assert (
+ matrix_to_string([[1, 2], [3, 4]], row_headers=None, col_headers=None)
+ == "1\t2\n"
+ "3\t4"
)
- self.assertEqual(
+ assert (
matrix_to_string(
[[1, 2], [3, 4]],
row_headers=None,
col_headers=None,
fmtfun=lambda x: f"{x:.2f}",
- ),
- "1.00\t2.00\n" "3.00\t4.00",
+ )
+ == "1.00\t2.00\n"
+ "3.00\t4.00"
)
- self.assertEqual(
- matrix_to_string(
- [[1, 2], [3, 4]], row_headers=["c", "d"], col_headers=None
- ),
- "c\t1\t2\n" "d\t3\t4",
+ assert (
+ matrix_to_string([[1, 2], [3, 4]], row_headers=["c", "d"], col_headers=None)
+ == "c\t1\t2\n"
+ "d\t3\t4"
)
- self.assertEqual(
- matrix_to_string(
- [[1, 2], [3, 4]], row_headers=None, col_headers=["a", "b"]
- ),
- "a\tb\n" "1\t2\n" "3\t4",
+ assert (
+ matrix_to_string([[1, 2], [3, 4]], row_headers=None, col_headers=["a", "b"])
+ == "a\tb\n"
+ "1\t2\n"
+ "3\t4"
)
- self.assertEqual(
+ assert (
matrix_to_string(
[[1, 2], [3, 4]], row_headers=["c", "d"], col_headers=["a", "b"]
- ),
- "\ta\tb\n" "c\t1\t2\n" "d\t3\t4",
+ )
+ == "\ta\tb\n"
+ "c\t1\t2\n"
+ "d\t3\t4"
)
def test_transpose(self):
- self.assertEqual(transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]])
+ assert transpose([[1, 2], [3, 4]]) == [[1, 3], [2, 4]]
-class TestOtherUtils(BaseTestCase):
+class TestOtherUtils:
def test_iterable(self):
# Test with list, string, generator, and scalar
- self.assertTrue(iterable([0, 1, 2, 3]))
- self.assertTrue(iterable("test"))
- self.assertTrue(iterable((i for i in range(5))))
- self.assertFalse(iterable(0))
+ assert iterable([0, 1, 2, 3])
+ assert iterable("test")
+ assert iterable((i for i in range(5)))
+ assert not iterable(0)
def test_sized(self):
# Test with list, string, generator, and scalar
- self.assertTrue(sized([0, 1, 2, 3]))
- self.assertTrue(sized("test"))
- self.assertFalse(sized((i for i in range(5))))
- self.assertFalse(sized(0))
+ assert sized([0, 1, 2, 3])
+ assert sized("test")
+ assert not sized((i for i in range(5)))
+ assert not sized(0)
View Lorry Controller Status