ucon 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

tests/ucon/test_graph_basis_transform.py

@@ -0,0 +1,263 @@
+# (c) 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for ConversionGraph integration with BasisTransform.
+
+Verifies cross-basis edge handling, RebasedUnit creation,
+and conversion paths that span dimensional bases.
+"""
+
+import unittest
+from fractions import Fraction
+
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    RebasedUnit,
+    Unit,
+    UnitSystem,
+)
+from ucon.graph import ConversionGraph, DimensionMismatch
+from ucon.maps import LinearMap
+from ucon import units
+
+
+class TestGraphAddEdgeWithBasisTransform(unittest.TestCase):
+    """Test add_edge with basis_transform parameter."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        # Simple 1:1 transform for length
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+
+    def test_add_edge_with_basis_transform(self):
+        # foot -> meter with basis transform
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+        # Verify the rebased unit was created
+        self.assertIn(units.foot, self.graph._rebased)
+        rebased = self.graph._rebased[units.foot]
+        self.assertIsInstance(rebased, RebasedUnit)
+        self.assertEqual(rebased.original, units.foot)
+        self.assertEqual(rebased.rebased_dimension, Dimension.length)
+
+    def test_add_edge_without_basis_transform_requires_same_dimension(self):
+        # foot and meter both have Dimension.length, so this should work
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+        )
+        # Verify no rebased unit was created (normal edge)
+        self.assertNotIn(units.foot, self.graph._rebased)
+
+
+class TestGraphConvertWithBasisTransform(unittest.TestCase):
+    """Test convert() with cross-basis edges."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+        # Add edge with basis transform
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+
+    def test_convert_uses_rebased_path(self):
+        # Convert via the rebased edge
+        map = self.graph.convert(src=units.foot, dst=units.meter)
+        # 1 foot = 0.3048 meters
+        self.assertAlmostEqual(map(1), 0.3048, places=5)
+
+    def test_convert_inverse_works(self):
+        # The inverse edge should also be available
+        map = self.graph.convert(src=units.meter, dst=units.foot)
+        # 1 meter ≈ 3.28084 feet
+        self.assertAlmostEqual(map(1), 1/0.3048, places=5)
+
+
+class TestGraphConnectSystems(unittest.TestCase):
+    """Test connect_systems convenience method."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length, Dimension.mass),
+            dst_dimensions=(Dimension.length, Dimension.mass),
+            matrix=((1, 0), (0, 1)),
+        )
+        self.graph = ConversionGraph()
+
+    def test_connect_systems_bulk_adds_edges(self):
+        self.graph.connect_systems(
+            basis_transform=self.bt,
+            edges={
+                (units.foot, units.meter): LinearMap(0.3048),
+                (units.pound, units.kilogram): LinearMap(0.453592),
+            }
+        )
+        # Both should be converted
+        length_map = self.graph.convert(src=units.foot, dst=units.meter)
+        self.assertAlmostEqual(length_map(1), 0.3048, places=5)
+
+        mass_map = self.graph.convert(src=units.pound, dst=units.kilogram)
+        self.assertAlmostEqual(mass_map(1), 0.453592, places=5)
+
+
+class TestGraphListTransforms(unittest.TestCase):
+    """Test introspection methods for transforms."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+
+    def test_list_rebased_units(self):
+        rebased = self.graph.list_rebased_units()
+        self.assertEqual(len(rebased), 1)
+        self.assertIn(units.foot, rebased)
+        self.assertIsInstance(rebased[units.foot], RebasedUnit)
+
+    def test_list_transforms(self):
+        transforms = self.graph.list_transforms()
+        self.assertEqual(len(transforms), 1)
+        self.assertEqual(transforms[0], self.bt)
+
+    def test_edges_for_transform(self):
+        edges = self.graph.edges_for_transform(self.bt)
+        self.assertEqual(len(edges), 1)
+        self.assertEqual(edges[0], (units.foot, units.meter))
+
+    def test_list_transforms_multiple(self):
+        # Add another transform
+        custom = UnitSystem(
+            name="Custom",
+            bases={Dimension.mass: units.pound}
+        )
+        bt2 = BasisTransform(
+            src=custom,
+            dst=self.si,
+            src_dimensions=(Dimension.mass,),
+            dst_dimensions=(Dimension.mass,),
+            matrix=((1,),),
+        )
+        # Need to add a mass base to SI for this test
+        si_with_mass = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+            }
+        )
+        bt2 = BasisTransform(
+            src=custom,
+            dst=si_with_mass,
+            src_dimensions=(Dimension.mass,),
+            dst_dimensions=(Dimension.mass,),
+            matrix=((1,),),
+        )
+        self.graph.add_edge(
+            src=units.pound,
+            dst=units.kilogram,
+            map=LinearMap(0.453592),
+            basis_transform=bt2,
+        )
+        transforms = self.graph.list_transforms()
+        self.assertEqual(len(transforms), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_rebased_unit.py

@@ -0,0 +1,184 @@
+# (c) 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for RebasedUnit.
+
+Verifies that units transformed by a BasisTransform preserve
+provenance while exposing the rebased dimension.
+"""
+
+import unittest
+from fractions import Fraction
+
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    RebasedUnit,
+    Unit,
+    UnitSystem,
+)
+from ucon import units
+
+
+class TestRebasedUnitConstruction(unittest.TestCase):
+    """Test RebasedUnit construction."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_valid_construction(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.original, units.foot)
+        self.assertEqual(rebased.rebased_dimension, Dimension.length)
+        self.assertEqual(rebased.basis_transform, self.bt)
+
+    def test_dimension_property(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.dimension, Dimension.length)
+
+    def test_name_property(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.name, "foot")
+
+
+class TestRebasedUnitEquality(unittest.TestCase):
+    """Test RebasedUnit equality and hashing."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_equal_rebased_units(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(r1, r2)
+
+    def test_hashable(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(hash(r1), hash(r2))
+        self.assertEqual(len({r1, r2}), 1)
+
+    def test_different_original_not_equal(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.inch,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertNotEqual(r1, r2)
+
+
+class TestRebasedUnitImmutability(unittest.TestCase):
+    """Test that RebasedUnit is immutable."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_frozen_dataclass(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        with self.assertRaises(AttributeError):
+            rebased.original = units.meter
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_uncertainty.py

@@ -0,0 +1,264 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for v0.5.x uncertainty propagation.
+
+Tests Number construction with uncertainty, display formatting,
+arithmetic propagation, and conversion propagation.
+"""
+
+import math
+import unittest
+
+from ucon import units, Scale
+from ucon.core import Number, UnitProduct
+
+
+class TestUncertaintyConstruction(unittest.TestCase):
+    """Test constructing Numbers with uncertainty."""
+
+    def test_number_with_uncertainty(self):
+        n = units.meter(1.234, uncertainty=0.005)
+        self.assertEqual(n.value, 1.234)
+        self.assertEqual(n.uncertainty, 0.005)
+
+    def test_number_without_uncertainty(self):
+        n = units.meter(1.234)
+        self.assertEqual(n.value, 1.234)
+        self.assertIsNone(n.uncertainty)
+
+    def test_unit_product_callable_with_uncertainty(self):
+        km = Scale.kilo * units.meter
+        n = km(5.0, uncertainty=0.1)
+        self.assertEqual(n.value, 5.0)
+        self.assertEqual(n.uncertainty, 0.1)
+
+    def test_composite_unit_with_uncertainty(self):
+        mps = units.meter / units.second
+        n = mps(10.0, uncertainty=0.5)
+        self.assertEqual(n.value, 10.0)
+        self.assertEqual(n.uncertainty, 0.5)
+
+
+class TestUncertaintyDisplay(unittest.TestCase):
+    """Test display formatting with uncertainty."""
+
+    def test_repr_with_uncertainty(self):
+        n = units.meter(1.234, uncertainty=0.005)
+        r = repr(n)
+        self.assertIn("1.234", r)
+        self.assertIn("±", r)
+        self.assertIn("0.005", r)
+        self.assertIn("m", r)
+
+    def test_repr_without_uncertainty(self):
+        n = units.meter(1.234)
+        r = repr(n)
+        self.assertIn("1.234", r)
+        self.assertNotIn("±", r)
+
+    def test_repr_dimensionless_with_uncertainty(self):
+        n = Number(quantity=0.5, uncertainty=0.01)
+        r = repr(n)
+        self.assertIn("0.5", r)
+        self.assertIn("±", r)
+        self.assertIn("0.01", r)
+
+
+class TestAdditionSubtractionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through addition and subtraction."""
+
+    def test_addition_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0, uncertainty=0.4)
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        # sqrt(0.3² + 0.4²) = sqrt(0.09 + 0.16) = sqrt(0.25) = 0.5
+        self.assertAlmostEqual(c.uncertainty, 0.5, places=9)
+
+    def test_subtraction_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0, uncertainty=0.4)
+        c = a - b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        # sqrt(0.3² + 0.4²) = 0.5
+        self.assertAlmostEqual(c.uncertainty, 0.5, places=9)
+
+    def test_addition_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0)  # no uncertainty
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.3, places=9)
+
+    def test_addition_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.meter(5.0)
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestMultiplicationPropagation(unittest.TestCase):
+    """Test uncertainty propagation through multiplication."""
+
+    def test_multiplication_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)  # 2% relative
+        b = units.meter(5.0, uncertainty=0.15)  # 3% relative
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        # relative: sqrt((0.2/10)² + (0.15/5)²) = sqrt(0.0004 + 0.0009) = sqrt(0.0013) ≈ 0.0361
+        # absolute: 50 * 0.0361 ≈ 1.803
+        expected = 50.0 * math.sqrt((0.2/10)**2 + (0.15/5)**2)
+        self.assertAlmostEqual(c.uncertainty, expected, places=6)
+
+    def test_multiplication_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        b = units.meter(5.0)  # no uncertainty
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        # Only a contributes: |c| * (δa/a) = 50 * 0.02 = 1.0
+        expected = 50.0 * (0.2/10)
+        self.assertAlmostEqual(c.uncertainty, expected, places=9)
+
+    def test_multiplication_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.meter(5.0)
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestDivisionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through division."""
+
+    def test_division_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)  # 2% relative
+        b = units.second(2.0, uncertainty=0.04)  # 2% relative
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        # relative: sqrt((0.2/10)² + (0.04/2)²) = sqrt(0.0004 + 0.0004) = sqrt(0.0008) ≈ 0.0283
+        # absolute: 5 * 0.0283 ≈ 0.1414
+        expected = 5.0 * math.sqrt((0.2/10)**2 + (0.04/2)**2)
+        self.assertAlmostEqual(c.uncertainty, expected, places=6)
+
+    def test_division_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        b = units.second(2.0)  # no uncertainty
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        expected = 5.0 * (0.2/10)
+        self.assertAlmostEqual(c.uncertainty, expected, places=9)
+
+    def test_division_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.second(2.0)
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestScalarOperations(unittest.TestCase):
+    """Test uncertainty propagation with scalar multiplication/division."""
+
+    def test_scalar_multiply_number(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        c = a * 3  # scalar multiplication
+        self.assertAlmostEqual(c.value, 30.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.6, places=9)
+
+    def test_scalar_divide_number(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        c = a / 2  # scalar division
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.1, places=9)
+
+
+class TestConversionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through unit conversion."""
+
+    def test_linear_conversion(self):
+        # meter to foot: factor ≈ 3.28084
+        length = units.meter(1.0, uncertainty=0.01)
+        length_ft = length.to(units.foot)
+        self.assertAlmostEqual(length_ft.value, 3.28084, places=4)
+        # uncertainty scales by same factor
+        self.assertAlmostEqual(length_ft.uncertainty, 0.01 * 3.28084, places=4)
+
+    def test_affine_conversion(self):
+        # Celsius to Kelvin: K = C + 273.15
+        # Derivative is 1, so uncertainty unchanged
+        temp = units.celsius(25.0, uncertainty=0.5)
+        temp_k = temp.to(units.kelvin)
+        self.assertAlmostEqual(temp_k.value, 298.15, places=9)
+        self.assertAlmostEqual(temp_k.uncertainty, 0.5, places=9)
+
+    def test_fahrenheit_to_celsius(self):
+        # F to C: C = (F - 32) * 5/9
+        # Derivative is 5/9 ≈ 0.5556
+        temp = units.fahrenheit(100.0, uncertainty=1.0)
+        temp_c = temp.to(units.celsius)
+        self.assertAlmostEqual(temp_c.value, 37.7778, places=3)
+        self.assertAlmostEqual(temp_c.uncertainty, 1.0 * (5/9), places=6)
+
+    def test_conversion_without_uncertainty(self):
+        length = units.meter(1.0)
+        length_ft = length.to(units.foot)
+        self.assertIsNone(length_ft.uncertainty)
+
+
+class TestEdgeCases(unittest.TestCase):
+    """Test edge cases for uncertainty handling."""
+
+    def test_zero_uncertainty(self):
+        a = units.meter(10.0, uncertainty=0.0)
+        b = units.meter(5.0, uncertainty=0.0)
+        c = a + b
+        self.assertAlmostEqual(c.uncertainty, 0.0, places=9)
+
+    def test_very_small_uncertainty(self):
+        a = units.meter(10.0, uncertainty=1e-15)
+        b = units.meter(5.0, uncertainty=1e-15)
+        c = a * b
+        self.assertIsNotNone(c.uncertainty)
+        self.assertGreater(c.uncertainty, 0)
+
+    def test_uncertainty_preserved_through_simplify(self):
+        km = Scale.kilo * units.meter
+        n = km(5.0, uncertainty=0.1)
+        simplified = n.simplify()
+        self.assertAlmostEqual(simplified.value, 5000.0, places=9)
+        # uncertainty also scales
+        self.assertAlmostEqual(simplified.uncertainty, 100.0, places=9)
+
+
+class TestMapDerivative(unittest.TestCase):
+    """Test Map.derivative() implementations."""
+
+    def test_linear_map_derivative(self):
+        from ucon.maps import LinearMap
+        m = LinearMap(3.28084)
+        self.assertAlmostEqual(m.derivative(0), 3.28084, places=9)
+        self.assertAlmostEqual(m.derivative(100), 3.28084, places=9)
+
+    def test_affine_map_derivative(self):
+        from ucon.maps import AffineMap
+        m = AffineMap(5/9, -32 * 5/9)  # F to C
+        self.assertAlmostEqual(m.derivative(0), 5/9, places=9)
+        self.assertAlmostEqual(m.derivative(100), 5/9, places=9)
+
+    def test_composed_map_derivative(self):
+        from ucon.maps import LinearMap, AffineMap
+        # Compose: first scale by 2, then add 10
+        inner = LinearMap(2)
+        outer = AffineMap(1, 10)
+        composed = outer @ inner
+        # d/dx [1*(2x) + 10] = 2
+        self.assertAlmostEqual(composed.derivative(0), 2, places=9)
+        self.assertAlmostEqual(composed.derivative(5), 2, places=9)
+
+
+if __name__ == "__main__":
+    unittest.main()