Use black.

20 files changed, 722 insertions, 329 deletions

diff --git a/test/ec/perf_formula.py b/test/ec/perf_formula.py
index 9e651ae..2cc4513 100755
--- a/test/ec/perf_formula.py
+++ b/test/ec/perf_formula.py
@@ -9,9 +9,20 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=5000)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
@@ -19,22 +30,36 @@ def main(profiler, mod, operations, directory):
         coords = p256.curve.coordinate_model
         add = coords.formulas["add-2016-rcb"]
         dbl = coords.formulas["dbl-2016-rcb"]
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit doubling formula executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit doubling formula executions..."
+        )
         one_point = p256.generator
-        with Profiler(profiler, directory, f"formula_dbl2016rcb_p256_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_dbl2016rcb_p256_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 one_point = dbl(p256.curve.prime, one_point, **p256.curve.parameters)[0]
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit addition formula executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit addition formula executions..."
+        )
         other_point = p256.generator
-        with Profiler(profiler, directory, f"formula_add2016rcb_p256_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_add2016rcb_p256_{operations}_{mod}"
+        ):
             for _ in range(operations):
-                one_point = add(p256.curve.prime, one_point, other_point, **p256.curve.parameters)[0]
+                one_point = add(
+                    p256.curve.prime, one_point, other_point, **p256.curve.parameters
+                )[0]
         ed25519 = get_params("other", "Ed25519", "extended")
         ecoords = ed25519.curve.coordinate_model
         dblg = ecoords.formulas["mdbl-2008-hwcd"]
-        click.echo(f"Profiling {operations} {ed25519.curve.prime.bit_length()}-bit doubling formula executions (with assumption)...")
+        click.echo(
+            f"Profiling {operations} {ed25519.curve.prime.bit_length()}-bit doubling formula executions (with assumption)..."
+        )
         eone_point = ed25519.generator
-        with Profiler(profiler, directory, f"formula_mdbl2008hwcd_ed25519_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"formula_mdbl2008hwcd_ed25519_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 dblg(ed25519.curve.prime, eone_point, **ed25519.curve.parameters)
 
diff --git a/test/ec/perf_mod.py b/test/ec/perf_mod.py
index 37cf41b..49fe9a7 100755
--- a/test/ec/perf_mod.py
+++ b/test/ec/perf_mod.py
@@ -8,20 +8,33 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=100000)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
-        n = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
+        n = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
         a = Mod(0x11111111111111111111111111111111, n)
-        b = Mod(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, n)
+        b = Mod(0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB, n)
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular inverse...")
         with Profiler(profiler, directory, f"mod_256b_inverse_{operations}_{mod}"):
             for _ in range(operations):
                 a.inverse()
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit modular square root...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit modular square root..."
+        )
         with Profiler(profiler, directory, f"mod_256b_sqrt_{operations}_{mod}"):
             for _ in range(operations):
                 a.sqrt()
@@ -30,16 +43,20 @@ def main(profiler, mod, operations, directory):
         with Profiler(profiler, directory, f"mod_256b_multiply_{operations}_{mod}"):
             for _ in range(operations):
                 c = c * b
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit constant modular multiply...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit constant modular multiply..."
+        )
         c = a
-        with Profiler(profiler, directory, f"mod_256b_constmultiply_{operations}_{mod}"):
+        with Profiler(
+            profiler, directory, f"mod_256b_constmultiply_{operations}_{mod}"
+        ):
             for _ in range(operations):
                 c = c * 48006
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular square...")
         c = a
         with Profiler(profiler, directory, f"mod_256b_square_{operations}_{mod}"):
             for _ in range(operations):
-                c = c**2
+                c = c ** 2
         click.echo(f"Profiling {operations} {n.bit_length()}-bit modular add...")
         c = a
         with Profiler(profiler, directory, f"mod_256b_add_{operations}_{mod}"):
@@ -50,7 +67,9 @@ def main(profiler, mod, operations, directory):
         with Profiler(profiler, directory, f"mod_256b_subtract_{operations}_{mod}"):
             for _ in range(operations):
                 c = c - b
-        click.echo(f"Profiling {operations} {n.bit_length()}-bit modular quadratic residue checks...")
+        click.echo(
+            f"Profiling {operations} {n.bit_length()}-bit modular quadratic residue checks..."
+        )
         with Profiler(profiler, directory, f"mod_256b_isresidue_{operations}_{mod}"):
             for _ in range(operations):
                 a.is_residue()
diff --git a/test/ec/perf_mult.py b/test/ec/perf_mult.py
index 2ec82b0..36f004b 100755
--- a/test/ec/perf_mult.py
+++ b/test/ec/perf_mult.py
@@ -10,9 +10,20 @@ from utils import Profiler
 
 @click.command()
 @click.option("-p", "--profiler", type=click.Choice(("py", "c")), default="py")
-@click.option("-m", "--mod", type=click.Choice(("python", "gmp")), default="gmp" if has_gmp else "python")
+@click.option(
+    "-m",
+    "--mod",
+    type=click.Choice(("python", "gmp")),
+    default="gmp" if has_gmp else "python",
+)
 @click.option("-o", "--operations", type=click.INT, default=50)
-@click.option("-d", "--directory", type=click.Path(file_okay=False, dir_okay=True), default=None, envvar="DIR")
+@click.option(
+    "-d",
+    "--directory",
+    type=click.Path(file_okay=False, dir_okay=True),
+    default=None,
+    envvar="DIR",
+)
 def main(profiler, mod, operations, directory):
     with TemporaryConfig() as cfg:
         cfg.ec.mod_implementation = mod
@@ -21,12 +32,16 @@ def main(profiler, mod, operations, directory):
         add = coords.formulas["add-2016-rcb"]
         dbl = coords.formulas["dbl-2016-rcb"]
         mult = LTRMultiplier(add, dbl)
-        click.echo(f"Profiling {operations} {p256.curve.prime.bit_length()}-bit scalar multiplication executions...")
+        click.echo(
+            f"Profiling {operations} {p256.curve.prime.bit_length()}-bit scalar multiplication executions..."
+        )
         one_point = p256.generator
         with Profiler(profiler, directory, f"mult_ltr_rcb_p256_{operations}_{mod}"):
             for _ in range(operations):
                 mult.init(p256, one_point)
-                one_point = mult.multiply(0x71a55e0c1abb3a0e069419e0f837bc195f1b9545e69fc51e53c4d48d7fea3b1a)
+                one_point = mult.multiply(
+                    0x71A55E0C1ABB3A0E069419E0F837BC195F1B9545E69FC51E53C4D48D7FEA3B1A
+                )
         # ed25519 = get_params("other", "Ed25519", "extended")
         # ecoords = ed25519.curve.coordinate_model
         # dblg = ecoords.formulas["mdbl-2008-hwcd"]
diff --git a/test/ec/test_configuration.py b/test/ec/test_configuration.py
index 9c8e361..7603321 100644
--- a/test/ec/test_configuration.py
+++ b/test/ec/test_configuration.py
@@ -1,14 +1,20 @@
 from unittest import TestCase
 
-from pyecsca.ec.configuration import (all_configurations, HashType, RandomMod, Multiplication,
-                                      Squaring, Reduction, Inversion)
+from pyecsca.ec.configuration import (
+    all_configurations,
+    HashType,
+    RandomMod,
+    Multiplication,
+    Squaring,
+    Reduction,
+    Inversion,
+)
 from pyecsca.ec.model import ShortWeierstrassModel
 from pyecsca.ec.mult import LTRMultiplier
 from .utils import slow
 
 
 class ConfigurationTests(TestCase):
-
     def base_independents(self):
         return {
             "hash_type": HashType.SHA1,
@@ -16,7 +22,7 @@ class ConfigurationTests(TestCase):
             "mult": Multiplication.BASE,
             "sqr": Squaring.BASE,
             "red": Reduction.BASE,
-            "inv": Inversion.GCD
+            "inv": Inversion.GCD,
         }
 
     @slow
@@ -29,15 +35,23 @@ class ConfigurationTests(TestCase):
     def test_weierstrass_projective(self):
         model = ShortWeierstrassModel()
         coords = model.coordinates["projective"]
-        configs = list(all_configurations(model=model, coords=coords, **self.base_independents()))
+        configs = list(
+            all_configurations(model=model, coords=coords, **self.base_independents())
+        )
         self.assertEqual(len(configs), 1960)
 
     def test_mult_class(self):
         model = ShortWeierstrassModel()
         coords = model.coordinates["projective"]
         scalarmult = LTRMultiplier
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 560)
 
     def test_one(self):
@@ -50,16 +64,37 @@ class ConfigurationTests(TestCase):
             "scl": None,
             "always": True,
             "complete": False,
-            "short_circuit": True
+            "short_circuit": True,
         }
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
-        scalarmult = LTRMultiplier(coords.formulas["add-1998-cmo"], coords.formulas["dbl-1998-cmo"],
-                                   None, True, False, True)
-        configs = list(all_configurations(model=model, coords=coords, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        scalarmult = LTRMultiplier(
+            coords.formulas["add-1998-cmo"],
+            coords.formulas["dbl-1998-cmo"],
+            None,
+            True,
+            False,
+            True,
+        )
+        configs = list(
+            all_configurations(
+                model=model,
+                coords=coords,
+                scalarmult=scalarmult,
+                **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
-        configs = list(all_configurations(model=model, scalarmult=scalarmult,
-                                          **self.base_independents()))
+        configs = list(
+            all_configurations(
+                model=model, scalarmult=scalarmult, **self.base_independents()
+            )
+        )
         self.assertEqual(len(configs), 1)
diff --git a/test/ec/test_context.py b/test/ec/test_context.py
index 603369d..04dbc7d 100644
--- a/test/ec/test_context.py
+++ b/test/ec/test_context.py
@@ -1,7 +1,15 @@
 from unittest import TestCase
 
-from pyecsca.ec.context import (local, DefaultContext, NullContext, getcontext,
-                                setcontext, resetcontext, Tree, PathContext)
+from pyecsca.ec.context import (
+    local,
+    DefaultContext,
+    NullContext,
+    getcontext,
+    setcontext,
+    resetcontext,
+    Tree,
+    PathContext,
+)
 from pyecsca.ec.key_generation import KeygenAction, KeyGeneration
 from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import RandomModAction
@@ -9,7 +17,6 @@ from pyecsca.ec.mult import LTRMultiplier, ScalarMultiplicationAction
 
 
 class TreeTests(TestCase):
-
     def test_walk_by_key(self):
         tree = Tree()
         tree["a"] = Tree()
@@ -46,14 +53,16 @@ class TreeTests(TestCase):
 
 
 class ContextTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.base = self.secp128r1.generator
         self.coords = self.secp128r1.curve.coordinate_model
-        self.mult = LTRMultiplier(self.coords.formulas["add-1998-cmo"],
-                                  self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"],
-                                  always=True)
+        self.mult = LTRMultiplier(
+            self.coords.formulas["add-1998-cmo"],
+            self.coords.formulas["dbl-1998-cmo"],
+            self.coords.formulas["z"],
+            always=True,
+        )
         self.mult.init(self.secp128r1, self.base)
 
     def test_null(self):
diff --git a/test/ec/test_curve.py b/test/ec/test_curve.py
index c358c68..345d3de 100644
--- a/test/ec/test_curve.py
+++ b/test/ec/test_curve.py
@@ -19,55 +19,89 @@ class CurveTests(TestCase):
 
     def test_init(self):
         with self.assertRaises(ValueError):
-            EllipticCurve(MontgomeryModel(), self.secp128r1.curve.coordinate_model, 1,
-                          InfinityPoint(self.secp128r1.curve.coordinate_model), parameters={})
+            EllipticCurve(
+                MontgomeryModel(),
+                self.secp128r1.curve.coordinate_model,
+                1,
+                InfinityPoint(self.secp128r1.curve.coordinate_model),
+                parameters={},
+            )
 
         with self.assertRaises(ValueError):
-            EllipticCurve(self.secp128r1.curve.model, self.secp128r1.curve.coordinate_model, 15,
-                          InfinityPoint(self.secp128r1.curve.coordinate_model), parameters={"c": 0})
+            EllipticCurve(
+                self.secp128r1.curve.model,
+                self.secp128r1.curve.coordinate_model,
+                15,
+                InfinityPoint(self.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={"a": Mod(1, 5), "b": Mod(2, 5)})
+            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_is_neutral(self):
-        self.assertTrue(self.secp128r1.curve.is_neutral(InfinityPoint(self.secp128r1.curve.coordinate_model)))
+        self.assertTrue(
+            self.secp128r1.curve.is_neutral(
+                InfinityPoint(self.secp128r1.curve.coordinate_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))
+        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))
+        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))
+        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))
 
         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)
+        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)
+        self.assertEqual(
+            self.secp128r1.curve.affine_double(self.secp128r1.curve.neutral),
+            self.secp128r1.curve.neutral,
+        )
 
     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)
+        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):
@@ -79,8 +113,13 @@ class CurveTests(TestCase):
         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)
+        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):
@@ -129,7 +168,9 @@ class CurveTests(TestCase):
         with self.assertRaises(ValueError):
             affine_curve.decode_point(unhexlify("03161ff7528b899b2d0c28607ca52c5b"))
         with self.assertRaises(ValueError):
-            affine_curve.decode_point(unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b"))
+            affine_curve.decode_point(
+                unhexlify("04161ff7528b899b2d0c28607ca52c5b2c5b2c5b2c5b")
+            )
         with self.assertRaises(ValueError):
             affine_curve.decode_point(unhexlify("7a161ff7528b899b2d0c28607ca52c5b86"))
         with self.assertRaises(ValueError):
diff --git a/test/ec/test_formula.py b/test/ec/test_formula.py
index ec585ad..ffae4c4 100644
--- a/test/ec/test_formula.py
+++ b/test/ec/test_formula.py
@@ -10,20 +10,25 @@ from pyecsca.ec.point import Point
 
 
 class FormulaTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mdbl = self.secp128r1.curve.coordinate_model.formulas["mdbl-2007-bl"]
         self.jac_secp128r1 = get_params("secg", "secp128r1", "jacobian")
-        self.jac_dbl = self.jac_secp128r1.curve.coordinate_model.formulas["dbl-1998-hnm"]
+        self.jac_dbl = self.jac_secp128r1.curve.coordinate_model.formulas[
+            "dbl-1998-hnm"
+        ]
 
     def test_wrong_call(self):
         with self.assertRaises(ValueError):
             self.add(self.secp128r1.curve.prime)
         with self.assertRaises(ValueError):
-            self.add(self.secp128r1.curve.prime, self.secp128r1.generator.to_affine(), self.secp128r1.generator.to_affine())
+            self.add(
+                self.secp128r1.curve.prime,
+                self.secp128r1.generator.to_affine(),
+                self.secp128r1.generator.to_affine(),
+            )
 
     def test_indices(self):
         self.assertEqual(self.add.input_index, 1)
@@ -47,33 +52,56 @@ class FormulaTests(TestCase):
         self.assertEqual(self.add.num_addsubs, 10)
 
     def test_assumptions(self):
-        res = self.mdbl(self.secp128r1.curve.prime, self.secp128r1.generator, **self.secp128r1.curve.parameters)
+        res = self.mdbl(
+            self.secp128r1.curve.prime,
+            self.secp128r1.generator,
+            **self.secp128r1.curve.parameters
+        )
         self.assertIsNotNone(res)
 
-        coords = {name: value * 5 for name, value in self.secp128r1.generator.coords.items()}
+        coords = {
+            name: value * 5 for name, value in self.secp128r1.generator.coords.items()
+        }
         other = Point(self.secp128r1.generator.coordinate_model, **coords)
         with self.assertRaises(UnsatisfiedAssumptionError):
-            self.mdbl(self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters)
+            self.mdbl(
+                self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters
+            )
         with TemporaryConfig() as cfg:
             cfg.ec.unsatisfied_formula_assumption_action = "ignore"
-            pt = self.mdbl(self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters)
+            pt = self.mdbl(
+                self.secp128r1.curve.prime, other, **self.secp128r1.curve.parameters
+            )
             self.assertIsNotNone(pt)
 
     def test_parameters(self):
-        res = self.jac_dbl(self.secp128r1.curve.prime, self.jac_secp128r1.generator, **self.jac_secp128r1.curve.parameters)
+        res = self.jac_dbl(
+            self.secp128r1.curve.prime,
+            self.jac_secp128r1.generator,
+            **self.jac_secp128r1.curve.parameters
+        )
         self.assertIsNotNone(res)
 
     def test_symbolic(self):
         p = self.secp128r1.curve.prime
         k = FF(p)
         coords = self.secp128r1.curve.coordinate_model
-        sympy_params = {key: SymbolicMod(k(int(value)), p) for key, value in self.secp128r1.curve.parameters.items()}
-        symbolic_point = Point(coords, **{key: SymbolicMod(symbols(key), p) for key in coords.variables})
+        sympy_params = {
+            key: SymbolicMod(k(int(value)), p)
+            for key, value in self.secp128r1.curve.parameters.items()
+        }
+        symbolic_point = Point(
+            coords, **{key: SymbolicMod(symbols(key), p) for key in coords.variables}
+        )
         symbolic_double = self.dbl(p, symbolic_point, **sympy_params)[0]
-        generator_double = self.dbl(p, self.secp128r1.generator, **self.secp128r1.curve.parameters)[0]
+        generator_double = self.dbl(
+            p, self.secp128r1.generator, **self.secp128r1.curve.parameters
+        )[0]
         for outer_var in coords.variables:
             symbolic_val = getattr(symbolic_double, outer_var).x
             generator_val = getattr(generator_double, outer_var).x
             for inner_var in coords.variables:
-                symbolic_val = symbolic_val.subs(inner_var, k(getattr(self.secp128r1.generator, inner_var).x))
+                symbolic_val = symbolic_val.subs(
+                    inner_var, k(getattr(self.secp128r1.generator, inner_var).x)
+                )
             self.assertEqual(Mod(int(symbolic_val), p), Mod(generator_val, p))
diff --git a/test/ec/test_key_agreement.py b/test/ec/test_key_agreement.py
index cbdb1c8..240c174 100644
--- a/test/ec/test_key_agreement.py
+++ b/test/ec/test_key_agreement.py
@@ -3,33 +3,40 @@ from unittest import TestCase
 from parameterized import parameterized
 
 from pyecsca.ec.params import get_params
-from pyecsca.ec.key_agreement import (ECDH_NONE, ECDH_SHA1, ECDH_SHA224, ECDH_SHA256, ECDH_SHA384,
-                                      ECDH_SHA512)
+from pyecsca.ec.key_agreement import (
+    ECDH_NONE,
+    ECDH_SHA1,
+    ECDH_SHA224,
+    ECDH_SHA256,
+    ECDH_SHA384,
+    ECDH_SHA512,
+)
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.mult import LTRMultiplier
 
 
 class KeyAgreementTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mult = LTRMultiplier(self.add, self.dbl)
-        self.priv_a = Mod(0xdeadbeef, self.secp128r1.order)
+        self.priv_a = Mod(0xDEADBEEF, self.secp128r1.order)
         self.mult.init(self.secp128r1, self.secp128r1.generator)
         self.pub_a = self.mult.multiply(int(self.priv_a))
-        self.priv_b = Mod(0xcafebabe, self.secp128r1.order)
+        self.priv_b = Mod(0xCAFEBABE, self.secp128r1.order)
         self.pub_b = self.mult.multiply(int(self.priv_b))
 
-    @parameterized.expand([
-        ("NONE", ECDH_NONE),
-        ("SHA1", ECDH_SHA1),
-        ("SHA224", ECDH_SHA224),
-        ("SHA256", ECDH_SHA256),
-        ("SHA384", ECDH_SHA384),
-        ("SHA512", ECDH_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("NONE", ECDH_NONE),
+            ("SHA1", ECDH_SHA1),
+            ("SHA224", ECDH_SHA224),
+            ("SHA256", ECDH_SHA256),
+            ("SHA384", ECDH_SHA384),
+            ("SHA512", ECDH_SHA512),
+        ]
+    )
     def test_all(self, name, algo):
         result_ab = algo(self.mult, self.secp128r1, self.pub_a, self.priv_b).perform()
         result_ba = algo(self.mult, self.secp128r1, self.pub_b, self.priv_a).perform()
diff --git a/test/ec/test_key_generation.py b/test/ec/test_key_generation.py
index f0d926c..7eb26f0 100644
--- a/test/ec/test_key_generation.py
+++ b/test/ec/test_key_generation.py
@@ -6,7 +6,6 @@ from pyecsca.ec.mult import LTRMultiplier
 
 
 class KeyGenerationTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
diff --git a/test/ec/test_mod.py b/test/ec/test_mod.py
index a21ef06..2c45447 100644
--- a/test/ec/test_mod.py
+++ b/test/ec/test_mod.py
@@ -1,13 +1,27 @@
 from sympy import FF, symbols
 from unittest import TestCase
 
-from pyecsca.ec.mod import Mod, gcd, extgcd, Undefined, miller_rabin, has_gmp, RawMod, SymbolicMod, jacobi
-from pyecsca.ec.error import NonInvertibleError, NonResidueError, NonInvertibleWarning, NonResidueWarning
+from pyecsca.ec.mod import (
+    Mod,
+    gcd,
+    extgcd,
+    Undefined,
+    miller_rabin,
+    has_gmp,
+    RawMod,
+    SymbolicMod,
+    jacobi,
+)
+from pyecsca.ec.error import (
+    NonInvertibleError,
+    NonResidueError,
+    NonInvertibleWarning,
+    NonResidueWarning,
+)
 from pyecsca.misc.cfg import getconfig, TemporaryConfig
 
 
 class ModTests(TestCase):
-
     def test_gcd(self):
         self.assertEqual(gcd(15, 20), 5)
         self.assertEqual(extgcd(15, 0), (1, 0, 15))
@@ -15,20 +29,33 @@ class ModTests(TestCase):
 
     def test_jacobi(self):
         self.assertEqual(jacobi(5, 1153486465415345646578465454655646543248656451), 1)
-        self.assertEqual(jacobi(564786456646845, 46874698564153465453246546545456849797895547657), -1)
-        self.assertEqual(jacobi(564786456646845, 46874698564153465453246546545456849797895), 0)
+        self.assertEqual(
+            jacobi(564786456646845, 46874698564153465453246546545456849797895547657), -1
+        )
+        self.assertEqual(
+            jacobi(564786456646845, 46874698564153465453246546545456849797895), 0
+        )
 
     def test_miller_rabin(self):
         self.assertTrue(miller_rabin(2))
         self.assertTrue(miller_rabin(3))
         self.assertTrue(miller_rabin(5))
         self.assertFalse(miller_rabin(8))
-        self.assertTrue(miller_rabin(0xe807561107ccf8fa82af74fd492543a918ca2e9c13750233a9))
-        self.assertFalse(miller_rabin(0x6f6889deb08da211927370810f026eb4c17b17755f72ea005))
+        self.assertTrue(
+            miller_rabin(0xE807561107CCF8FA82AF74FD492543A918CA2E9C13750233A9)
+        )
+        self.assertFalse(
+            miller_rabin(0x6F6889DEB08DA211927370810F026EB4C17B17755F72EA005)
+        )
 
     def test_inverse(self):
-        p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
-        self.assertEqual(Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).inverse(), Mod(0x1cb2e5274bba085c4ca88eede75ae77949e7a410c80368376e97ab22eb590f9d, p))
+        p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
+        self.assertEqual(
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).inverse(),
+            Mod(0x1CB2E5274BBA085C4CA88EEDE75AE77949E7A410C80368376E97AB22EB590F9D, p),
+        )
         with self.assertRaises(NonInvertibleError):
             Mod(0, p).inverse()
         with self.assertRaises(NonInvertibleError):
@@ -50,22 +77,42 @@ class ModTests(TestCase):
         self.assertTrue(Mod(1, 2).is_residue())
 
     def test_sqrt(self):
-        p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
-        self.assertIn(Mod(0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc, p).sqrt(), (0x9add512515b70d9ec471151c1dec46625cd18b37bde7ca7fb2c8b31d7033599d, 0x6522aed9ea48f2623b8eeae3e213b99da32e74c9421835804d374ce28fcca662))
+        p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
+        self.assertIn(
+            Mod(
+                0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC, p
+            ).sqrt(),
+            (
+                0x9ADD512515B70D9EC471151C1DEC46625CD18B37BDE7CA7FB2C8B31D7033599D,
+                0x6522AED9EA48F2623B8EEAE3E213B99DA32E74C9421835804D374CE28FCCA662,
+            ),
+        )
         with self.assertRaises(NonResidueError):
-            Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).sqrt()
         getconfig().ec.non_residue_action = "warning"
         with self.assertRaises(NonResidueWarning):
-            Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+            Mod(
+                0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+            ).sqrt()
         getconfig().ec.non_residue_action = "ignore"
-        Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+        Mod(
+            0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1, p
+        ).sqrt()
         with TemporaryConfig() as cfg:
             cfg.ec.non_residue_action = "warning"
             with self.assertRaises(NonResidueWarning):
-                Mod(0x702bdafd3c1c837b23a1cb196ed7f9fadb333c5cfe4a462be32adcd67bfb6ac1, p).sqrt()
+                Mod(
+                    0x702BDAFD3C1C837B23A1CB196ED7F9FADB333C5CFE4A462BE32ADCD67BFB6AC1,
+                    p,
+                ).sqrt()
         self.assertEqual(Mod(0, p).sqrt(), Mod(0, p))
-        q = 0x75d44fee9a71841ae8403c0c251fbad
-        self.assertIn(Mod(0x591e0db18cf1bd81a11b2985a821eb3, q).sqrt(), (0x113b41a1a2b73f636e73be3f9a3716e, 0x64990e4cf7ba44b779cc7dcc8ae8a3f))
+        q = 0x75D44FEE9A71841AE8403C0C251FBAD
+        self.assertIn(
+            Mod(0x591E0DB18CF1BD81A11B2985A821EB3, q).sqrt(),
+            (0x113B41A1A2B73F636E73BE3F9A3716E, 0x64990E4CF7BA44B779CC7DCC8AE8A3F),
+        )
         getconfig().ec.non_residue_action = "error"
 
     def test_eq(self):
@@ -77,9 +124,9 @@ class ModTests(TestCase):
 
     def test_pow(self):
         a = Mod(5, 7)
-        self.assertEqual(a**(-1), a.inverse())
-        self.assertEqual(a**0, Mod(1, 7))
-        self.assertEqual(a**(-2), a.inverse()**2)
+        self.assertEqual(a ** (-1), a.inverse())
+        self.assertEqual(a ** 0, Mod(1, 7))
+        self.assertEqual(a ** (-2), a.inverse() ** 2)
 
     def test_wrong_mod(self):
         a = Mod(5, 7)
@@ -91,7 +138,7 @@ class ModTests(TestCase):
         a = Mod(5, 7)
         c = Mod(4, 11)
         with self.assertRaises(TypeError):
-            a**c
+            a ** c
 
     def test_other(self):
         a = Mod(5, 7)
@@ -116,7 +163,15 @@ class ModTests(TestCase):
     def test_undefined(self):
         u = Undefined()
         for k, meth in u.__class__.__dict__.items():
-            if k in ("__module__", "__new__", "__init__", "__doc__", "__hash__", "__abstractmethods__", "_abc_impl"):
+            if k in (
+                "__module__",
+                "__new__",
+                "__init__",
+                "__doc__",
+                "__hash__",
+                "__abstractmethods__",
+                "_abc_impl",
+            ):
                 continue
             args = [5 for _ in range(meth.__code__.co_argcount - 1)]
             if k == "__repr__":
diff --git a/test/ec/test_model.py b/test/ec/test_model.py
index b9d4383..d1c03c3 100644
--- a/test/ec/test_model.py
+++ b/test/ec/test_model.py
@@ -1,11 +1,14 @@
 from unittest import TestCase
 
-from pyecsca.ec.model import (ShortWeierstrassModel, MontgomeryModel, EdwardsModel,
-                              TwistedEdwardsModel)
+from pyecsca.ec.model import (
+    ShortWeierstrassModel,
+    MontgomeryModel,
+    EdwardsModel,
+    TwistedEdwardsModel,
+)
 
 
 class CurveModelTests(TestCase):
-
     def test_load(self):
         self.assertGreater(len(ShortWeierstrassModel().coordinates), 0)
         self.assertGreater(len(MontgomeryModel().coordinates), 0)
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index 19db2b2..5200520 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -3,16 +3,21 @@ from unittest import TestCase
 from parameterized import parameterized
 
 from pyecsca.ec.params import get_params
-from pyecsca.ec.mult import (LTRMultiplier, RTLMultiplier, LadderMultiplier, BinaryNAFMultiplier,
-                             WindowNAFMultiplier, SimpleLadderMultiplier,
-                             DifferentialLadderMultiplier,
-                             CoronMultiplier)
+from pyecsca.ec.mult import (
+    LTRMultiplier,
+    RTLMultiplier,
+    LadderMultiplier,
+    BinaryNAFMultiplier,
+    WindowNAFMultiplier,
+    SimpleLadderMultiplier,
+    DifferentialLadderMultiplier,
+    CoronMultiplier,
+)
 from pyecsca.ec.point import InfinityPoint
 from .utils import cartesian
 
 
 class ScalarMultiplierTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.base = self.secp128r1.generator
@@ -31,9 +36,13 @@ class ScalarMultiplierTests(TestCase):
         else:
             assert one.equals(other)
 
-    def do_basic_test(self, mult_class, params, base, add, dbl, scale, neg=None, **kwargs):
-        mult = mult_class(*self.get_formulas(params.curve.coordinate_model, add, dbl, neg, scale),
-                          **kwargs)
+    def do_basic_test(
+        self, mult_class, params, base, add, dbl, scale, neg=None, **kwargs
+    ):
+        mult = mult_class(
+            *self.get_formulas(params.curve.coordinate_model, add, dbl, neg, scale),
+            **kwargs
+        )
         mult.init(params, base)
         res = mult.multiply(314)
         other = mult.multiply(157)
@@ -44,71 +53,120 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(InfinityPoint(params.curve.coordinate_model), mult.multiply(0))
         return res
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_rtl(self, name, add, dbl, scale):
         self.do_basic_test(RTLMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_ltr(self, name, add, dbl, scale):
-        a = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale)
-        b = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               always=True)
-        c = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               complete=False)
-        d = self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale,
-                               always=True,
-                               complete=False)
+        a = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale
+        )
+        b = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, always=True
+        )
+        c = self.do_basic_test(
+            LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, complete=False
+        )
+        d = self.do_basic_test(
+            LTRMultiplier,
+            self.secp128r1,
+            self.base,
+            add,
+            dbl,
+            scale,
+            always=True,
+            complete=False,
+        )
         self.assertPointEquality(a, b, scale)
         self.assertPointEquality(b, c, scale)
         self.assertPointEquality(c, d, scale)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_coron(self, name, add, dbl, scale):
         self.do_basic_test(CoronMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     def test_ladder(self):
-        a = self.do_basic_test(LadderMultiplier, self.curve25519, self.base25519, "ladd-1987-m",
-                               "dbl-1987-m", "scale")
-        b = self.do_basic_test(LadderMultiplier, self.curve25519, self.base25519, "ladd-1987-m",
-                               "dbl-1987-m", "scale", complete=False)
+        a = self.do_basic_test(
+            LadderMultiplier,
+            self.curve25519,
+            self.base25519,
+            "ladd-1987-m",
+            "dbl-1987-m",
+            "scale",
+        )
+        b = self.do_basic_test(
+            LadderMultiplier,
+            self.curve25519,
+            self.base25519,
+            "ladd-1987-m",
+            "dbl-1987-m",
+            "scale",
+            complete=False,
+        )
         self.assertPointEquality(a, b, True)
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", None),
+        ]
+    )
     def test_simple_ladder(self, name, add, dbl, scale):
-        self.do_basic_test(SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale)
+        self.do_basic_test(
+            SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale
+        )
 
-    @parameterized.expand([
-        ("15", 15, True),
-        ("15", 15, False),
-        ("2355498743", 2355498743, True),
-        ("2355498743", 2355498743, False),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746, True),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746, False)
-    ])
+    @parameterized.expand(
+        [
+            ("15", 15, True),
+            ("15", 15, False),
+            ("2355498743", 2355498743, True),
+            ("2355498743", 2355498743, False),
+            (
+                "325385790209017329644351321912443757746",
+                325385790209017329644351321912443757746,
+                True,
+            ),
+            (
+                "325385790209017329644351321912443757746",
+                325385790209017329644351321912443757746,
+                False,
+            ),
+        ]
+    )
     def test_ladder_differential(self, name, num, complete):
-        ladder = LadderMultiplier(self.coords25519.formulas["ladd-1987-m"],
-                                  self.coords25519.formulas["dbl-1987-m"],
-                                  self.coords25519.formulas["scale"], complete=complete)
-        differential = DifferentialLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
-                                                    self.coords25519.formulas["dbl-1987-m"],
-                                                    self.coords25519.formulas["scale"],
-                                                    complete=complete)
+        ladder = LadderMultiplier(
+            self.coords25519.formulas["ladd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+            complete=complete,
+        )
+        differential = DifferentialLadderMultiplier(
+            self.coords25519.formulas["dadd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+            complete=complete,
+        )
         ladder.init(self.curve25519, self.base25519)
         res_ladder = ladder.multiply(num)
         differential.init(self.curve25519, self.base25519)
@@ -116,22 +174,28 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_ladder, res_differential)
         self.assertEqual(InfinityPoint(self.coords25519), differential.multiply(0))
 
-    @parameterized.expand([
-        ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
-        ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None),
-        ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None)
-    ])
+    @parameterized.expand(
+        [
+            ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
+            ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None),
+            ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None),
+        ]
+    )
     def test_binary_naf(self, name, add, dbl, neg, scale):
-        self.do_basic_test(BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg)
+        self.do_basic_test(
+            BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg
+        )
 
-    @parameterized.expand([
-        ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
-        ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None),
-        ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None),
-        ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"),
-        ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None),
-        ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None),
-    ])
+    @parameterized.expand(
+        [
+            ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
+            ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None),
+            ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None),
+            ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"),
+            ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None),
+            ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None),
+        ]
+    )
     def test_window_naf(self, name, add, dbl, neg, width, scale):
         formulas = self.get_formulas(self.coords, add, dbl, neg, scale)
         mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:])
@@ -144,41 +208,59 @@ class ScalarMultiplierTests(TestCase):
         mult.init(self.secp128r1, self.base)
         self.assertEqual(InfinityPoint(self.coords), mult.multiply(0))
 
-        mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:],
-                                   precompute_negation=True)
+        mult = WindowNAFMultiplier(
+            *formulas[:3], width, *formulas[3:], precompute_negation=True
+        )
         mult.init(self.secp128r1, self.base)
         res_precompute = mult.multiply(157 * 789)
         self.assertPointEquality(res_precompute, res, scale)
 
-    @parameterized.expand(cartesian([
-        ("10", 10),
-        ("2355498743", 2355498743),
-        ("325385790209017329644351321912443757746", 325385790209017329644351321912443757746)
-    ], [
-        ("add-1998-cmo", "dbl-1998-cmo"),
-        ("add-2016-rcb", "dbl-2016-rcb")
-    ]))
+    @parameterized.expand(
+        cartesian(
+            [
+                ("10", 10),
+                ("2355498743", 2355498743),
+                (
+                    "325385790209017329644351321912443757746",
+                    325385790209017329644351321912443757746,
+                ),
+            ],
+            [("add-1998-cmo", "dbl-1998-cmo"), ("add-2016-rcb", "dbl-2016-rcb")],
+        )
+    )
     def test_basic_multipliers(self, name, num, add, dbl):
-        ltr = LTRMultiplier(self.coords.formulas[add],
-                            self.coords.formulas[dbl], self.coords.formulas["z"])
+        ltr = LTRMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             ltr.multiply(1)
         ltr.init(self.secp128r1, self.base)
         res_ltr = ltr.multiply(num)
-        rtl = RTLMultiplier(self.coords.formulas[add],
-                            self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
+        rtl = RTLMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas["dbl-1998-cmo"],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             rtl.multiply(1)
         rtl.init(self.secp128r1, self.base)
         res_rtl = rtl.multiply(num)
         self.assertEqual(res_ltr, res_rtl)
 
-        ltr_always = LTRMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl], self.coords.formulas["z"],
-                                   always=True)
-        rtl_always = RTLMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl], self.coords.formulas["z"],
-                                   always=True)
+        ltr_always = LTRMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+            always=True,
+        )
+        rtl_always = RTLMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+            always=True,
+        )
         ltr_always.init(self.secp128r1, self.base)
         rtl_always.init(self.secp128r1, self.base)
         res_ltr_always = ltr_always.multiply(num)
@@ -186,36 +268,47 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_ltr, res_ltr_always)
         self.assertEqual(res_rtl, res_rtl_always)
 
-        bnaf = BinaryNAFMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl],
-                                   self.coords.formulas["neg"], self.coords.formulas["z"])
+        bnaf = BinaryNAFMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["neg"],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             bnaf.multiply(1)
         bnaf.init(self.secp128r1, self.base)
         res_bnaf = bnaf.multiply(num)
         self.assertEqual(res_bnaf, res_ltr)
 
-        wnaf = WindowNAFMultiplier(self.coords.formulas[add],
-                                   self.coords.formulas[dbl],
-                                   self.coords.formulas["neg"], 3, self.coords.formulas["z"])
+        wnaf = WindowNAFMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["neg"],
+            3,
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             wnaf.multiply(1)
         wnaf.init(self.secp128r1, self.base)
         res_wnaf = wnaf.multiply(num)
         self.assertEqual(res_wnaf, res_ltr)
 
-        ladder = SimpleLadderMultiplier(self.coords.formulas[add],
-                                        self.coords.formulas[dbl],
-                                        self.coords.formulas["z"])
+        ladder = SimpleLadderMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             ladder.multiply(1)
         ladder.init(self.secp128r1, self.base)
         res_ladder = ladder.multiply(num)
         self.assertEqual(res_ladder, res_ltr)
 
-        coron = CoronMultiplier(self.coords.formulas[add],
-                                self.coords.formulas[dbl],
-                                self.coords.formulas["z"])
+        coron = CoronMultiplier(
+            self.coords.formulas[add],
+            self.coords.formulas[dbl],
+            self.coords.formulas["z"],
+        )
         with self.assertRaises(ValueError):
             coron.multiply(1)
         coron.init(self.secp128r1, self.base)
@@ -223,12 +316,17 @@ class ScalarMultiplierTests(TestCase):
         self.assertEqual(res_coron, res_ltr)
 
     def test_init_fail(self):
-        mult = DifferentialLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
-                                            self.coords25519.formulas["dbl-1987-m"],
-                                            self.coords25519.formulas["scale"])
+        mult = DifferentialLadderMultiplier(
+            self.coords25519.formulas["dadd-1987-m"],
+            self.coords25519.formulas["dbl-1987-m"],
+            self.coords25519.formulas["scale"],
+        )
         with self.assertRaises(ValueError):
             mult.init(self.secp128r1, self.base)
 
         with self.assertRaises(ValueError):
-            LadderMultiplier(self.coords25519.formulas["ladd-1987-m"],
-                             scl=self.coords25519.formulas["scale"], complete=False)
+            LadderMultiplier(
+                self.coords25519.formulas["ladd-1987-m"],
+                scl=self.coords25519.formulas["scale"],
+                complete=False,
+            )
diff --git a/test/ec/test_naf.py b/test/ec/test_naf.py
index c87c03f..bdc176a 100644
--- a/test/ec/test_naf.py
+++ b/test/ec/test_naf.py
@@ -4,7 +4,6 @@ from pyecsca.ec.naf import naf, wnaf
 
 
 class NafTests(TestCase):
-
     def test_nafs(self):
         i = 0b1100110101001101011011
         self.assertListEqual(naf(i), wnaf(i, 2))
diff --git a/test/ec/test_op.py b/test/ec/test_op.py
index 019e0e8..c09914f 100644
--- a/test/ec/test_op.py
+++ b/test/ec/test_op.py
@@ -10,28 +10,31 @@ from pyecsca.ec.op import CodeOp, OpType
 
 
 class OpTests(TestCase):
-
-    @parameterized.expand([
-        ("add", "x = a+b", "x = a+b", OpType.Add),
-        ("sub", "x = a-b", "x = a-b", OpType.Sub),
-        ("mul", "y = a*b", "y = a*b", OpType.Mult),
-        ("div", "z = a/b", "z = a/b", OpType.Div),
-        ("inv", "z = 1/b", "z = 1/b", OpType.Inv),
-        ("pow", "b = a**d", "b = a^d", OpType.Pow),
-        ("sqr", "b = a**2", "b = a^2", OpType.Sqr),
-        ("id1", "b = 7", "b = 7", OpType.Id),
-        ("id2", "b = a", "b = a", OpType.Id),
-    ])
+    @parameterized.expand(
+        [
+            ("add", "x = a+b", "x = a+b", OpType.Add),
+            ("sub", "x = a-b", "x = a-b", OpType.Sub),
+            ("mul", "y = a*b", "y = a*b", OpType.Mult),
+            ("div", "z = a/b", "z = a/b", OpType.Div),
+            ("inv", "z = 1/b", "z = 1/b", OpType.Inv),
+            ("pow", "b = a**d", "b = a^d", OpType.Pow),
+            ("sqr", "b = a**2", "b = a^2", OpType.Sqr),
+            ("id1", "b = 7", "b = 7", OpType.Id),
+            ("id2", "b = a", "b = a", OpType.Id),
+        ]
+    )
     def test_str(self, name, module, result, op_type):
         code = parse(module, mode="exec")
         op = CodeOp(code)
         self.assertEqual(str(op), result)
         self.assertEqual(op.operator, op_type)
 
-    @parameterized.expand([
-        ("add", "x = a+b", {"a": Mod(5, 21), "b": Mod(7, 21)}, Mod(12, 21)),
-        ("sub", "x = a-b", {"a": Mod(7, 21), "b": Mod(5, 21)}, Mod(2, 21))
-    ])
+    @parameterized.expand(
+        [
+            ("add", "x = a+b", {"a": Mod(5, 21), "b": Mod(7, 21)}, Mod(12, 21)),
+            ("sub", "x = a-b", {"a": Mod(7, 21), "b": Mod(5, 21)}, Mod(2, 21)),
+        ]
+    )
     def test_call(self, name, module, locals, result):
         code = parse(module, mode="exec")
         op = CodeOp(code)
@@ -40,7 +43,6 @@ class OpTests(TestCase):
 
 
 class OpResultTests(TestCase):
-
     def test_str(self):
         for op, char in zip((ast.Add(), ast.Sub(), ast.Mult(), ast.Div()), "+-*/"):
             res = OpResult("X1", Mod(0, 5), op, Mod(2, 5), Mod(3, 5))
diff --git a/test/ec/test_params.py b/test/ec/test_params.py
index eb70342..b2a57b6 100644
--- a/test/ec/test_params.py
+++ b/test/ec/test_params.py
@@ -21,15 +21,17 @@ class DomainParameterTests(TestCase):
     def test_str(self):
         self.assertEqual(str(self.secp128r1), "DomainParameters(secg/secp128r1)")
 
-    @parameterized.expand([
-        ("secg/secp128r1", "projective"),
-        ("secg/secp256r1", "projective"),
-        ("secg/secp521r1", "projective"),
-        ("other/Curve25519", "xz"),
-        ("other/Ed25519", "projective"),
-        ("other/Ed448", "projective"),
-        ("other/E-222", "projective")
-    ])
+    @parameterized.expand(
+        [
+            ("secg/secp128r1", "projective"),
+            ("secg/secp256r1", "projective"),
+            ("secg/secp521r1", "projective"),
+            ("other/Curve25519", "xz"),
+            ("other/Ed25519", "projective"),
+            ("other/Ed448", "projective"),
+            ("other/E-222", "projective"),
+        ]
+    )
     def test_get_params(self, name, coords):
         params = get_params(*name.split("/"), coords)
         try:
@@ -37,10 +39,15 @@ class DomainParameterTests(TestCase):
         except NotImplementedError:
             pass
 
-    @parameterized.expand([
-        ("anssi", "projective"),
-        ("brainpool", lambda name: "projective" if name.endswith("r1") else "jacobian")
-    ])
+    @parameterized.expand(
+        [
+            ("anssi", "projective"),
+            (
+                "brainpool",
+                lambda name: "projective" if name.endswith("r1") else "jacobian",
+            ),
+        ]
+    )
     def test_get_category(self, name, coords):
         get_category(name, coords)
 
@@ -55,11 +62,13 @@ class DomainParameterTests(TestCase):
         category = load_category("test/data/curves.json", "yz")
         self.assertEqual(len(category), 1)
 
-    @parameterized.expand([
-        ("no_category/some", "else"),
-        ("secg/no_curve", "else"),
-        ("secg/secp128r1", "some")
-    ])
+    @parameterized.expand(
+        [
+            ("no_category/some", "else"),
+            ("secg/no_curve", "else"),
+            ("secg/secp128r1", "some"),
+        ]
+    )
     def test_unknown(self, name, coords):
         with self.assertRaises(ValueError):
             get_params(*name.split("/"), coords)
diff --git a/test/ec/test_point.py b/test/ec/test_point.py
index 9bff800..51907ec 100644
--- a/test/ec/test_point.py
+++ b/test/ec/test_point.py
@@ -19,10 +19,12 @@ class PointTests(TestCase):
             Point(self.coords)
 
     def test_to_affine(self):
-        pt = Point(self.coords,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
-                   Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         affine = pt.to_affine()
 
         self.assertIsInstance(affine.coordinate_model, AffineCoordinateModel)
@@ -35,7 +37,11 @@ class PointTests(TestCase):
         self.assertIsInstance(affine, InfinityPoint)
 
     def test_to_model(self):
-        affine = Point(self.affine, x=Mod(0xabcd, self.secp128r1.curve.prime), y=Mod(0xef, self.secp128r1.curve.prime))
+        affine = Point(
+            self.affine,
+            x=Mod(0xABCD, self.secp128r1.curve.prime),
+            y=Mod(0xEF, self.secp128r1.curve.prime),
+        )
         projective_model = self.coords
         other = affine.to_model(projective_model, self.secp128r1.curve)
 
@@ -53,26 +59,34 @@ class PointTests(TestCase):
             self.base.to_model(self.coords, self.secp128r1.curve)
 
     def test_to_from_affine(self):
-        pt = Point(self.coords,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
-                   Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x161FF7528B899B2D0C28607CA52C5B86, self.secp128r1.curve.prime),
+            Y=Mod(0xCF5AC8395BAFEB13C02DA292DDED7A83, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         other = pt.to_affine().to_model(self.coords, self.secp128r1.curve)
         self.assertEqual(pt, other)
 
     def test_equals(self):
-        pt = Point(self.coords,
-                   X=Mod(0x4, self.secp128r1.curve.prime),
-                   Y=Mod(0x6, self.secp128r1.curve.prime),
-                   Z=Mod(2, self.secp128r1.curve.prime))
-        other = Point(self.coords,
-                      X=Mod(0x2, self.secp128r1.curve.prime),
-                      Y=Mod(0x3, self.secp128r1.curve.prime),
-                      Z=Mod(1, self.secp128r1.curve.prime))
-        third = Point(self.coords,
-                      X=Mod(0x5, self.secp128r1.curve.prime),
-                      Y=Mod(0x3, self.secp128r1.curve.prime),
-                      Z=Mod(1, self.secp128r1.curve.prime))
+        pt = Point(
+            self.coords,
+            X=Mod(0x4, self.secp128r1.curve.prime),
+            Y=Mod(0x6, self.secp128r1.curve.prime),
+            Z=Mod(2, self.secp128r1.curve.prime),
+        )
+        other = Point(
+            self.coords,
+            X=Mod(0x2, self.secp128r1.curve.prime),
+            Y=Mod(0x3, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
+        third = Point(
+            self.coords,
+            X=Mod(0x5, self.secp128r1.curve.prime),
+            Y=Mod(0x3, self.secp128r1.curve.prime),
+            Z=Mod(1, self.secp128r1.curve.prime),
+        )
         self.assertTrue(pt.equals(other))
         self.assertNotEqual(pt, other)
         self.assertFalse(pt.equals(2))
@@ -94,17 +108,26 @@ class PointTests(TestCase):
         self.assertFalse(pt.equals_scaled(infty_one))
 
         mont = MontgomeryModel()
-        different = Point(mont.coordinates["xz"],
-                          X=Mod(0x64daccd2656420216545e5f65221eb,
-                                0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),
-                          Z=Mod(1, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa))
+        different = Point(
+            mont.coordinates["xz"],
+            X=Mod(
+                0x64DACCD2656420216545E5F65221EB,
+                0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,
+            ),
+            Z=Mod(1, 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA),
+        )
         self.assertFalse(pt.equals(different))
         self.assertNotEqual(pt, different)
 
     def test_bytes(self):
-        pt = Point(self.coords,
-                   X=Mod(0x4, self.secp128r1.curve.prime),
-                   Y=Mod(0x6, self.secp128r1.curve.prime),
-                   Z=Mod(2, self.secp128r1.curve.prime))
-        self.assertEqual(bytes(pt), b"\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02")
+        pt = Point(
+            self.coords,
+            X=Mod(0x4, self.secp128r1.curve.prime),
+            Y=Mod(0x6, self.secp128r1.curve.prime),
+            Z=Mod(2, self.secp128r1.curve.prime),
+        )
+        self.assertEqual(
+            bytes(pt),
+            b"\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02",
+        )
         self.assertEqual(bytes(InfinityPoint(self.coords)), b"\x00")
diff --git a/test/ec/test_regress.py b/test/ec/test_regress.py
index ef593fc..e02cc8e 100644
--- a/test/ec/test_regress.py
+++ b/test/ec/test_regress.py
@@ -10,7 +10,6 @@ from pyecsca.ec.point import Point
 
 
 class RegressionTests(TestCase):
-
     def test_issue_7(self):
         secp128r1 = get_params("secg", "secp128r1", "projective")
         base = secp128r1.generator
@@ -18,7 +17,9 @@ class RegressionTests(TestCase):
         add = coords.formulas["add-1998-cmo"]
         dbl = coords.formulas["dbl-1998-cmo"]
         scl = coords.formulas["z"]
-        mult = LTRMultiplier(add, dbl, scl, always=False, complete=False, short_circuit=True)
+        mult = LTRMultiplier(
+            add, dbl, scl, always=False, complete=False, short_circuit=True
+        )
         mult.init(secp128r1, base)
         pt = mult.multiply(13613624287328732)
         self.assertIsInstance(pt.coords["X"], Mod)
@@ -44,7 +45,9 @@ class RegressionTests(TestCase):
         coords = model.coordinates["xz"]
         p = 19
         neutral = Point(coords, X=Mod(1, p), Z=Mod(0, p))
-        curve = EllipticCurve(model, coords, p, neutral, {"a": Mod(8, p), "b": Mod(1, p)})
+        curve = EllipticCurve(
+            model, coords, p, neutral, {"a": Mod(8, p), "b": Mod(1, p)}
+        )
         base = Point(coords, X=Mod(12, p), Z=Mod(1, p))
         formula = coords.formulas["dbl-1987-m-2"]
         res = formula(p, base, **curve.parameters)[0]
@@ -60,13 +63,13 @@ class RegressionTests(TestCase):
         model = EdwardsModel()
         coords = model.coordinates["yz"]
         coords_sqr = model.coordinates["yzsquared"]
-        p = 0x1d
+        p = 0x1D
         c = Mod(1, p)
-        d = Mod(0x1c, p)
+        d = Mod(0x1C, p)
         r = d.sqrt()
         neutral = Point(coords, Y=c * r, Z=Mod(1, p))
         curve = EllipticCurve(model, coords, p, neutral, {"c": c, "d": d, "r": r})
         neutral_affine = Point(AffineCoordinateModel(model), x=Mod(0, p), y=c)
         self.assertEqual(neutral, neutral_affine.to_model(coords, curve))
-        neutral_sqr = Point(coords_sqr, Y=c**2 * r, Z=Mod(1, p))
+        neutral_sqr = Point(coords_sqr, Y=c ** 2 * r, Z=Mod(1, p))
         self.assertEqual(neutral_sqr, neutral_affine.to_model(coords_sqr, curve))
diff --git a/test/ec/test_signature.py b/test/ec/test_signature.py
index 8d4a439..f6ab302 100644
--- a/test/ec/test_signature.py
+++ b/test/ec/test_signature.py
@@ -5,29 +5,38 @@ from parameterized import parameterized
 from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.mult import LTRMultiplier
-from pyecsca.ec.signature import (Signature, SignatureResult, ECDSA_NONE, ECDSA_SHA1, ECDSA_SHA224,
-                                  ECDSA_SHA256, ECDSA_SHA384, ECDSA_SHA512)
+from pyecsca.ec.signature import (
+    Signature,
+    SignatureResult,
+    ECDSA_NONE,
+    ECDSA_SHA1,
+    ECDSA_SHA224,
+    ECDSA_SHA256,
+    ECDSA_SHA384,
+    ECDSA_SHA512,
+)
 
 
 class SignatureTests(TestCase):
-
     def setUp(self):
         self.secp128r1 = get_params("secg", "secp128r1", "projective")
         self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
         self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
         self.mult = LTRMultiplier(self.add, self.dbl)
-        self.msg = 0xcafebabe.to_bytes(4, byteorder="big")
-        self.priv = Mod(0xdeadbeef, self.secp128r1.order)
+        self.msg = 0xCAFEBABE .to_bytes(4, byteorder="big")
+        self.priv = Mod(0xDEADBEEF, self.secp128r1.order)
         self.mult.init(self.secp128r1, self.secp128r1.generator)
         self.pub = self.mult.multiply(self.priv.x)
 
-    @parameterized.expand([
-        ("SHA1", ECDSA_SHA1),
-        ("SHA224", ECDSA_SHA224),
-        ("SHA256", ECDSA_SHA256),
-        ("SHA384", ECDSA_SHA384),
-        ("SHA512", ECDSA_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("SHA1", ECDSA_SHA1),
+            ("SHA224", ECDSA_SHA224),
+            ("SHA256", ECDSA_SHA256),
+            ("SHA384", ECDSA_SHA384),
+            ("SHA512", ECDSA_SHA512),
+        ]
+    )
     def test_all(self, name, algo):
         signer = algo(self.mult, self.secp128r1, privkey=self.priv)
         self.assertTrue(signer.can_sign)
@@ -36,13 +45,17 @@ class SignatureTests(TestCase):
         self.assertTrue(verifier.can_verify)
         self.assertTrue(verifier.verify_data(sig, self.msg))
 
-        none = ECDSA_NONE(self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv)
+        none = ECDSA_NONE(
+            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
+        )
         digest = signer.hash_algo(self.msg).digest()
         sig = none.sign_hash(digest)
         self.assertTrue(none.verify_hash(sig, digest))
 
     def test_cannot(self):
-        ok = ECDSA_NONE(self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv)
+        ok = ECDSA_NONE(
+            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
+        )
         data = b"aaaa"
         sig = ok.sign_data(data)
 
@@ -60,23 +73,25 @@ class SignatureTests(TestCase):
         with self.assertRaises(ValueError):
             Signature(self.mult, self.secp128r1)
 
-    @parameterized.expand([
-        ("SHA1", ECDSA_SHA1),
-        ("SHA224", ECDSA_SHA224),
-        ("SHA256", ECDSA_SHA256),
-        ("SHA384", ECDSA_SHA384),
-        ("SHA512", ECDSA_SHA512)
-    ])
+    @parameterized.expand(
+        [
+            ("SHA1", ECDSA_SHA1),
+            ("SHA224", ECDSA_SHA224),
+            ("SHA256", ECDSA_SHA256),
+            ("SHA384", ECDSA_SHA384),
+            ("SHA512", ECDSA_SHA512),
+        ]
+    )
     def test_fixed_nonce(self, name, algo):
         signer = algo(self.mult, self.secp128r1, privkey=self.priv)
-        sig_one = signer.sign_data(self.msg, nonce=0xabcdef)
-        sig_other = signer.sign_data(self.msg, nonce=0xabcdef)
+        sig_one = signer.sign_data(self.msg, nonce=0xABCDEF)
+        sig_other = signer.sign_data(self.msg, nonce=0xABCDEF)
         verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
         self.assertTrue(verifier.verify_data(sig_one, self.msg))
         self.assertTrue(verifier.verify_data(sig_other, self.msg))
         self.assertEqual(sig_one, sig_other)
 
     def test_der(self):
-        sig = SignatureResult(0xaaaaa, 0xbbbbb)
+        sig = SignatureResult(0xAAAAA, 0xBBBBB)
         self.assertEqual(sig, SignatureResult.from_DER(sig.to_DER()))
         self.assertNotEqual(sig, "abc")
diff --git a/test/ec/test_transformations.py b/test/ec/test_transformations.py
index 951fbb8..b15f868 100644
--- a/test/ec/test_transformations.py
+++ b/test/ec/test_transformations.py
@@ -5,7 +5,6 @@ from pyecsca.ec.transformations import M2SW, M2TE, TE2M, SW2M, SW2TE
 
 
 class TransformationTests(TestCase):
-
     def test_montgomery(self):
         curve25519 = get_params("other", "Curve25519", "affine")
         sw = M2SW(curve25519)
diff --git a/test/ec/utils.py b/test/ec/utils.py
index 6429ac9..84c568d 100644
--- a/test/ec/utils.py
+++ b/test/ec/utils.py
@@ -46,12 +46,21 @@ class Profiler(object):
             raise ValueError
         if self._output_directory is None or self._benchmark_name is None:
             return
-        git_commit = run(["git", "rev-parse", "--short", "HEAD"], stdout=PIPE, stderr=DEVNULL).stdout.strip().decode()
-        git_dirty = run(["git", "diff", "--quiet"], stdout=DEVNULL, stderr=DEVNULL).returncode != 0
+        git_commit = (
+            run(["git", "rev-parse", "--short", "HEAD"], stdout=PIPE, stderr=DEVNULL)
+            .stdout.strip()
+            .decode()
+        )
+        git_dirty = (
+            run(["git", "diff", "--quiet"], stdout=DEVNULL, stderr=DEVNULL).returncode
+            != 0
+        )
         version = git_commit + ("-dirty" if git_dirty else "")
         output_path = Path(self._output_directory) / (self._benchmark_name + ".csv")
         with output_path.open("a") as f:
-            f.write(f"{version},{'.'.join(map(str, sys.version_info[:3]))},{self.get_time()}\n")
+            f.write(
+                f"{version},{'.'.join(map(str, sys.version_info[:3]))},{self.get_time()}\n"
+            )
 
     def output(self):
         if self._state != "out":