Move to pytest.

10 files changed, 877 insertions, 561 deletions

diff --git a/pyproject.toml b/pyproject.toml
index 90b19ae..8eef1b8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -50,7 +50,7 @@ client="pyecsca.codegen.client:main"
 
 [project.optional-dependencies]
 "dev" = ["mypy", "flake8"]
-"test" = ["nose2", "parameterized", "green", "coverage"]
+"test" = ["pytest>=7.0.0", "coverage", "pytest-cov", "pytest-sugar", "pytest-click"]
 
 [tool.setuptools.packages.find]
 include = ["pyecsca*"]
diff --git a/test/conftest.py b/test/conftest.py
new file mode 100644
index 0000000..1c1449a
--- /dev/null
+++ b/test/conftest.py
@@ -0,0 +1,13 @@
+import pytest
+
+from pyecsca.ec.params import get_params, DomainParameters
+
+
+@pytest.fixture(scope="session")
+def secp128r1() -> DomainParameters:
+    return get_params("secg", "secp128r1", "projective")
+
+
+@pytest.fixture(scope="session")
+def curve25519() -> DomainParameters:
+    return get_params("other", "Curve25519", "xz")
diff --git a/test/test_builder.py b/test/test_builder.py
index f2760ea..0f931ef 100644
--- a/test/test_builder.py
+++ b/test/test_builder.py
@@ -1,71 +1,207 @@
-from unittest import TestCase
-
-from click.testing import CliRunner
+import pytest
 
 from pyecsca.codegen.builder import build_impl, list_impl
-from parameterized import parameterized
 
-class BuilderTests(TestCase):
 
-    @parameterized.expand([
-        ("basic", ["--platform", "HOST", "shortw", "projective", "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=True)", "."]),
-        ("karatsuba", ["--platform", "HOST", "--mul", "KARATSUBA", "shortw", "projective", "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=True)", "."]),
-        ("strip", ["--platform", "HOST", "--strip", "--no-remove", "shortw", "projective", "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=True)", "."]),
-        ("montgom", ["--platform", "HOST", "--no-ecdsa", "montgom", "xz", "ladd-1987-m", "dbl-1987-m", "scale", "ldr()", "."]),
-        ("jacobian", ["--platform", "HOST", "--no-ecdsa", "shortw", "jacobian", "add-2007-bl", "dbl-2007-bl", "rtl()", "."])
-    ])
-    def test_cli_build(self, name, args):
-        runner = CliRunner()
-        with runner.isolated_filesystem():
-            result = runner.invoke(build_impl, args)
-            self.assertEqual(result.exit_code, 0)
+@pytest.mark.parametrize(
+    "name,args",
+    [
+        (
+            "basic",
+            [
+                "--platform",
+                "HOST",
+                "shortw",
+                "projective",
+                "add-1998-cmo",
+                "dbl-1998-cmo",
+                "z",
+                "ltr(complete=True)",
+                ".",
+            ],
+        ),
+        (
+            "karatsuba",
+            [
+                "--platform",
+                "HOST",
+                "--mul",
+                "KARATSUBA",
+                "shortw",
+                "projective",
+                "add-1998-cmo",
+                "dbl-1998-cmo",
+                "z",
+                "ltr(complete=True)",
+                ".",
+            ],
+        ),
+        (
+            "strip",
+            [
+                "--platform",
+                "HOST",
+                "--strip",
+                "--no-remove",
+                "shortw",
+                "projective",
+                "add-1998-cmo",
+                "dbl-1998-cmo",
+                "z",
+                "ltr(complete=True)",
+                ".",
+            ],
+        ),
+        (
+            "montgom",
+            [
+                "--platform",
+                "HOST",
+                "--no-ecdsa",
+                "montgom",
+                "xz",
+                "ladd-1987-m",
+                "dbl-1987-m",
+                "scale",
+                "ldr()",
+                ".",
+            ],
+        ),
+        (
+            "jacobian",
+            [
+                "--platform",
+                "HOST",
+                "--no-ecdsa",
+                "shortw",
+                "jacobian",
+                "add-2007-bl",
+                "dbl-2007-bl",
+                "rtl()",
+                ".",
+            ],
+        ),
+    ],
+)
+def test_cli_build(name, args, isolated_cli_runner):
+    result = isolated_cli_runner.invoke(build_impl, args)
+    assert result.exit_code == 0
+
+
+def test_cli_build_fails(isolated_cli_runner):
+    # unknown model
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "missing",
+            "projective",
+            "add-1998-cmo",
+            "dbl-1998-cmo",
+            "z",
+            "ltr(complete=True)",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "missing",
+            "add-1998-cmo",
+            "dbl-1998-cmo",
+            "z",
+            "ltr(complete=True)",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "projective",
+            "missing",
+            "dbl-1998-cmo",
+            "z",
+            "ltr(complete=True)",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "projective",
+            "add-1998-cmo",
+            "dbl-1998-cmo",
+            "z",
+            "missing",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "projective",
+            "add-1998-cmo",
+            "dbl-1998-cmo",
+            "z",
+            "missing()",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "projective",
+            "add-1998-cmo",
+            "z",
+            "ltr(complete=True)",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
+    result = isolated_cli_runner.invoke(
+        build_impl,
+        [
+            "--platform",
+            "HOST",
+            "shortw",
+            "projective",
+            "add-1998-cmo",
+            "add-1998-cmo",
+            "z",
+            "ltr(complete=True)",
+            ".",
+        ],
+    )
+    assert result.exit_code == 2
 
-    def test_cli_build_fails(self):
-        runner = CliRunner()
-        with runner.isolated_filesystem():
-            # unknown model
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "missing", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
-            self.assertEqual(result.exit_code, 2)
-            # unknown coordinates
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "missing", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
-            self.assertEqual(result.exit_code, 2)
-            # unknown formula
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "projective", "missing",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
-            self.assertEqual(result.exit_code, 2)
-            # bad formatted mult spec
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "missing", "."])
-            self.assertEqual(result.exit_code, 2)
-            # unknown mult
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "missing()", "."])
-            self.assertEqual(result.exit_code, 2)
-            # missing required formulas to mult
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "z", "ltr(complete=True)", "."])
-            self.assertEqual(result.exit_code, 2)
-            # duplicate formulas
-            result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "add-1998-cmo", "z", "ltr(complete=True)", "."])
-            self.assertEqual(result.exit_code, 2)
 
-    def test_cli_list(self):
-        runner = CliRunner()
-        result = runner.invoke(list_impl, [])
-        self.assertEqual(result.exit_code, 0)
-        result = runner.invoke(list_impl, ["montgom"])
-        self.assertEqual(result.exit_code, 0)
-        result = runner.invoke(list_impl, ["montgom", "xz"])
-        self.assertEqual(result.exit_code, 0)
-        result = runner.invoke(list_impl, ["montgom", "xz", "ladd-1987-m"])
-        self.assertEqual(result.exit_code, 0)
+def test_cli_list(cli_runner):
+    result = cli_runner.invoke(list_impl, [])
+    assert result.exit_code == 0
+    result = cli_runner.invoke(list_impl, ["montgom"])
+    assert result.exit_code == 0
+    result = cli_runner.invoke(list_impl, ["montgom", "xz"])
+    assert result.exit_code == 0
+    result = cli_runner.invoke(list_impl, ["montgom", "xz", "ladd-1987-m"])
+    assert result.exit_code == 0
diff --git a/test/test_client.py b/test/test_client.py
index 3132e4e..170b32f 100644
--- a/test/test_client.py
+++ b/test/test_client.py
@@ -1,108 +1,99 @@
 from os.path import join
-from unittest import TestCase
-
-from click.testing import CliRunner
-from pyecsca.ec.params import get_params
-from pyecsca.ec.mod import Mod
 
 from pyecsca.codegen.builder import build_impl
-from pyecsca.codegen.client import (encode_data, decode_data, encode_scalar, cmd_init_prng,
-                                    cmd_set_params, cmd_set_pubkey, cmd_set_privkey,
-                                    cmd_scalar_mult,
-                                    cmd_ecdh, cmd_ecdsa_sign, cmd_ecdsa_verify, cmd_generate,
-                                    cmd_debug, main, cmd_set_trigger, Triggers)
-
-
-class EncodingTests(TestCase):
-
-    def test_encode_decode(self):
-        data = {"a": encode_scalar(0xcafebabe),
-                "b": {
-                    "c": encode_scalar(Mod(1, 3)),
-                    "d": bytes([0x2])
-                }}
-        encoded = encode_data(None, data)
-        result = decode_data(encoded)
-        self.assertEqual(data, result)
-
-
-class CommandTest(TestCase):
-
-    def setUp(self):
-        self.curve = get_params("secg", "secp128r1", "projective")
-        self.model = self.curve.curve.model
-        self.coords = self.curve.curve.coordinate_model
-
-    def test_init_prng(self):
-        cmd_init_prng(bytes([0xca, 0xfe, 0xba, 0xbe]))
-
-    def test_set_curve(self):
-        cmd_set_params(self.curve)
-
-    def test_generate(self):
-        cmd_generate()
-
-    def test_set_pubkey(self):
-        cmd_set_pubkey(self.curve.generator)
-
-    def test_set_privkey(self):
-        cmd_set_privkey(0x123456789)
-
-    def test_scalar_mult(self):
-        cmd_scalar_mult(0x123456789, self.curve.generator)
-
-    def test_ecdh(self):
-        cmd_ecdh(self.curve.generator)
-
-    def test_ecdsa_sign(self):
-        cmd_ecdsa_sign(b"something")
-
-    def test_ecdsa_verify(self):
-        cmd_ecdsa_verify(b"something", b"signature")
-
-    def test_set_trigger(self):
-        cmd_set_trigger(Triggers.add)
-
-    def test_debug(self):
-        cmd_debug()
-
+from pyecsca.codegen.client import main
 
-class ClientTests(TestCase):
 
-    def test_generate(self):
-        runner = CliRunner()
-        with runner.isolated_filesystem() as tmpdir:
-            runner.invoke(build_impl,
-                          ["--platform", "HOST", "shortw", "projective",
-                           "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=False)", "."])
-            result = runner.invoke(main,
-                                   ["--platform", "HOST", "--fw",
-                                    join(tmpdir, "pyecsca-codegen-HOST.elf"),
-                                    "shortw", "projective", "gen", "secg/secp128r1"])
-            self.assertEqual(result.exit_code, 0)
+def test_generate(cli_runner):
+    with cli_runner.isolated_filesystem() as tmpdir:
+        cli_runner.invoke(
+            build_impl,
+            [
+                "--platform",
+                "HOST",
+                "shortw",
+                "projective",
+                "add-1998-cmo",
+                "dbl-1998-cmo",
+                "z",
+                "ltr(complete=False)",
+                ".",
+            ],
+        )
+        result = cli_runner.invoke(
+            main,
+            [
+                "--platform",
+                "HOST",
+                "--fw",
+                join(tmpdir, "pyecsca-codegen-HOST.elf"),
+                "shortw",
+                "projective",
+                "gen",
+                "secg/secp128r1",
+            ],
+        )
+        assert result.exit_code == 0
 
 
-    def test_ecdh(self):
-        runner = CliRunner()
-        with runner.isolated_filesystem() as tmpdir:
-            runner.invoke(build_impl,
-                          ["--platform", "HOST", "shortw", "projective",
-                           "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=False)", "."])
-            result = runner.invoke(main,
-                                   ["--platform", "HOST", "--fw",
-                                    join(tmpdir, "pyecsca-codegen-HOST.elf"),
-                                    "shortw", "projective", "ecdh", "secg/secp128r1",
-                                    "122835813094999453922649270086793500655,326514220558629293368386081113307347349"])
-            self.assertEqual(result.exit_code, 0)
-            result = runner.invoke(main,
-                                   ["--platform", "HOST", "--fw",
-                                    join(tmpdir, "pyecsca-codegen-HOST.elf"),
-                                    "shortw", "projective", "ecdh", "secg/secp128r1",
-                                    "045c69512b630addd5b6d347b7bce517eff5a459f98f015c6906ccfed3cf0bf995"])
-            self.assertEqual(result.exit_code, 0)
-            result = runner.invoke(main,
-                                   ["--platform", "HOST", "--fw",
-                                    join(tmpdir, "pyecsca-codegen-HOST.elf"),
-                                    "shortw", "projective", "ecdh", "secg/secp128r1",
-                                    "something"])
-            self.assertEqual(result.exit_code, 2)
+def test_ecdh(cli_runner):
+    with cli_runner.isolated_filesystem() as tmpdir:
+        cli_runner.invoke(
+            build_impl,
+            [
+                "--platform",
+                "HOST",
+                "shortw",
+                "projective",
+                "add-1998-cmo",
+                "dbl-1998-cmo",
+                "z",
+                "ltr(complete=False)",
+                ".",
+            ],
+        )
+        result = cli_runner.invoke(
+            main,
+            [
+                "--platform",
+                "HOST",
+                "--fw",
+                join(tmpdir, "pyecsca-codegen-HOST.elf"),
+                "shortw",
+                "projective",
+                "ecdh",
+                "secg/secp128r1",
+                "122835813094999453922649270086793500655,326514220558629293368386081113307347349",
+            ],
+        )
+        assert result.exit_code == 0
+        result = cli_runner.invoke(
+            main,
+            [
+                "--platform",
+                "HOST",
+                "--fw",
+                join(tmpdir, "pyecsca-codegen-HOST.elf"),
+                "shortw",
+                "projective",
+                "ecdh",
+                "secg/secp128r1",
+                "045c69512b630addd5b6d347b7bce517eff5a459f98f015c6906ccfed3cf0bf995",
+            ],
+        )
+        assert result.exit_code == 0
+        result = cli_runner.invoke(
+            main,
+            [
+                "--platform",
+                "HOST",
+                "--fw",
+                join(tmpdir, "pyecsca-codegen-HOST.elf"),
+                "shortw",
+                "projective",
+                "ecdh",
+                "secg/secp128r1",
+                "something",
+            ],
+        )
+        assert result.exit_code == 2
diff --git a/test/test_commands.py b/test/test_commands.py
new file mode 100644
index 0000000..b8393e8
--- /dev/null
+++ b/test/test_commands.py
@@ -0,0 +1,58 @@
+from pyecsca.codegen.client import (
+    cmd_init_prng,
+    cmd_set_params,
+    cmd_set_pubkey,
+    cmd_set_privkey,
+    cmd_scalar_mult,
+    cmd_ecdh,
+    cmd_ecdsa_sign,
+    cmd_ecdsa_verify,
+    cmd_generate,
+    cmd_debug,
+    cmd_set_trigger,
+    Triggers,
+)
+
+
+def test_init_prng():
+    assert cmd_init_prng(bytes([0xCA, 0xFE, 0xBA, 0xBE])) is not None
+
+
+def test_set_curve(secp128r1):
+    assert cmd_set_params(secp128r1) is not None
+
+
+def test_generate():
+    assert cmd_generate() is not None
+
+
+def test_set_pubkey(secp128r1):
+    assert cmd_set_pubkey(secp128r1.generator) is not None
+
+
+def test_set_privkey():
+    assert cmd_set_privkey(0x123456789) is not None
+
+
+def test_scalar_mult(secp128r1):
+    assert cmd_scalar_mult(0x123456789, secp128r1.generator) is not None
+
+
+def test_ecdh(secp128r1):
+    assert cmd_ecdh(secp128r1.generator) is not None
+
+
+def test_ecdsa_sign():
+    assert cmd_ecdsa_sign(b"something") is not None
+
+
+def test_ecdsa_verify():
+    assert cmd_ecdsa_verify(b"something", b"signature") is not None
+
+
+def test_set_trigger():
+    assert cmd_set_trigger(Triggers.add) is not None
+
+
+def test_debug():
+    assert cmd_debug() is not None
diff --git a/test/test_encoding.py b/test/test_encoding.py
new file mode 100644
index 0000000..0684945
--- /dev/null
+++ b/test/test_encoding.py
@@ -0,0 +1,12 @@
+from pyecsca.ec.mod import Mod
+from pyecsca.codegen.client import encode_data, decode_data, encode_scalar
+
+
+def test_encode_decode():
+    data = {
+        "a": encode_scalar(0xCAFEBABE),
+        "b": {"c": encode_scalar(Mod(1, 3)), "d": bytes([0x2])},
+    }
+    encoded = encode_data(None, data)
+    result = decode_data(encoded)
+    assert data == result
diff --git a/test/test_impl.py b/test/test_impl.py
index b054567..6c58315 100644
--- a/test/test_impl.py
+++ b/test/test_impl.py
@@ -1,137 +1,165 @@
 from copy import copy
 from os.path import join
-from unittest import TestCase
+import pytest
 
-from click.testing import CliRunner
-from pyecsca.ec.params import get_params
 from pyecsca.ec.key_agreement import ECDH_SHA1
-from pyecsca.ec.mult import LTRMultiplier, RTLMultiplier, CoronMultiplier, BinaryNAFMultiplier
+from pyecsca.ec.mult import (
+    LTRMultiplier,
+    RTLMultiplier,
+    CoronMultiplier,
+    BinaryNAFMultiplier,
+)
 from pyecsca.ec.signature import ECDSA_SHA1, SignatureResult
 
 from pyecsca.codegen.builder import build_impl
 from pyecsca.codegen.client import HostTarget
 
 
-class ImplTests(TestCase):
+def do_basic_test(
+    callback,
+    runner,
+    params,
+    mult_class,
+    formulas,
+    mult_name,
+    ecdsa,
+    ecdh,
+    **mult_kwargs,
+):
+    other_args = [
+        ("--mul", "KARATSUBA", "--sqr", "KARATSUBA"),
+        ("--mul", "TOOM_COOK", "--sqr", "TOOM_COOK"),
+        ("--red", "BARRETT"),
+        ("--red", "MONTGOMERY"),
+    ]
+    for additional in other_args:
+        with runner.isolated_filesystem() as tmpdir:
+            runner.invoke(
+                build_impl,
+                [
+                    "--platform",
+                    "HOST",
+                    *additional,
+                    "--ecdsa" if ecdsa else "--no-ecdsa",
+                    "--ecdh" if ecdh else "--no-ecdh",
+                    params.curve.model.shortname,
+                    params.curve.coordinate_model.name,
+                    *formulas,
+                    f"{mult_name}({','.join(f'{key}={value}' for key, value in mult_kwargs.items())})",
+                    ".",
+                ],
+            )
+            target = HostTarget(
+                params.curve.model,
+                params.curve.coordinate_model,
+                binary=join(tmpdir, "pyecsca-codegen-HOST.elf"),
+            )
+            target.connect()
+            target.set_params(params)
+            formula_instances = [
+                params.curve.coordinate_model.formulas[formula] for formula in formulas
+            ]
+            mult = mult_class(*formula_instances, **mult_kwargs)
+            mult.init(params, params.generator)
+            callback(target, mult, params)
+            target.disconnect()
 
-    def setUp(self):
-        self.secp128r1 = get_params("secg", "secp128r1", "projective")
-        self.base = self.secp128r1.generator
-        self.coords = self.secp128r1.curve.coordinate_model
 
-        self.curve25519 = get_params("other", "Curve25519", "xz")
-        self.base25519 = self.curve25519.generator
-        self.coords25519 = self.curve25519.curve.coordinate_model
+def test_init(cli_runner, secp128r1):
+    def callback(target, mult, params):
+        target.init_prng(bytes([0x12, 0x34, 0x56, 0x78]))
 
-    def do_basic_test(self, callback, runner, params, mult_class, formulas, mult_name,
-                      ecdsa, ecdh, **mult_kwargs):
-        other_args = [
-            ("--mul", "KARATSUBA", "--sqr", "KARATSUBA"),
-            ("--mul", "TOOM_COOK", "--sqr", "TOOM_COOK"),
-            ("--red", "BARRETT"),
-            ("--red", "MONTGOMERY")
-        ]
-        for additional in other_args:
-            with runner.isolated_filesystem() as tmpdir:
-                runner.invoke(build_impl,
-                              ["--platform", "HOST",
-                               *additional,
-                               "--ecdsa" if ecdsa else "--no-ecdsa",
-                               "--ecdh" if ecdh else "--no-ecdh",
-                               params.curve.model.shortname, params.curve.coordinate_model.name,
-                               *formulas,
-                               f"{mult_name}({','.join(f'{key}={value}' for key, value in mult_kwargs.items())})",
-                               "."])
-                target = HostTarget(params.curve.model, params.curve.coordinate_model,
-                                    binary=join(tmpdir, "pyecsca-codegen-HOST.elf"))
-                target.connect()
-                target.set_params(params)
-                formula_instances = [params.curve.coordinate_model.formulas[formula] for formula
-                                     in formulas]
-                mult = mult_class(*formula_instances, **mult_kwargs)
-                mult.init(params, params.generator)
-                callback(target, mult, params)
-                target.disconnect()
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
 
-class PRNGTests(ImplTests):
+def test_setup(cli_runner, secp128r1):
+    def callback(target, mult, params):
+        priv = 57
+        pub = mult.multiply(priv).to_affine()
+        target.set_privkey(priv)
+        target.set_pubkey(pub)
 
-    def test_init(self):
-        runner = CliRunner()
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
-        def callback(target, mult, params):
-            target.init_prng(bytes([0x12, 0x34, 0x56, 0x78]))
 
-        self.do_basic_test(callback, runner, self.secp128r1, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False, complete=False)
+def test_debug(cli_runner, secp128r1):
+    def callback(target, mult, params):
+        model, coords = target.debug()
+        assert model == params.curve.model.shortname
+        assert coords == params.curve.coordinate_model.name
 
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
-class SetupTests(ImplTests):
 
-    def test_setup(self):
-        runner = CliRunner()
-
-        def callback(target, mult, params):
-            priv = 57
-            pub = mult.multiply(priv).to_affine()
-            target.set_privkey(priv)
-            target.set_pubkey(pub)
-
-        self.do_basic_test(callback, runner, self.secp128r1, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False, complete=False)
-
-    def test_debug(self):
-        runner = CliRunner()
-
-        def callback(target, mult, params):
-            model, coords = target.debug()
-            self.assertEqual(model, params.curve.model.shortname)
-            self.assertEqual(coords, params.curve.coordinate_model.name)
-
-        self.do_basic_test(callback, runner, self.secp128r1, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False, complete=False)
-
-
-class KeyGenerationTests(ImplTests):
-
-    def do_keygen_test(self, runner, params, mult_class, formulas, mult_name, **mult_kwargs):
-        def callback(target, mult, params):
-            for _ in range(10):
-                priv, pub = target.generate()
-                self.assertTrue(params.curve.is_on_curve(pub))
-                expected = mult.multiply(priv).to_affine()
-                self.assertEqual(pub, expected)
-
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, False,
-                           **mult_kwargs)
-
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "ltr", complete=False)
-        self.do_keygen_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "ltr", complete=True)
-        self.do_keygen_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "ltr", always=True, complete=False)
-        self.do_keygen_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "ltr", always=True, complete=True)
-
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "rtl", always=False)
-        self.do_keygen_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "rtl", always=True)
-
-    def test_coron(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.secp128r1, CoronMultiplier,
-                            ["add-1998-cmo", "dbl-1998-cmo"], "coron")
+@pytest.mark.parametrize(
+    "mult_class,mult_name,formulas,mult_kwargs",
+    [
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": False}),
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": True}),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": False, "always": True},
+        ),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": True, "always": True},
+        ),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": False}),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": True}),
+        (CoronMultiplier, "coron", ["add-1998-cmo", "dbl-1998-cmo"], {}),
+        (BinaryNAFMultiplier, "bnaf", ["add-1998-cmo", "dbl-1998-cmo", "neg"], {}),
+    ],
+)
+def test_keygen(mult_class, mult_name, mult_kwargs, formulas, cli_runner, secp128r1):
+    def callback(target, mult, params):
+        for _ in range(10):
+            priv, pub = target.generate()
+            assert params.curve.is_on_curve(pub)
+            expected = mult.multiply(priv).to_affine()
+            assert pub == expected
 
-    def test_bnaf(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.secp128r1, BinaryNAFMultiplier,
-                            ["add-1998-cmo", "dbl-1998-cmo", "neg"], "bnaf")
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        mult_class,
+        formulas,
+        mult_name,
+        False,
+        False,
+        **mult_kwargs,
+    )
 
     # def test_ladder(self):
     #    runner = CliRunner()
@@ -139,120 +167,152 @@ class KeyGenerationTests(ImplTests):
     #    # TODO: what about coords where generator is not affine?
 
 
-class ScalarMultiplicationTests(ImplTests):
+@pytest.mark.parametrize(
+    "mult_class,mult_name,formulas,mult_kwargs",
+    [
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": False}),
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": True}),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": False, "always": True},
+        ),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": True, "always": True},
+        ),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": False}),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": True}),
+        (CoronMultiplier, "coron", ["add-1998-cmo", "dbl-1998-cmo"], {}),
+        (BinaryNAFMultiplier, "bnaf", ["add-1998-cmo", "dbl-1998-cmo", "neg"], {}),
+    ],
+)
+def test_scalarmult(
+    mult_class, mult_name, mult_kwargs, formulas, cli_runner, secp128r1
+):
+    values = [15, 2355498743, 3253857901321912443757746]
 
-    def do_mult_test(self, runner, params, mult_class, formulas, mult_name, **mult_kwargs):
-        values = [15, 2355498743, 3253857901321912443757746]
+    def callback(target, mult, params):
+        for value in values:
+            result = target.scalar_mult(value, params.generator)
+            expected = mult.multiply(value)
+            assert result == expected
 
-        def callback(target, mult, params):
-            for value in values:
-                result = target.scalar_mult(value, params.generator)
-                expected = mult.multiply(value)
-                self.assertEqual(result, expected)
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        mult_class,
+        formulas,
+        mult_name,
+        False,
+        False,
+        **mult_kwargs,
+    )
 
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, False,
-                           **mult_kwargs)
 
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=False)
-        self.do_mult_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=True)
-        self.do_mult_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=False, always=True)
-        self.do_mult_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=True, always=True)
+@pytest.mark.parametrize(
+    "mult_class,mult_name,formulas,mult_kwargs",
+    [
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": False}),
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": True}),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": False, "always": True},
+        ),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": True, "always": True},
+        ),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": False}),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": True}),
+        (CoronMultiplier, "coron", ["add-1998-cmo", "dbl-1998-cmo"], {}),
+        (BinaryNAFMultiplier, "bnaf", ["add-1998-cmo", "dbl-1998-cmo", "neg"], {}),
+    ],
+)
+def test_ecdh(mult_class, mult_name, mult_kwargs, formulas, cli_runner, secp128r1):
+    other_privs = [15, 2355498743, 3253857901321912443757746]
 
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl", always=False)
-        self.do_mult_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl", always=True)
-
-    def test_coron(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.secp128r1, CoronMultiplier,
-                          ["add-1998-cmo", "dbl-1998-cmo"], "coron")
-
-    def test_bnaf(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.secp128r1, BinaryNAFMultiplier,
-                          ["add-1998-cmo", "dbl-1998-cmo", "neg"], "bnaf")
-
-
-class ECDHTests(ImplTests):
-    def do_ecdh_test(self, runner, params, mult_class, formulas, mult_name, **mult_kwargs):
-        other_privs = [15, 2355498743, 3253857901321912443757746]
-
-        def callback(target, mult, params):
-            for other_priv in other_privs:
-                priv, pub = target.generate()
-                other_pub = mult.multiply(other_priv)
-                ecdh = ECDH_SHA1(copy(mult), params, other_pub, priv)
-                result = target.ecdh(other_pub)
-                expected = ecdh.perform()
-                self.assertEqual(result, expected)
-
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, True,
-                           **mult_kwargs)
-
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=False)
-        self.do_ecdh_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=True)
-        self.do_ecdh_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=False, always=True)
-        self.do_ecdh_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr", complete=True, always=True)
-
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl", always=False)
-        self.do_ecdh_test(runner, self.secp128r1, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl", always=True)
-
-    def test_coron(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.secp128r1, CoronMultiplier,
-                          ["add-1998-cmo", "dbl-1998-cmo"], "coron")
-
-    def test_bnaf(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.secp128r1, BinaryNAFMultiplier,
-                          ["add-1998-cmo", "dbl-1998-cmo", "neg"], "bnaf")
+    def callback(target, mult, params):
+        for other_priv in other_privs:
+            priv, pub = target.generate()
+            other_pub = mult.multiply(other_priv)
+            ecdh = ECDH_SHA1(copy(mult), params, other_pub, priv)
+            result = target.ecdh(other_pub)
+            expected = ecdh.perform()
+            assert result == expected
 
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        mult_class,
+        formulas,
+        mult_name,
+        False,
+        True,
+        **mult_kwargs,
+    )
 
-class ECDSATests(ImplTests):
-    def do_ecdsa_test(self, runner, params, mult_class, formulas, mult_name, **mult_kwargs):
-        data = b"something"
 
-        def callback(target, mult, params):
-            priv, pub = target.generate()
-            ecdsa = ECDSA_SHA1(copy(mult), params, mult.formulas["add"],
-                               pub.to_model(params.curve.coordinate_model, params.curve), priv)
+@pytest.mark.parametrize(
+    "mult_class,mult_name,formulas,mult_kwargs",
+    [
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": False}),
+        (LTRMultiplier, "ltr", ["add-1998-cmo", "dbl-1998-cmo"], {"complete": True}),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": False, "always": True},
+        ),
+        (
+            LTRMultiplier,
+            "ltr",
+            ["add-1998-cmo", "dbl-1998-cmo"],
+            {"complete": True, "always": True},
+        ),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": False}),
+        (RTLMultiplier, "rtl", ["add-1998-cmo", "dbl-1998-cmo"], {"always": True}),
+        (CoronMultiplier, "coron", ["add-1998-cmo", "dbl-1998-cmo"], {}),
+        (BinaryNAFMultiplier, "bnaf", ["add-1998-cmo", "dbl-1998-cmo", "neg"], {}),
+    ],
+)
+def test_ecdsa(mult_class, mult_name, mult_kwargs, formulas, cli_runner, secp128r1):
+    data = b"something"
 
-            signature_data = target.ecdsa_sign(data)
-            result = SignatureResult.from_DER(signature_data)
-            self.assertTrue(ecdsa.verify_data(result, data))
+    def callback(target, mult, params):
+        priv, pub = target.generate()
+        ecdsa = ECDSA_SHA1(
+            copy(mult),
+            params,
+            mult.formulas["add"],
+            pub.to_model(params.curve.coordinate_model, params.curve),
+            priv,
+        )
 
-            expected = ecdsa.sign_data(data).to_DER()
-            self.assertTrue(target.ecdsa_verify(data, expected))
+        signature_data = target.ecdsa_sign(data)
+        result = SignatureResult.from_DER(signature_data)
+        assert ecdsa.verify_data(result, data)
 
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, True,
-                           False, **mult_kwargs)
+        expected = ecdsa.sign_data(data).to_DER()
+        assert target.ecdsa_verify(data, expected)
 
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_ecdsa_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                           "ltr", complete=False)
-        self.do_ecdsa_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                           "ltr", complete=True)
-        self.do_ecdsa_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                           "ltr", complete=False, always=True)
-        self.do_ecdsa_test(runner, self.secp128r1, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                           "ltr", complete=True, always=True)
\ No newline at end of file
+    do_basic_test(
+        callback,
+        cli_runner,
+        secp128r1,
+        mult_class,
+        formulas,
+        mult_name,
+        True,
+        False,
+        **mult_kwargs,
+    )
diff --git a/test/test_render.py b/test/test_render.py
index b8d6075..b190e35 100644
--- a/test/test_render.py
+++ b/test/test_render.py
@@ -1,34 +1,49 @@
 import tempfile
-from unittest import TestCase
 
-from pyecsca.ec.configuration import (HashType, RandomMod, Multiplication, Squaring, Reduction,
-                                      Inversion)
-from pyecsca.ec.params import get_params
+from pyecsca.ec.configuration import (
+    HashType,
+    RandomMod,
+    Multiplication,
+    Squaring,
+    Reduction,
+    Inversion,
+)
 from pyecsca.ec.mult import LTRMultiplier
 
 from pyecsca.codegen.common import Platform, DeviceConfiguration
 from pyecsca.codegen.render import render_and_build
 
 
-class RenderTests(TestCase):
-
-    def test_basic_build(self):
-        platform = Platform.HOST
-        hash_type = HashType.SHA1
-        mod_rand = RandomMod.REDUCE
-        mult = Multiplication.BASE
-        sqr = Squaring.BASE
-        red = Reduction.BASE
-        inv = Inversion.GCD
-        params = get_params("secg", "secp128r1", "projective")
-        model = params.curve.model
-        coords = params.curve.coordinate_model
-        add = coords.formulas["add-1998-cmo"]
-        dbl = coords.formulas["dbl-1998-cmo"]
-        scl = coords.formulas["z"]
-        formulas = [add, dbl, scl]
-        scalarmult = LTRMultiplier(add, dbl, scl)
-        config = DeviceConfiguration(model, coords, formulas, scalarmult, hash_type, mod_rand, mult,
-                                     sqr, red, inv, platform, True, True, True)
-        temp = tempfile.mkdtemp()
-        render_and_build(config, temp, True)
+def test_basic_build(secp128r1, tmp_path):
+    platform = Platform.HOST
+    hash_type = HashType.SHA1
+    mod_rand = RandomMod.REDUCE
+    mult = Multiplication.BASE
+    sqr = Squaring.BASE
+    red = Reduction.BASE
+    inv = Inversion.GCD
+    model = secp128r1.curve.model
+    coords = secp128r1.curve.coordinate_model
+    add = coords.formulas["add-1998-cmo"]
+    dbl = coords.formulas["dbl-1998-cmo"]
+    scl = coords.formulas["z"]
+    formulas = [add, dbl, scl]
+    scalarmult = LTRMultiplier(add, dbl, scl)
+    config = DeviceConfiguration(
+        model,
+        coords,
+        formulas,
+        scalarmult,
+        hash_type,
+        mod_rand,
+        mult,
+        sqr,
+        red,
+        inv,
+        platform,
+        True,
+        True,
+        True,
+    )
+    dir, elf_file, hex_file, res = render_and_build(config, str(tmp_path), True)
+    assert res.returncode == 0
diff --git a/test/test_simulator.py b/test/test_simulator.py
index d741cf4..e5a1c9d 100644
--- a/test/test_simulator.py
+++ b/test/test_simulator.py
@@ -1,10 +1,9 @@
 from copy import copy
 from os.path import join
-from unittest import TestCase
+import pytest
 
-from click.testing import CliRunner
 from pyecsca.ec.key_agreement import ECDH_SHA1
-from pyecsca.ec.mult import LTRMultiplier, RTLMultiplier, CoronMultiplier, BinaryNAFMultiplier
+from pyecsca.ec.mult import LTRMultiplier, RTLMultiplier
 from pyecsca.ec.signature import ECDSA_SHA1, SignatureResult
 
 from pyecsca.codegen.builder import build_impl
@@ -18,177 +17,212 @@ from pyecsca.ec.point import InfinityPoint, Point
 import gc
 
 
-class SimulatorTest(TestCase):
+@pytest.fixture(scope="module")
+def curve32():
+    model = ShortWeierstrassModel()
+    coords = model.coordinates["projective"]
+    p = 0xD7D1247F
+    a = Mod(0xA4A44016, p)
+    b = Mod(0x73F76716, p)
+    n = 0xD7D2A475
+    h = 1
+    gx, gy, gz = Mod(0x54EED6D7, p), Mod(0x6F1E55AC, p), Mod(1, p)
+    generator = Point(coords, X=gx, Y=gy, Z=gz)
+    neutral = InfinityPoint(coords)
 
-    def setUp(self):
-        model = ShortWeierstrassModel()
-        coords = model.coordinates["projective"]
-        p = 0xd7d1247f
-        a = Mod(0xa4a44016, p)
-        b = Mod(0x73f76716, p)
-        n = 0xd7d2a475
-        h = 1
-        gx, gy, gz = Mod(0x54eed6d7, p), Mod(0x6f1e55ac, p), Mod(1, p)
-        generator = Point(coords, X=gx, Y=gy, Z=gz)
-        neutral = InfinityPoint(coords)
+    curve = EllipticCurve(model, coords, p, neutral, {"a": a, "b": b})
+    params = DomainParameters(curve, generator, n, h)
+    return params
 
-        curve = EllipticCurve(model, coords, p, neutral, {"a": a, "b": b})
-        self.curve32 = DomainParameters(curve, generator, n, h)
-        self.base = self.curve32.generator
-        self.coords = self.curve32.curve.coordinate_model
 
-    def do_basic_test(self, callback, runner, params, mult_class, formulas, mult_name,
-                      ecdsa, ecdh):
-        with runner.isolated_filesystem() as tmpdir:
-            runner.invoke(build_impl,
-                        ["--platform", "STM32F3",
-                        "--ecdsa" if ecdsa else "--no-ecdsa",
-                        "--ecdh" if ecdh else "--no-ecdh", 
-                        params.curve.model.shortname, params.curve.coordinate_model.name,
-                        *formulas,
-                        f"{mult_name}()",
-                        "."])
-            target = SimulatorTarget(params.curve.model, params.curve.coordinate_model)
-            target.connect(binary=join(tmpdir, "pyecsca-codegen-CW308_STM32F3.elf"))
-            target.set_params(params)
-            formula_instances = [params.curve.coordinate_model.formulas[formula] for formula
-                                    in formulas]
-            mult = mult_class(*formula_instances)
-            mult.init(params, params.generator)
-            callback(target, mult, params)
-            target.disconnect()
-            del target
-            gc.collect()
+def do_basic_test(
+    callback, runner, params, mult_class, formulas, mult_name, ecdsa, ecdh
+):
+    with runner.isolated_filesystem() as tmpdir:
+        runner.invoke(
+            build_impl,
+            [
+                "--platform",
+                "STM32F3",
+                "--ecdsa" if ecdsa else "--no-ecdsa",
+                "--ecdh" if ecdh else "--no-ecdh",
+                params.curve.model.shortname,
+                params.curve.coordinate_model.name,
+                *formulas,
+                f"{mult_name}()",
+                ".",
+            ],
+        )
+        target = SimulatorTarget(params.curve.model, params.curve.coordinate_model)
+        target.connect(binary=join(tmpdir, "pyecsca-codegen-CW308_STM32F3.elf"))
+        target.set_params(params)
+        formula_instances = [
+            params.curve.coordinate_model.formulas[formula] for formula in formulas
+        ]
+        mult = mult_class(*formula_instances)
+        mult.init(params, params.generator)
+        callback(target, mult, params)
+        target.disconnect()
+        del target
+        gc.collect()
 
 
-class PRNGTests(SimulatorTest):
+def test_init(cli_runner, curve32):
+    def callback(target, mult, params):
+        target.init_prng(bytes([0x12, 0x34, 0x56, 0x78]))
 
-    def test_init(self):
-        runner = CliRunner()
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
-        def callback(target, mult, params):
-            target.init_prng(bytes([0x12, 0x34, 0x56, 0x78]))
 
-        self.do_basic_test(callback, runner, self.curve32, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False)
+def test_setup(cli_runner, curve32):
+    def callback(target, mult, params):
+        priv = 57
+        pub = mult.multiply(priv).to_affine()
+        target.set_privkey(priv)
+        target.set_pubkey(pub)
 
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
-class SetupTests(SimulatorTest):
 
-    def test_setup(self):
-        runner = CliRunner()
+def test_debug(cli_runner, curve32):
+    def callback(target, mult, params):
+        model, coords = target.debug()
+        assert model == params.curve.model.shortname
+        assert coords == params.curve.coordinate_model.name
 
-        def callback(target, mult, params):
-            priv = 57
-            pub = mult.multiply(priv).to_affine()
-            target.set_privkey(priv)
-            target.set_pubkey(pub)
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        LTRMultiplier,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        "ltr",
+        False,
+        False,
+    )
 
-        self.do_basic_test(callback, runner, self.curve32, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False)
 
-    def test_debug(self):
-        runner = CliRunner()
+@pytest.mark.parametrize(
+    "mult_name,mult_class", [("ltr", LTRMultiplier), ("rtl", RTLMultiplier)]
+)
+def test_keygen(mult_name, mult_class, cli_runner, curve32):
+    def callback(target, mult, params):
+        priv, pub = target.generate()
+        assert params.curve.is_on_curve(pub)
+        expected = mult.multiply(priv).to_affine()
+        assert pub == expected
 
-        def callback(target, mult, params):
-            model, coords = target.debug()
-            self.assertEqual(model, params.curve.model.shortname)
-            self.assertEqual(coords, params.curve.coordinate_model.name)
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        mult_class,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        mult_name,
+        False,
+        False,
+    )
 
-        self.do_basic_test(callback, runner, self.curve32, LTRMultiplier,
-                           ["add-1998-cmo", "dbl-1998-cmo"], "ltr", False, False)
 
+@pytest.mark.parametrize(
+    "mult_name,mult_class", [("ltr", LTRMultiplier), ("rtl", RTLMultiplier)]
+)
+def test_scalarmult(mult_name, mult_class, cli_runner, curve32):
+    values = [2355498743]
 
-class KeyGenerationTests(SimulatorTest):
+    def callback(target, mult, params):
+        for value in values:
+            result = target.scalar_mult(value, params.generator)
+            expected = mult.multiply(value)
+            assert result == expected
 
-    def do_keygen_test(self, runner, params, mult_class, formulas, mult_name):
-        def callback(target, mult, params):
-            priv, pub = target.generate()
-            self.assertTrue(params.curve.is_on_curve(pub))
-            expected = mult.multiply(priv).to_affine()
-            self.assertEqual(pub, expected)
-
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, False)
-
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.curve32, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "ltr")
-
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_keygen_test(runner, self.curve32, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                            "rtl")
-
-
-class ScalarMultiplicationTests(SimulatorTest):
-
-    def do_mult_test(self, runner, params, mult_class, formulas, mult_name):
-        values = [2355498743]
-
-        def callback(target, mult, params):
-            for value in values:
-                result = target.scalar_mult(value, params.generator)
-                expected = mult.multiply(value)
-                self.assertEqual(result, expected)
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        mult_class,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        mult_name,
+        False,
+        False,
+    )
 
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, False)
 
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.curve32, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr")
+@pytest.mark.parametrize(
+    "mult_name,mult_class", [("ltr", LTRMultiplier), ("rtl", RTLMultiplier)]
+)
+def test_ecdh(mult_name, mult_class, cli_runner, curve32):
+    other_privs = [2355498743]
 
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_mult_test(runner, self.curve32, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl")
-
-
-class ECDHTests(SimulatorTest):
-    def do_ecdh_test(self, runner, params, mult_class, formulas, mult_name):
-        other_privs = [2355498743]
-
-        def callback(target, mult, params):
-            for other_priv in other_privs:
-                priv, pub = target.generate()
-                other_pub = mult.multiply(other_priv)
-                ecdh = ECDH_SHA1(copy(mult), params, other_pub, priv)
-                result = target.ecdh(other_pub)
-                expected = ecdh.perform()
-                self.assertEqual(result, expected)
-
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, False, True)
-
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.curve32, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "ltr")
-
-    def test_rtl(self):
-        runner = CliRunner()
-        self.do_ecdh_test(runner, self.curve32, RTLMultiplier, ["add-1998-cmo", "dbl-1998-cmo"],
-                          "rtl")
+    def callback(target, mult, params):
+        for other_priv in other_privs:
+            priv, pub = target.generate()
+            other_pub = mult.multiply(other_priv)
+            ecdh = ECDH_SHA1(copy(mult), params, other_pub, priv)
+            result = target.ecdh(other_pub)
+            expected = ecdh.perform()
+            assert result == expected
 
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        mult_class,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        mult_name,
+        False,
+        True,
+    )
 
-class ECDSATests(SimulatorTest):
-    def do_ecdsa_test(self, runner, params, mult_class, formulas, mult_name):
-        data = b"something"
 
-        def callback(target, mult, params):
-            priv, pub = target.generate()
-            ecdsa = ECDSA_SHA1(copy(mult), params, mult.formulas["add"],
-                               pub.to_model(params.curve.coordinate_model, params.curve), priv)
+@pytest.mark.parametrize(
+    "mult_name,mult_class", [("ltr", LTRMultiplier), ("rtl", RTLMultiplier)]
+)
+def test_ecdsa(mult_name, mult_class, cli_runner, curve32):
+    data = b"something"
 
-            signature_data = target.ecdsa_sign(data)
-            result = SignatureResult.from_DER(bytes(signature_data))
-            self.assertTrue(ecdsa.verify_data(result, data))
+    def callback(target, mult, params):
+        priv, pub = target.generate()
+        ecdsa = ECDSA_SHA1(
+            copy(mult),
+            params,
+            mult.formulas["add"],
+            pub.to_model(params.curve.coordinate_model, params.curve),
+            priv,
+        )
 
-            expected = ecdsa.sign_data(data).to_DER()
-            self.assertTrue(target.ecdsa_verify(data, expected))
+        signature_data = target.ecdsa_sign(data)
+        result = SignatureResult.from_DER(bytes(signature_data))
+        assert ecdsa.verify_data(result, data)
 
-        self.do_basic_test(callback, runner, params, mult_class, formulas, mult_name, True, False)
+        expected = ecdsa.sign_data(data).to_DER()
+        assert target.ecdsa_verify(data, expected)
 
-    def test_ltr(self):
-        runner = CliRunner()
-        self.do_ecdsa_test(runner, self.curve32, LTRMultiplier, ["add-1998-cmo", "dbl-1998-cmo"], "ltr")
\ No newline at end of file
+    do_basic_test(
+        callback,
+        cli_runner,
+        curve32,
+        mult_class,
+        ["add-1998-cmo", "dbl-1998-cmo"],
+        mult_name,
+        True,
+        False,
+    )
diff --git a/unittest.cfg b/unittest.cfg
deleted file mode 100644
index c057996..0000000
--- a/unittest.cfg
+++ /dev/null
@@ -1,3 +0,0 @@
-[unittest]
-plugins = nose2.plugins.attrib
-          nose2.plugins.doctests
\ No newline at end of file