ucon 0.3.5rc1__py3-none-any.whl → 0.4.0__py3-none-any.whl

tests/ucon/conversion/test_graph.py

@@ -0,0 +1,175 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+import unittest
+
+from ucon import units
+from ucon.core import Dimension, Scale, Unit, UnitFactor, UnitProduct
+from ucon.graph import (
+    ConversionGraph,
+    DimensionMismatch,
+    ConversionNotFound,
+    CyclicInconsistency,
+)
+from ucon.maps import LinearMap, AffineMap
+
+
+class TestConversionGraphEdgeManagement(unittest.TestCase):
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.meter = units.meter
+        self.foot = Unit(name='foot', dimension=Dimension.length, aliases=('ft',))
+        self.inch = Unit(name='inch', dimension=Dimension.length, aliases=('in',))
+        self.gram = units.gram
+
+    def test_add_and_retrieve_edge(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        m = self.graph.convert(src=self.meter, dst=self.foot)
+        self.assertAlmostEqual(m(1), 3.28084, places=4)
+
+    def test_inverse_auto_stored(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        m = self.graph.convert(src=self.foot, dst=self.meter)
+        self.assertAlmostEqual(m(1), 0.3048, places=4)
+
+    def test_dimension_mismatch_rejected(self):
+        with self.assertRaises(DimensionMismatch):
+            self.graph.add_edge(src=self.meter, dst=self.gram, map=LinearMap(1))
+
+    def test_cyclic_consistency_check(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        # Adding inconsistent reverse should raise
+        with self.assertRaises(CyclicInconsistency):
+            self.graph.add_edge(src=self.foot, dst=self.meter, map=LinearMap(0.5))  # wrong!
+
+
+class TestConversionGraphUnitConversion(unittest.TestCase):
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.meter = units.meter
+        self.foot = Unit(name='foot', dimension=Dimension.length, aliases=('ft',))
+        self.inch = Unit(name='inch', dimension=Dimension.length, aliases=('in',))
+        self.yard = Unit(name='yard', dimension=Dimension.length, aliases=('yd',))
+
+    def test_identity_conversion(self):
+        m = self.graph.convert(src=self.meter, dst=self.meter)
+        self.assertTrue(m.is_identity())
+
+    def test_direct_edge(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        m = self.graph.convert(src=self.meter, dst=self.foot)
+        self.assertAlmostEqual(m(1), 3.28084, places=4)
+
+    def test_composed_path(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        self.graph.add_edge(src=self.foot, dst=self.inch, map=LinearMap(12))
+        m = self.graph.convert(src=self.meter, dst=self.inch)
+        self.assertAlmostEqual(m(1), 39.37008, places=3)
+
+    def test_multi_hop_path(self):
+        self.graph.add_edge(src=self.meter, dst=self.foot, map=LinearMap(3.28084))
+        self.graph.add_edge(src=self.foot, dst=self.inch, map=LinearMap(12))
+        self.graph.add_edge(src=self.inch, dst=self.yard, map=LinearMap(1/36))
+        m = self.graph.convert(src=self.meter, dst=self.yard)
+        self.assertAlmostEqual(m(1), 1.0936, places=3)
+
+    def test_no_path_raises(self):
+        mile = Unit(name='mile', dimension=Dimension.length, aliases=('mi',))
+        with self.assertRaises(ConversionNotFound):
+            self.graph.convert(src=self.meter, dst=mile)
+
+    def test_dimension_mismatch_on_convert(self):
+        with self.assertRaises(DimensionMismatch):
+            self.graph.convert(src=self.meter, dst=units.second)
+
+
+class TestConversionGraphProductConversion(unittest.TestCase):
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.meter = units.meter
+        self.second = units.second
+        self.mile = Unit(name='mile', dimension=Dimension.length, aliases=('mi',))
+        self.hour = Unit(name='hour', dimension=Dimension.time, aliases=('h',))
+
+        # Register unit conversions
+        self.graph.add_edge(src=self.meter, dst=self.mile, map=LinearMap(0.000621371))
+        self.graph.add_edge(src=self.second, dst=self.hour, map=LinearMap(1/3600))
+
+    def test_factorwise_velocity_conversion(self):
+        m_per_s = UnitProduct({
+            UnitFactor(self.meter, Scale.one): 1,
+            UnitFactor(self.second, Scale.one): -1,
+        })
+        mi_per_hr = UnitProduct({
+            UnitFactor(self.mile, Scale.one): 1,
+            UnitFactor(self.hour, Scale.one): -1,
+        })
+
+        m = self.graph.convert(src=m_per_s, dst=mi_per_hr)
+        # 1 m/s = 2.23694 mi/h
+        self.assertAlmostEqual(m(1), 2.237, places=2)
+
+    def test_scale_ratio_in_factorwise(self):
+        km = UnitProduct({UnitFactor(self.meter, Scale.kilo): 1})
+        m = UnitProduct({UnitFactor(self.meter, Scale.one): 1})
+
+        conversion = self.graph.convert(src=km, dst=m)
+        self.assertAlmostEqual(conversion(1), 1000, places=6)
+
+    def test_direct_product_edge(self):
+        # Define joule and watt_hour as UnitProducts
+        g = units.gram
+        joule = UnitProduct({
+            UnitFactor(g, Scale.one): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -2,
+        })
+        watt = UnitProduct({
+            UnitFactor(g, Scale.one): 1,
+            UnitFactor(self.meter, Scale.one): 2,
+            UnitFactor(self.second, Scale.one): -3,
+        })
+        watt_hour = watt * UnitProduct({UnitFactor(self.hour, Scale.one): 1})
+
+        # Register direct edge
+        self.graph.add_edge(src=joule, dst=watt_hour, map=LinearMap(1/3600))
+
+        m = self.graph.convert(src=joule, dst=watt_hour)
+        self.assertAlmostEqual(m(7200), 2.0, places=6)
+
+    def test_product_identity(self):
+        m_per_s = UnitProduct({
+            UnitFactor(self.meter, Scale.one): 1,
+            UnitFactor(self.second, Scale.one): -1,
+        })
+        m = self.graph.convert(src=m_per_s, dst=m_per_s)
+        self.assertTrue(m.is_identity())
+
+
+class TestConversionGraphTemperature(unittest.TestCase):
+
+    def setUp(self):
+        self.graph = ConversionGraph()
+        self.celsius = Unit(name='celsius', dimension=Dimension.temperature, aliases=('°C',))
+        self.kelvin = Unit(name='kelvin', dimension=Dimension.temperature, aliases=('K',))
+        self.fahrenheit = Unit(name='fahrenheit', dimension=Dimension.temperature, aliases=('°F',))
+
+    def test_celsius_to_kelvin(self):
+        self.graph.add_edge(src=self.celsius, dst=self.kelvin, map=AffineMap(1, 273.15))
+        m = self.graph.convert(src=self.celsius, dst=self.kelvin)
+        self.assertAlmostEqual(m(0), 273.15, places=2)
+        self.assertAlmostEqual(m(100), 373.15, places=2)
+
+    def test_celsius_to_fahrenheit_via_kelvin(self):
+        # C → K: K = C + 273.15
+        self.graph.add_edge(src=self.celsius, dst=self.kelvin, map=AffineMap(1, 273.15))
+        # F → K: K = (F - 32) * 5/9 + 273.15 = 5/9 * F + 255.372
+        self.graph.add_edge(src=self.fahrenheit, dst=self.kelvin, map=AffineMap(5/9, 255.372))
+
+        m = self.graph.convert(src=self.celsius, dst=self.fahrenheit)
+        self.assertAlmostEqual(m(0), 32, places=0)
+        self.assertAlmostEqual(m(100), 212, places=0)

tests/ucon/conversion/test_map.py

@@ -0,0 +1,163 @@
+# © 2025 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+import unittest
+
+from ucon.maps import AffineMap, ComposedMap, LinearMap, Map
+
+
+class TestLinearMap(unittest.TestCase):
+
+    def test_apply(self):
+        m = LinearMap(39.37)
+        self.assertAlmostEqual(m(1.0), 39.37)
+        self.assertAlmostEqual(m(0.0), 0.0)
+        self.assertAlmostEqual(m(2.5), 98.425)
+
+    def test_inverse(self):
+        m = LinearMap(39.37)
+        inv = m.inverse()
+        self.assertIsInstance(inv, LinearMap)
+        self.assertAlmostEqual(inv.a, 1.0 / 39.37)
+
+    def test_inverse_zero_raises(self):
+        m = LinearMap(0)
+        with self.assertRaises(ZeroDivisionError):
+            m.inverse()
+
+    def test_round_trip(self):
+        m = LinearMap(39.37)
+        for x in [0.0, 1.0, -5.5, 1000.0]:
+            self.assertAlmostEqual(m.inverse()(m(x)), x, places=10)
+
+    def test_compose_closed(self):
+        f = LinearMap(39.37)
+        g = LinearMap(1.0 / 12.0)
+        composed = f @ g
+        self.assertIsInstance(composed, LinearMap)
+        self.assertAlmostEqual(composed.a, 39.37 / 12.0)
+
+    def test_compose_apply(self):
+        f = LinearMap(2.0)
+        g = LinearMap(3.0)
+        # (f @ g)(x) = f(g(x)) = 2 * (3 * x) = 6x
+        self.assertAlmostEqual((f @ g)(5.0), 30.0)
+
+    def test_identity(self):
+        ident = LinearMap.identity()
+        self.assertAlmostEqual(ident(42.0), 42.0)
+        m = LinearMap(7.0)
+        self.assertEqual(m @ ident, m)
+        self.assertEqual(ident @ m, m)
+
+    def test_invertible(self):
+        self.assertTrue(LinearMap(5.0).invertible)
+        self.assertFalse(LinearMap(0).invertible)
+
+    def test_eq(self):
+        self.assertEqual(LinearMap(3.0), LinearMap(3.0))
+        self.assertNotEqual(LinearMap(3.0), LinearMap(4.0))
+
+    def test_repr(self):
+        self.assertIn("39.37", repr(LinearMap(39.37)))
+
+    def test_matmul_non_map_returns_not_implemented(self):
+        m = LinearMap(2.0)
+        result = m.__matmul__(42)
+        self.assertIs(result, NotImplemented)
+
+
+class TestAffineMap(unittest.TestCase):
+
+    def test_apply(self):
+        # Celsius to Fahrenheit: F = 1.8 * C + 32
+        c_to_f = AffineMap(1.8, 32.0)
+        self.assertAlmostEqual(c_to_f(0.0), 32.0)
+        self.assertAlmostEqual(c_to_f(100.0), 212.0)
+        self.assertAlmostEqual(c_to_f(-40.0), -40.0)
+
+    def test_inverse(self):
+        c_to_f = AffineMap(1.8, 32.0)
+        f_to_c = c_to_f.inverse()
+        self.assertIsInstance(f_to_c, AffineMap)
+        self.assertAlmostEqual(f_to_c(32.0), 0.0)
+        self.assertAlmostEqual(f_to_c(212.0), 100.0)
+
+    def test_inverse_zero_raises(self):
+        m = AffineMap(0, 5.0)
+        with self.assertRaises(ZeroDivisionError):
+            m.inverse()
+
+    def test_round_trip(self):
+        m = AffineMap(1.8, 32.0)
+        for x in [0.0, 100.0, -40.0, 37.5]:
+            self.assertAlmostEqual(m.inverse()(m(x)), x, places=10)
+
+    def test_compose_closed(self):
+        f = AffineMap(2.0, 3.0)
+        g = AffineMap(4.0, 5.0)
+        composed = f @ g
+        self.assertIsInstance(composed, AffineMap)
+        # f(g(x)) = 2*(4x+5)+3 = 8x+13
+        self.assertAlmostEqual(composed.a, 8.0)
+        self.assertAlmostEqual(composed.b, 13.0)
+
+    def test_compose_apply(self):
+        f = AffineMap(2.0, 3.0)
+        g = AffineMap(4.0, 5.0)
+        for x in [0.0, 1.0, -2.0]:
+            self.assertAlmostEqual((f @ g)(x), f(g(x)), places=10)
+
+    def test_invertible(self):
+        self.assertTrue(AffineMap(1.8, 32.0).invertible)
+        self.assertFalse(AffineMap(0, 32.0).invertible)
+
+    def test_eq(self):
+        self.assertEqual(AffineMap(1.8, 32.0), AffineMap(1.8, 32.0))
+        self.assertNotEqual(AffineMap(1.8, 32.0), AffineMap(1.8, 0.0))
+
+    def test_repr(self):
+        r = repr(AffineMap(1.8, 32.0))
+        self.assertIn("1.8", r)
+        self.assertIn("32.0", r)
+
+
+class TestComposedMap(unittest.TestCase):
+
+    def test_heterogeneous_composition(self):
+        # LinearMap @ AffineMap now returns AffineMap (closed composition)
+        # Use ComposedMap directly to test the fallback behavior
+        lin = LinearMap(2.0)
+        aff = AffineMap(3.0, 1.0)
+        composed = ComposedMap(lin, aff)
+        # lin(aff(x)) = 2 * (3x + 1) = 6x + 2
+        self.assertAlmostEqual(composed(0.0), 2.0)
+        self.assertAlmostEqual(composed(1.0), 8.0)
+
+    def test_inverse(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        for x in [0.0, 1.0, -3.0, 10.0]:
+            self.assertAlmostEqual(composed.inverse()(composed(x)), x, places=10)
+
+    def test_invertible(self):
+        self.assertTrue(ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0)).invertible)
+        self.assertFalse(ComposedMap(LinearMap(0), AffineMap(3.0, 1.0)).invertible)
+
+    def test_non_invertible_raises(self):
+        composed = ComposedMap(LinearMap(0), AffineMap(3.0, 1.0))
+        with self.assertRaises(ValueError):
+            composed.inverse()
+
+    def test_repr(self):
+        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
+        r = repr(composed)
+        self.assertIn("LinearMap", r)
+        self.assertIn("AffineMap", r)
+
+
+class TestMapABC(unittest.TestCase):
+
+    def test_cannot_instantiate(self):
+        with self.assertRaises(TypeError):
+            Map()

tests/ucon/test_algebra.py

@@ -11,41 +11,41 @@ from ucon.algebra import Exponent, Vector
 class TestVector(TestCase):
 
     def test_vector_iteration_and_length(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(tuple(v), (1, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(len(v), 7)  # always 7 components
+        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        self.assertEqual(tuple(v), (1, 0, 0, 0, 0, 0, 0, 0))
+        self.assertEqual(len(v), 8)  # 7 SI + 1 information
 
     def test_vector_addition(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 2, 0, 0, 0, 0, 0)
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(0, 2, 0, 0, 0, 0, 0, 0)
         result = v1 + v2
-        self.assertEqual(result, Vector(1, 2, 0, 0, 0, 0, 0))
+        self.assertEqual(result, Vector(1, 2, 0, 0, 0, 0, 0, 0))
 
     def test_vector_subtraction(self):
-        v1 = Vector(2, 1, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 1, 0, 0, 0, 0, 0)
-        self.assertEqual(v1 - v2, Vector(1, 0, 0, 0, 0, 0, 0))
+        v1 = Vector(2, 1, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(1, 1, 0, 0, 0, 0, 0, 0)
+        self.assertEqual(v1 - v2, Vector(1, 0, 0, 0, 0, 0, 0, 0))
 
     def test_vector_scalar_multiplication_by_integer(self):
-        v = Vector(1, -2, 0, 0, 0, 0, 3)
+        v = Vector(1, -2, 0, 0, 0, 0, 3, 0)
         scaled = v * 2
-        self.assertEqual(scaled, Vector(2, -4, 0, 0, 0, 0, 6))
-        self.assertEqual(v, Vector(1, -2, 0, 0, 0, 0, 3))  # original unchanged
+        self.assertEqual(scaled, Vector(2, -4, 0, 0, 0, 0, 6, 0))
+        self.assertEqual(v, Vector(1, -2, 0, 0, 0, 0, 3, 0))  # original unchanged
 
     def test_vector_scalar_multiplication_by_float(self):
-        v = Vector(0, 1, 0, 0, 0, 0, 0)
+        v = Vector(0, 1, 0, 0, 0, 0, 0, 0)
         scaled = v * 0.5
-        self.assertEqual(scaled, Vector(0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0))
+        self.assertEqual(scaled, Vector(0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0))
 
     def test_vector_scalar_multiplication_by_zero(self):
-        v = Vector(1, 2, 3, 4, 5, 6, 7)
+        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
         zeroed = v * 0
-        self.assertEqual(zeroed, Vector(0, 0, 0, 0, 0, 0, 0))
+        self.assertEqual(zeroed, Vector(0, 0, 0, 0, 0, 0, 0, 0))
 
     def test_vector_equality_and_hash(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v3 = Vector(0, 1, 0, 0, 0, 0, 0)
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v3 = Vector(0, 1, 0, 0, 0, 0, 0, 0)
         self.assertTrue(v1 == v2)
         self.assertFalse(v1 == v3)
         self.assertEqual(hash(v1), hash(v2))
@@ -56,17 +56,17 @@ class TestVectorEdgeCases(TestCase):
 
     def test_zero_vector_equality_and_additivity(self):
         zero = Vector()
-        self.assertEqual(zero, Vector(0, 0, 0, 0, 0, 0, 0))
+        self.assertEqual(zero, Vector(0, 0, 0, 0, 0, 0, 0, 0))
         # Adding or subtracting zero should yield same vector
-        v = Vector(1, 2, 3, 4, 5, 6, 7)
+        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
         self.assertEqual(v + zero, v)
         self.assertEqual(v - zero, v)
 
     def test_vector_with_negative_exponents(self):
-        v1 = Vector(1, -2, 3, 0, 0, 0, 0)
-        v2 = Vector(-1, 2, -3, 0, 0, 0, 0)
+        v1 = Vector(1, -2, 3, 0, 0, 0, 0, 0)
+        v2 = Vector(-1, 2, -3, 0, 0, 0, 0, 0)
         result = v1 + v2
-        self.assertEqual(result, Vector(0, 0, 0, 0, 0, 0, 0))
+        self.assertEqual(result, Vector(0, 0, 0, 0, 0, 0, 0, 0))
         self.assertEqual(v1 - v1, Vector())  # perfect cancellation
 
     def test_vector_equality_with_non_vector(self):
@@ -77,27 +77,27 @@ class TestVectorEdgeCases(TestCase):
             v == None
 
     def test_hash_consistency_for_equal_vectors(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0)
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
         self.assertEqual(hash(v1), hash(v2))
         self.assertEqual(len({v1, v2}), 1)
 
     def test_iter_length_order_consistency(self):
-        v = Vector(1, 2, 3, 4, 5, 6, 7)
+        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
         components = list(v)
         self.assertEqual(len(components), len(v))
-        # Ensure order of iteration is fixed (T→L→M→I→Θ→J→N)
-        self.assertEqual(components, [1, 2, 3, 4, 5, 6, 7])
+        # Ensure order of iteration is fixed (T→L→M→I→Θ→J→N→B)
+        self.assertEqual(components, [1, 2, 3, 4, 5, 6, 7, 8])
 
     def test_vector_arithmetic_does_not_mutate_operands(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 1, 0, 0, 0, 0, 0)
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(0, 1, 0, 0, 0, 0, 0, 0)
         _ = v1 + v2
-        self.assertEqual(v1, Vector(1, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(v2, Vector(0, 1, 0, 0, 0, 0, 0))
+        self.assertEqual(v1, Vector(1, 0, 0, 0, 0, 0, 0, 0))
+        self.assertEqual(v2, Vector(0, 1, 0, 0, 0, 0, 0, 0))
 
     def test_invalid_addition_type_raises(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0)
+        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
         with self.assertRaises(TypeError):
             _ = v + "length"
         with self.assertRaises(TypeError):

tests/ucon/test_core.py

@@ -451,7 +451,7 @@ class TestUnit(unittest.TestCase):
     unit_name = 'second'
     unit_type = 'time'
     unit_aliases = ('seconds', 'secs', 's', 'S')
-    unit = Unit(*unit_aliases, name=unit_name, dimension=Dimension.time)
+    unit = Unit(name=unit_name, dimension=Dimension.time, aliases=unit_aliases)
 
     def test___repr__(self):
         self.assertEqual(f'<Unit {self.unit_aliases[0]}>', str(self.unit))
@@ -464,12 +464,12 @@ class TestUnit(unittest.TestCase):
 
     def test_unit_equality_alias_normalization(self):
         # ('',) should normalize to () under _norm
-        u1 = Unit("", name="x", dimension=Dimension.length)
+        u1 = Unit(name="x", dimension=Dimension.length, aliases=("",))
         u2 = Unit(name="x", dimension=Dimension.length)
         self.assertEqual(u1, u2)
 
     def test_unit_invalid_eq_type(self):
-        self.assertFalse(Unit("m", dimension=Dimension.length) == "meter")
+        self.assertFalse(Unit(name="meter", dimension=Dimension.length, aliases=("m",)) == "meter")
 
 
 class TestUnitProduct(unittest.TestCase):
@@ -544,7 +544,7 @@ class TestUnitEdgeCases(unittest.TestCase):
         self.assertEqual(repr(u), '<Unit>')
 
     def test_unit_with_aliases_and_name(self):
-        u = Unit('m', 'M', name='meter', dimension=Dimension.length)
+        u = Unit(name='meter', dimension=Dimension.length, aliases=('m', 'M'))
         self.assertEqual(u.shorthand, 'm')
         self.assertIn('m', u.aliases)
         self.assertIn('M', u.aliases)
@@ -553,9 +553,9 @@ class TestUnitEdgeCases(unittest.TestCase):
         self.assertIn('<Unit m>', repr(u))
 
     def test_hash_and_equality_consistency(self):
-        u1 = Unit('m', name='meter', dimension=Dimension.length)
-        u2 = Unit('m', name='meter', dimension=Dimension.length)
-        u3 = Unit('s', name='second', dimension=Dimension.time)
+        u1 = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        u2 = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        u3 = Unit(name='second', dimension=Dimension.time, aliases=('s',))
         self.assertEqual(u1, u2)
         self.assertEqual(hash(u1), hash(u2))
         self.assertNotEqual(u1, u3)
@@ -569,36 +569,36 @@ class TestUnitEdgeCases(unittest.TestCase):
     # --- arithmetic behavior ----------------------------------------------
 
     def test_multiplication_produces_composite_unit(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        s = Unit('s', name='second', dimension=Dimension.time)
+        m = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        s = Unit(name='second', dimension=Dimension.time, aliases=('s',))
         v = m / s
         self.assertIsInstance(v, UnitProduct)
         self.assertEqual(v.dimension, Dimension.velocity)
         self.assertIn('/', repr(v))
 
     def test_division_with_dimensionless_denominator_returns_self(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
+        m = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
         none = Unit(name='none', dimension=Dimension.none)
         result = m / none
         self.assertEqual(result, m)
 
     def test_division_of_identical_units_returns_dimensionless(self):
-        m1 = Unit('m', name='meter', dimension=Dimension.length)
-        m2 = Unit('m', name='meter', dimension=Dimension.length)
+        m1 = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        m2 = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
         result = m1 / m2
         self.assertEqual(result.dimension, Dimension.none)
         self.assertEqual(result.name, '')
 
     def test_multiplying_with_dimensionless_returns_self(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
+        m = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
         none = Unit(name='none', dimension=Dimension.none)
         result = m * none
         self.assertEqual(result.dimension, Dimension.length)
         self.assertEqual('m', result.shorthand)
 
     def test_invalid_dimension_combinations_raise_value_error(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        c = Unit('C', name='coulomb', dimension=Dimension.charge)
+        m = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        c = Unit(name='coulomb', dimension=Dimension.charge, aliases=('C',))
         # The result of combination gives CompositeUnit
         self.assertIsInstance(m / c, UnitProduct)
         self.assertIsInstance(m * c, UnitProduct)
@@ -606,16 +606,16 @@ class TestUnitEdgeCases(unittest.TestCase):
     # --- equality, hashing, immutability ----------------------------------
 
     def test_equality_with_non_unit(self):
-        self.assertFalse(Unit('m', name='meter', dimension=Dimension.length) == 'meter')
+        self.assertFalse(Unit(name='meter', dimension=Dimension.length, aliases=('m',)) == 'meter')
 
     def test_hash_stability_in_collections(self):
-        m1 = Unit('m', name='meter', dimension=Dimension.length)
+        m1 = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
         s = set([m1])
-        self.assertIn(Unit('m', name='meter', dimension=Dimension.length), s)
+        self.assertIn(Unit(name='meter', dimension=Dimension.length, aliases=('m',)), s)
 
     def test_operations_do_not_mutate_operands(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        s = Unit('s', name='second', dimension=Dimension.time)
+        m = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
+        s = Unit(name='second', dimension=Dimension.time, aliases=('s',))
         _ = m / s
         self.assertEqual(m.dimension, Dimension.length)
         self.assertEqual(s.dimension, Dimension.time)