Move EC tests to pytest fully.

1 files changed, 157 insertions, 162 deletions

diff --git a/test/ec/test_curve.py b/test/ec/test_curve.py
index bc0cdaf..cd0639a 100644
--- a/test/ec/test_curve.py
+++ b/test/ec/test_curve.py
@@ -1,192 +1,187 @@
 from binascii import unhexlify
-from unittest import TestCase
+import pytest
 
 from pyecsca.ec.coordinates import AffineCoordinateModel
 from pyecsca.ec.curve import EllipticCurve
 from pyecsca.ec.error import UnsatisfiedAssumptionError
-from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.model import MontgomeryModel
 from pyecsca.ec.point import Point, InfinityPoint
 
 
-class CurveTests(TestCase):
-    def setUp(self):
-        self.secp128r1 = get_params("secg", "secp128r1", "projective")
-        self.base = self.secp128r1.generator
-        self.affine_base = self.base.to_affine()
-        self.curve25519 = get_params("other", "Curve25519", "xz")
-        self.ed25519 = get_params("other", "Ed25519", "projective")
+def test_init(secp128r1):
+    with pytest.raises(ValueError):
+        EllipticCurve(
+            MontgomeryModel(),
+            secp128r1.curve.coordinate_model,
+            1,
+            InfinityPoint(secp128r1.curve.coordinate_model),
+            parameters={},
+        )
 
-    def test_init(self):
-        with self.assertRaises(ValueError):
-            EllipticCurve(
-                MontgomeryModel(),
-                self.secp128r1.curve.coordinate_model,
-                1,
-                InfinityPoint(self.secp128r1.curve.coordinate_model),
-                parameters={},
-            )
+    with pytest.raises(ValueError):
+        EllipticCurve(
+            secp128r1.curve.model,
+            secp128r1.curve.coordinate_model,
+            15,
+            InfinityPoint(secp128r1.curve.coordinate_model),
+            parameters={"c": 0},
+        )
 
-        with self.assertRaises(ValueError):
-            EllipticCurve(
-                self.secp128r1.curve.model,
-                self.secp128r1.curve.coordinate_model,
-                15,
-                InfinityPoint(self.secp128r1.curve.coordinate_model),
-                parameters={"c": 0},
-            )
+    with pytest.raises(ValueError):
+        EllipticCurve(
+            secp128r1.curve.model,
+            secp128r1.curve.coordinate_model,
+            15,
+            InfinityPoint(secp128r1.curve.coordinate_model),
+            parameters={"a": Mod(1, 5), "b": Mod(2, 5)},
+        )
 
-        with self.assertRaises(ValueError):
-            EllipticCurve(
-                self.secp128r1.curve.model,
-                self.secp128r1.curve.coordinate_model,
-                15,
-                InfinityPoint(self.secp128r1.curve.coordinate_model),
-                parameters={"a": Mod(1, 5), "b": Mod(2, 5)},
-            )
 
-    def test_to_coords(self):
-        affine = self.secp128r1.to_affine()
-        m1_coords = affine.curve.model.coordinates["projective-1"]
-        m3_coords = affine.curve.model.coordinates["projective-3"]
-        with self.assertRaises(UnsatisfiedAssumptionError):
-            affine.to_coords(m1_coords)
-        affine.to_coords(m3_coords)
+def test_to_coords(secp128r1):
+    affine = secp128r1.to_affine()
+    m1_coords = affine.curve.model.coordinates["projective-1"]
+    m3_coords = affine.curve.model.coordinates["projective-3"]
+    with pytest.raises(UnsatisfiedAssumptionError):
+        affine.to_coords(m1_coords)
+    affine.to_coords(m3_coords)
 
-    def test_to_affine(self):
-        affine = self.secp128r1.to_affine()
-        model = AffineCoordinateModel(affine.curve.model)
-        self.assertEqual(affine.curve.coordinate_model, model)
-        self.assertEqual(affine.generator.coordinate_model, model)
 
-    def test_is_neutral(self):
-        self.assertTrue(
-            self.secp128r1.curve.is_neutral(
-                InfinityPoint(self.secp128r1.curve.coordinate_model)
-            )
-        )
+def test_to_affine(secp128r1):
+    affine = secp128r1.to_affine()
+    model = AffineCoordinateModel(affine.curve.model)
+    assert affine.curve.coordinate_model == model
+    assert affine.generator.coordinate_model == model
 
-    def test_is_on_curve(self):
-        self.assertTrue(self.secp128r1.curve.is_on_curve(self.secp128r1.curve.neutral))
-        pt = Point(
-            self.secp128r1.curve.coordinate_model,
-            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
-            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
-            Z=Mod(1, self.secp128r1.curve.prime),
-        )
-        self.assertTrue(self.secp128r1.curve.is_on_curve(pt))
-        self.assertTrue(self.secp128r1.curve.is_on_curve(pt.to_affine()))
-        other = Point(
-            self.secp128r1.curve.coordinate_model,
-            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
-            Y=Mod(0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, self.secp128r1.curve.prime),
-            Z=Mod(1, self.secp128r1.curve.prime),
-        )
-        self.assertFalse(self.secp128r1.curve.is_on_curve(other))
-        self.assertFalse(self.secp128r1.curve.is_on_curve(self.curve25519.generator))
 
-    def test_affine_add(self):
-        pt = Point(
-            AffineCoordinateModel(self.secp128r1.curve.model),
-            x=Mod(0xEB916224EDA4FB356421773573297C15, self.secp128r1.curve.prime),
-            y=Mod(0xBCDAF32A2C08FD4271228FEF35070848, self.secp128r1.curve.prime),
-        )
-        self.assertIsNotNone(self.secp128r1.curve.affine_add(self.affine_base, pt))
+def test_is_neutral(secp128r1):
+    assert secp128r1.curve.is_neutral(
+        InfinityPoint(secp128r1.curve.coordinate_model)
+    )
 
-        added = self.secp128r1.curve.affine_add(self.affine_base, self.affine_base)
-        doubled = self.secp128r1.curve.affine_double(self.affine_base)
-        self.assertEqual(added, doubled)
-        self.assertEqual(
-            self.secp128r1.curve.affine_add(self.secp128r1.curve.neutral, pt), pt
-        )
-        self.assertEqual(
-            self.secp128r1.curve.affine_add(pt, self.secp128r1.curve.neutral), pt
-        )
 
-    def test_affine_double(self):
-        self.assertIsNotNone(self.secp128r1.curve.affine_double(self.affine_base))
-        self.assertEqual(
-            self.secp128r1.curve.affine_double(self.secp128r1.curve.neutral),
-            self.secp128r1.curve.neutral,
-        )
+def test_is_on_curve(secp128r1, curve25519):
+    assert secp128r1.curve.is_on_curve(secp128r1.curve.neutral)
+    pt = Point(
+        secp128r1.curve.coordinate_model,
+        X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, secp128r1.curve.prime),
+        Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, secp128r1.curve.prime),
+        Z=Mod(1, secp128r1.curve.prime),
+    )
+    assert secp128r1.curve.is_on_curve(pt)
+    assert secp128r1.curve.is_on_curve(pt.to_affine())
+    other = Point(
+        secp128r1.curve.coordinate_model,
+        X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, secp128r1.curve.prime),
+        Y=Mod(0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, secp128r1.curve.prime),
+        Z=Mod(1, secp128r1.curve.prime),
+    )
+    assert not secp128r1.curve.is_on_curve(other)
+    assert not secp128r1.curve.is_on_curve(curve25519.generator)
 
-    def test_affine_negate(self):
-        self.assertIsNotNone(self.secp128r1.curve.affine_negate(self.affine_base))
-        self.assertEqual(
-            self.secp128r1.curve.affine_negate(self.secp128r1.curve.neutral),
-            self.secp128r1.curve.neutral,
-        )
-        with self.assertRaises(ValueError):
-            self.secp128r1.curve.affine_negate(self.base)
-        with self.assertRaises(ValueError):
-            self.secp128r1.curve.affine_negate(self.curve25519.generator)
 
-    def test_affine_multiply(self):
-        expected = self.affine_base
-        expected = self.secp128r1.curve.affine_double(expected)
-        expected = self.secp128r1.curve.affine_double(expected)
-        expected = self.secp128r1.curve.affine_add(expected, self.affine_base)
-        expected = self.secp128r1.curve.affine_double(expected)
-        self.assertEqual(
-            self.secp128r1.curve.affine_multiply(self.affine_base, 10), expected
-        )
-        self.assertEqual(
-            self.secp128r1.curve.affine_multiply(self.secp128r1.curve.neutral, 10),
-            self.secp128r1.curve.neutral,
-        )
-        with self.assertRaises(ValueError):
-            self.secp128r1.curve.affine_multiply(self.base, 10)
-        with self.assertRaises(ValueError):
-            self.secp128r1.curve.affine_multiply(self.curve25519.generator, 10)
+def test_affine_add(secp128r1):
+    pt = Point(
+        AffineCoordinateModel(secp128r1.curve.model),
+        x=Mod(0xEB916224EDA4FB356421773573297C15, secp128r1.curve.prime),
+        y=Mod(0xBCDAF32A2C08FD4271228FEF35070848, secp128r1.curve.prime),
+    )
+    affine_base = secp128r1.generator.to_affine()
+    assert secp128r1.curve.affine_add(affine_base, pt) is not None
 
-    def test_affine_neutral(self):
-        self.assertIsNone(self.secp128r1.curve.affine_neutral)
-        self.assertIsNone(self.curve25519.curve.affine_neutral)
-        self.assertIsNotNone(self.ed25519.curve.affine_neutral)
+    added = secp128r1.curve.affine_add(affine_base, affine_base)
+    doubled = secp128r1.curve.affine_double(affine_base)
+    assert added == doubled
+    assert secp128r1.curve.affine_add(secp128r1.curve.neutral, pt) == pt
+    assert secp128r1.curve.affine_add(pt, secp128r1.curve.neutral) == pt
 
-    def test_affine_random(self):
-        for params in [self.secp128r1, self.curve25519, self.ed25519]:
-            for _ in range(20):
-                pt = params.curve.affine_random()
-                self.assertIsNotNone(pt)
-                self.assertTrue(params.curve.is_on_curve(pt))
 
-    def test_neutral_is_affine(self):
-        self.assertFalse(self.secp128r1.curve.neutral_is_affine)
-        self.assertFalse(self.curve25519.curve.neutral_is_affine)
-        self.assertTrue(self.ed25519.curve.neutral_is_affine)
+def test_affine_double(secp128r1):
+    affine_base = secp128r1.generator.to_affine()
+    assert secp128r1.curve.affine_double(affine_base) is not None
+    assert secp128r1.curve.affine_double(secp128r1.curve.neutral) == \
+           secp128r1.curve.neutral
 
-    def test_eq(self):
-        self.assertEqual(self.secp128r1.curve, self.secp128r1.curve)
-        self.assertNotEqual(self.secp128r1.curve, self.curve25519.curve)
-        self.assertNotEqual(self.secp128r1.curve, None)
 
-    def test_decode(self):
-        affine_curve = self.secp128r1.curve.to_affine()
-        affine_point = self.secp128r1.generator.to_affine()
-        decoded = affine_curve.decode_point(bytes(affine_point))
-        self.assertEqual(decoded, affine_point)
+def test_affine_negate(secp128r1, curve25519):
+    affine_base = secp128r1.generator.to_affine()
+    assert secp128r1.curve.affine_negate(affine_base) is not None
+    assert secp128r1.curve.affine_negate(secp128r1.curve.neutral) == \
+           secp128r1.curve.neutral
+    with pytest.raises(ValueError):
+        secp128r1.curve.affine_negate(secp128r1.generator)
+    with pytest.raises(ValueError):
+        secp128r1.curve.affine_negate(curve25519.generator)
 
-        affine_compressed_bytes = unhexlify("03161ff7528b899b2d0c28607ca52c5b86")
-        decoded_compressed = affine_curve.decode_point(affine_compressed_bytes)
-        self.assertEqual(decoded_compressed, affine_point)
-        affine_compressed_bytes = unhexlify("02161ff7528b899b2d0c28607ca52c5b86")
-        decoded_compressed = affine_curve.decode_point(affine_compressed_bytes)
-        decoded_compressed = self.secp128r1.curve.affine_negate(decoded_compressed)
-        self.assertEqual(decoded_compressed, affine_point)
 
-        infinity_bytes = unhexlify("00")
-        decoded_infinity = affine_curve.decode_point(infinity_bytes)
-        self.assertEqual(affine_curve.neutral, decoded_infinity)
+def test_affine_multiply(secp128r1, curve25519):
+    affine_base = secp128r1.generator.to_affine()
+    expected = affine_base
+    expected = secp128r1.curve.affine_double(expected)
+    expected = secp128r1.curve.affine_double(expected)
+    expected = secp128r1.curve.affine_add(expected, affine_base)
+    expected = secp128r1.curve.affine_double(expected)
+    assert secp128r1.curve.affine_multiply(affine_base, 10) == expected
+    assert secp128r1.curve.affine_multiply(secp128r1.curve.neutral, 10) == \
+           secp128r1.curve.neutral
+    with pytest.raises(ValueError):
+        secp128r1.curve.affine_multiply(secp128r1.generator, 10)
+    with pytest.raises(ValueError):
+        secp128r1.curve.affine_multiply(curve25519.generator, 10)
 
-        with self.assertRaises(ValueError):
-            affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b"))
-        with self.assertRaises(ValueError):
-            affine_curve.decode_point(
-                unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b")
-            )
-        with self.assertRaises(ValueError):
-            affine_curve.decode_point(unhexlify("7a161ff7528b899b2d0c28607ca52c5b86"))
-        with self.assertRaises(ValueError):
-            affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b88"))
+
+def test_affine_neutral(secp128r1, curve25519, ed25519):
+    assert secp128r1.curve.affine_neutral is None
+    assert curve25519.curve.affine_neutral is None
+    assert ed25519.curve.affine_neutral is not None
+
+
+def test_neutral_is_affine(secp128r1, curve25519, ed25519):
+    assert not secp128r1.curve.neutral_is_affine
+    assert not curve25519.curve.neutral_is_affine
+    assert ed25519.curve.neutral_is_affine
+
+
+@pytest.mark.parametrize("curve_name", ["secp128r1", "curve25519", "ed25519"])
+def test_affine_random(curve_name, request):
+    params = request.getfixturevalue(curve_name)
+    for _ in range(20):
+        pt = params.curve.affine_random()
+        assert pt is not None
+        assert params.curve.is_on_curve(pt)
+
+
+def test_eq(secp128r1, curve25519):
+    assert secp128r1.curve == secp128r1.curve
+    assert secp128r1.curve != curve25519.curve
+    assert secp128r1.curve is not None
+
+
+def test_decode(secp128r1):
+    affine_curve = secp128r1.curve.to_affine()
+    affine_point = secp128r1.generator.to_affine()
+    decoded = affine_curve.decode_point(bytes(affine_point))
+    assert decoded == affine_point
+
+    affine_compressed_bytes = unhexlify("03161ff7528b899b2d0c28607ca52c5b86")
+    decoded_compressed = affine_curve.decode_point(affine_compressed_bytes)
+    assert decoded_compressed == affine_point
+    affine_compressed_bytes = unhexlify("02161ff7528b899b2d0c28607ca52c5b86")
+    decoded_compressed = affine_curve.decode_point(affine_compressed_bytes)
+    decoded_compressed = secp128r1.curve.affine_negate(decoded_compressed)
+    assert decoded_compressed == affine_point
+
+    infinity_bytes = unhexlify("00")
+    decoded_infinity = affine_curve.decode_point(infinity_bytes)
+    assert affine_curve.neutral == decoded_infinity
+
+    with pytest.raises(ValueError):
+        affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b"))
+    with pytest.raises(ValueError):
+        affine_curve.decode_point(
+            unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b")
+        )
+    with pytest.raises(ValueError):
+        affine_curve.decode_point(unhexlify("7a161ff7528b899b2d0c28607ca52c5b86"))
+    with pytest.raises(ValueError):
+        affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b88"))