tests: convert all to pytest

Author: james-d-mitchell

libsemigroups_pybind11/transf.py

@@ -7,7 +7,7 @@
 # The full license is in the file LICENSE, distributed with this software.
 
 # pylint: disable=no-name-in-module, invalid-name
-# pylint: disable=bad-option-value, consider-using-f-string
+# pylint: disable=bad-option-value, consider-using-f-string, duplicate-code
 
 """
 This package provides a the user-facing python part of libsemigroups_pybind11

tests/element.py

@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=no-name-in-module, missing-function-docstring
-# pylint: disable=missing-class-docstring, invalid-name
 
 # Copyright (c) 2021, J. D. Mitchell
 #
@@ -12,15 +10,17 @@
 This module contains some tests for elements.
 """
 
+# pylint: disable=no-name-in-module, missing-function-docstring, invalid-name
 
-def check_products(self, x):
+
+def check_products(x):
     y = x.identity()
     z = x.identity()
     z.product_inplace(x, y, 0)
-    self.assertEqual(z, x)
+    assert z == x
     z.product_inplace(y, x, 0)
-    self.assertEqual(z, x)
+    assert z == x
     z.product_inplace(x, x, 0)
-    self.assertEqual(z, x * x)
-    self.assertEqual(x * x.identity(), x)
-    self.assertEqual(x.identity() * x, x)
+    assert z == x * x
+    assert x * x.identity() == x
+    assert x.identity() * x == x

tests/fpsemi_intf.py

@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=no-name-in-module, missing-function-docstring
-# pylint: disable=missing-class-docstring, invalid-name
 
 # Copyright (c) 2021, J. D. Mitchell + Maria Tsalakou
 #
@@ -13,93 +11,96 @@
 derived classes, i.e. KnuthBendix, FpSemigroup, etc.
 """
 
+# pylint: disable=no-name-in-module, missing-function-docstring, invalid-name
+
 from datetime import timedelta
+import pytest
 from runner import check_runner
 from libsemigroups_pybind11 import ReportGuard, FroidurePin, Transf
 
 
-def check_validation(self, t):
+def check_validation(t):
     ReportGuard(False)
     x = t()
     x.set_alphabet("ab")
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.validate_letter("c")
     try:
         x.validate_letter("a")
     except RuntimeError as e:
-        self.fail(
+        pytest.fail(
             "unexpected exception raised for FpSemigroupInterface::validate_letter: "
             + e
         )
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.validate_letter(3)
     try:
         x.validate_letter(0)
     except RuntimeError as e:
-        self.fail(
+        pytest.fail(
             "unexpected exception raised for FpSemigroupInterface::validate_letter: "
             + e
         )
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.validate_word("abc")
     try:
         x.validate_word("abab")
     except RuntimeError as e:
-        self.fail(
+        pytest.fail(
             "unexpected exception raised for FpSemigroupInterface::validate_letter: "
             + e
         )
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.validate_word([0, 1, 2])
 
     try:
         x.validate_word([0, 1, 0, 1])
     except RuntimeError as e:
-        self.fail(
+        pytest.fail(
             "unexpected exception raised for FpSemigroupInterface::validate_letter: "
             + e
         )
 
 
-def check_converters(self, t):
+def check_converters(t):
     ReportGuard(False)
     x = t()
     x.set_alphabet("ba")
-    self.assertEqual(x.char_to_uint("a"), 1)
-    self.assertEqual(x.char_to_uint("b"), 0)
+    assert x.char_to_uint("a") == 1
+    assert x.char_to_uint("b") == 0
 
-    self.assertEqual(x.string_to_word("ab"), [1, 0])
-    self.assertEqual(x.string_to_word("aaaaaa"), [1] * 6)
-    with self.assertRaises(RuntimeError):
+    assert x.string_to_word("ab") == [1, 0]
+    assert x.string_to_word("aaaaaa") == [1] * 6
+    with pytest.raises(RuntimeError):
         x.string_to_word("c")
 
-    self.assertEqual(x.uint_to_char(0), "b")
-    self.assertEqual(x.uint_to_char(1), "a")
-    with self.assertRaises(RuntimeError):
+    assert x.uint_to_char(0) == "b"
+    assert x.uint_to_char(1) == "a"
+    with pytest.raises(RuntimeError):
         x.uint_to_char(2)
 
-    self.assertEqual(x.word_to_string([1, 0]), "ab")
-    self.assertEqual(x.word_to_string([1] * 6), "a" * 6)
-    with self.assertRaises(RuntimeError):
+    assert x.word_to_string([1, 0]) == "ab"
+    assert x.word_to_string([1] * 6) == "a" * 6
+    with pytest.raises(RuntimeError):
         x.word_to_string([2])
 
 
-def check_initialisation(self, t):
+def check_initialisation(t):
     ReportGuard(False)
     x = t()
     x.set_alphabet("ba")
     x.add_rule([0, 1], [1, 0])
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.add_rule([0, 1], [2])
 
     S = FroidurePin([Transf([1, 2, 0]), Transf([1, 0, 2])])
     S.run()
     x.add_rules(S)
-    self.assertEqual(x.size(), 2)
+    assert x.size() == 2
 
     x = t()
     x.set_alphabet("abBe")
@@ -109,15 +110,15 @@ def check_initialisation(self, t):
 
     x.add_rule("bb", "B")
     x.add_rule("BaBa", "abab")
-    self.assertEqual(x.size(), 24)
+    assert x.size() == 24
 
     x = t()
     x.set_alphabet(1)
     x.set_identity(0)
-    self.assertEqual(x.size(), 1)
+    assert x.size() == 1
 
 
-def check_attributes(self, t):
+def check_attributes(t):
     ReportGuard(False)
     x = t()
     x.set_alphabet("abBe")
@@ -128,36 +129,33 @@ def check_attributes(self, t):
     x.add_rule("BaBa", "abab")
     x.run()
 
-    self.assertEqual(
-        list(x.rules()),
-        [
-            ("ae", "a"),
-            ("ea", "a"),
-            ("be", "b"),
-            ("eb", "b"),
-            ("Be", "B"),
-            ("eB", "B"),
-            ("ee", "e"),
-            ("aa", "e"),
-            ("bB", "e"),
-            ("Bb", "e"),
-            ("bb", "B"),
-            ("BaBa", "abab"),
-        ],
-    )
-    self.assertEqual(x.number_of_rules(), 12)
-
-    self.assertEqual(x.alphabet(), "abBe")
-    self.assertFalse(x.has_froidure_pin())
-    self.assertEqual(x.froidure_pin().size(), 24)
-    self.assertEqual(x.identity(), "e")
-    self.assertEqual(x.inverses(), "aBbe")
-    self.assertFalse(x.is_obviously_infinite())
-    self.assertTrue(x.is_obviously_finite())
-    self.assertEqual(x.size(), 24)
-
-
-def check_operators(self, t):
+    assert list(x.rules()) == [
+        ("ae", "a"),
+        ("ea", "a"),
+        ("be", "b"),
+        ("eb", "b"),
+        ("Be", "B"),
+        ("eB", "B"),
+        ("ee", "e"),
+        ("aa", "e"),
+        ("bB", "e"),
+        ("Bb", "e"),
+        ("bb", "B"),
+        ("BaBa", "abab"),
+    ]
+    assert x.number_of_rules() == 12
+
+    assert x.alphabet() == "abBe"
+    assert not x.has_froidure_pin()
+    assert x.froidure_pin().size() == 24
+    assert x.identity() == "e"
+    assert x.inverses() == "aBbe"
+    assert not x.is_obviously_infinite()
+    assert x.is_obviously_finite()
+    assert x.size() == 24
+
+
+def check_operators(t):
     x = t()
     x.set_alphabet("abBe")
     x.set_identity("e")
@@ -166,31 +164,31 @@ def check_operators(self, t):
     x.add_rule("bb", "B")
     x.add_rule("BaBa", "abab")
     x.run()
-    self.assertTrue(x.equal_to("bb", "B"))
-    self.assertTrue(x.equal_to([1, 1], [2]))
+    assert x.equal_to("bb", "B")
+    assert x.equal_to([1, 1], [2])
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.equal_to([1, 1], [5])
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.equal_to("aa", "z")
 
-    self.assertEqual(x.normal_form("bb"), "B")
-    self.assertEqual(x.normal_form("B"), "B")
-    self.assertEqual(x.normal_form([1, 1]), [2])
-    self.assertEqual(x.normal_form([0, 0]), [3])
+    assert x.normal_form("bb") == "B"
+    assert x.normal_form("B") == "B"
+    assert x.normal_form([1, 1]) == [2]
+    assert x.normal_form([0, 0]) == [3]
 
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.normal_form([1, 5])
-    with self.assertRaises(RuntimeError):
+    with pytest.raises(RuntimeError):
         x.normal_form("z")
 
     if hasattr(t, "rewrite"):
-        self.assertEqual(x.rewrite("aa"), "")
-        self.assertEqual(x.rewrite("bb"), "B")
+        assert x.rewrite("aa") == ""
+        assert x.rewrite("bb") == "B"
 
-        with self.assertRaises(TypeError):
-            self.assertEqual(x.rewrite("z"))
+        with pytest.raises(TypeError):
+            x.rewrite("z")
 
 
 def check_running_and_state(T):