Reuse and improve ergonomics of assert_raises utility

- Move assert_raises to testutils
- Add optional message argument, with reasonable default
- Reverse order of expr and exception type for readability
- Lambda argument no longer takes parameter
- Convert applicable snippets to use assert_raises

Author: OddCoincidence

tests/snippets/builtin_divmod.py

@@ -1,17 +1,8 @@
+from testutils import assert_raises
+
 assert divmod(11, 3) == (3, 2)
 assert divmod(8,11) == (0, 8)
 assert divmod(0.873, 0.252) == (3.0, 0.11699999999999999)
 
-try:
-    divmod(5, 0)
-except ZeroDivisionError:
-    pass
-else:
-    assert False, "Expected divmod by zero to throw ZeroDivisionError"
-
-try:
-    divmod(5.0, 0.0)
-except ZeroDivisionError:
-    pass
-else:
-    assert False, "Expected divmod by zero to throw ZeroDivisionError"
+assert_raises(ZeroDivisionError, lambda: divmod(5, 0), 'divmod by zero')
+assert_raises(ZeroDivisionError, lambda: divmod(5.0, 0.0), 'divmod by zero')

tests/snippets/builtin_format.py

@@ -1,17 +1,9 @@
+from testutils import assert_raises
+
 assert format(5, "b") == "101"
 
-try:
-    format(2, 3)
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when format is called with a number"
+assert_raises(TypeError, lambda: format(2, 3), 'format called with number')
 
 assert format({}) == "{}"
 
-try:
-    format({}, 'b')
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when format_spec not empty for dict"
+assert_raises(TypeError, lambda: format({}, 'b'), 'format_spec not empty for dict')

tests/snippets/builtin_hex.py

@@ -1,9 +1,6 @@
+from testutils import assert_raises
+
 assert hex(16) == '0x10'
 assert hex(-16) == '-0x10'
 
-try:
-    hex({})
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when ord() is called with a dict"
+assert_raises(TypeError, lambda: hex({}), 'ord() called with dict')

tests/snippets/builtin_max.py

@@ -1,3 +1,5 @@
+from testutils import assert_raises
+
 # simple values
 assert max(0, 0) == 0
 assert max(1, 0) == 1
@@ -14,32 +16,17 @@
 }) == "b"
 assert max([1, 2], default=0) == 2
 assert max([], default=0) == 0
-try:
-    max([])
-except ValueError:
-    pass
-else:
-    assert False, "ValueError was not raised"
+assert_raises(ValueError, lambda: max([]))
 
 # key parameter
 assert max(1, 2, -3, key=abs) == -3
 assert max([1, 2, -3], key=abs) == -3
 
 # no argument
-try:
-    max()
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: max())
 
 # one non-iterable argument
-try:
-    max(1)
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: max(1))
 
 
 # custom class
@@ -64,9 +51,4 @@ class MyNotComparable():
     pass
 
 
-try:
-    max(MyNotComparable(), MyNotComparable())
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: max(MyNotComparable(), MyNotComparable()))

tests/snippets/builtin_min.py

@@ -1,3 +1,5 @@
+from testutils import assert_raises
+
 # simple values
 assert min(0, 0) == 0
 assert min(1, 0) == 0
@@ -14,32 +16,18 @@
 }) == "a"
 assert min([1, 2], default=0) == 1
 assert min([], default=0) == 0
-try:
-    min([])
-except ValueError:
-    pass
-else:
-    assert False, "ValueError was not raised"
+
+assert_raises(ValueError, lambda: min([]))
 
 # key parameter
 assert min(1, 2, -3, key=abs) == 1
 assert min([1, 2, -3], key=abs) == 1
 
 # no argument
-try:
-    min()
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: min())
 
 # one non-iterable argument
-try:
-    min(1)
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: min(1))
 
 
 # custom class
@@ -64,9 +52,4 @@ class MyNotComparable():
     pass
 
 
-try:
-    min(MyNotComparable(), MyNotComparable())
-except TypeError:
-    pass
-else:
-    assert False, "TypeError was not raised"
+assert_raises(TypeError, lambda: min(MyNotComparable(), MyNotComparable()))

tests/snippets/builtin_open.py

@@ -1,8 +1,6 @@
+from testutils import assert_raises
+
 fd = open('README.md')
 assert 'RustPython' in fd.read()
 
-try:
-    open('DoesNotExist')
-    assert False
-except FileNotFoundError:
-    pass
+assert_raises(FileNotFoundError, lambda: open('DoesNotExist'))

tests/snippets/builtin_ord.py

@@ -1,23 +1,9 @@
+from testutils import assert_raises
+
 assert ord("a") == 97
 assert ord("é") == 233
 assert ord("🤡") == 129313
-try:
-    ord()
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when ord() is called with no argument"
-
-try:
-    ord("")
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when ord() is called with an empty string"
 
-try:
-    ord("ab")
-except TypeError:
-    pass
-else:
-    assert False, "TypeError not raised when ord() is called with more than one character"
+assert_raises(TypeError, lambda: ord(), "ord() is called with no argument")
+assert_raises(TypeError, lambda: ord(""), "ord() is called with an empty string")
+assert_raises(TypeError, lambda: ord("ab"), "ord() is called with more than one character")

tests/snippets/builtin_range.py

@@ -1,20 +1,4 @@
-def assert_raises(expr, exc_type):
-    """
-    Helper function to assert `expr` raises an exception of type `exc_type`
-    Args:
-        expr: Callable
-        exec_type: Exception
-    Returns:
-        None
-    Raises:
-        Assertion error on failure
-    """
-    try:
-        expr(None)
-    except exc_type:
-        assert True
-    else:
-        assert False
+from testutils import assert_raises
 
 assert range(2**63+1)[2**63] == 9223372036854775808
 
@@ -29,15 +13,10 @@ def assert_raises(expr, exc_type):
 assert range(4, 10, 2).index(6) == 1
 assert range(10, 4, -2).index(8) == 1
 
-# index raises value error on out of bounds
-assert_raises(lambda _: range(10).index(-1), ValueError)
-assert_raises(lambda _: range(10).index(10), ValueError)
-
-# index raises value error if out of step
-assert_raises(lambda _: range(4, 10, 2).index(5), ValueError)
-
-# index raises value error if needle is not an int
-assert_raises(lambda _: range(10).index('foo'), ValueError)
+assert_raises(ValueError, lambda: range(10).index(-1), 'out of bounds')
+assert_raises(ValueError, lambda: range(10).index(10), 'out of bounds')
+assert_raises(ValueError, lambda: range(4, 10, 2).index(5), 'out of step')
+assert_raises(ValueError, lambda: range(10).index('foo'), 'not an int')
 
 # count tests
 assert range(10).count(2) == 1

tests/snippets/builtin_slice.py

@@ -1,3 +1,4 @@
+from testutils import assert_raises
 
 a = []
 assert a[:] == []
@@ -18,12 +19,7 @@
 assert b[0:0] == []
 assert b[1:0] == []
 
-try:
-    _ = b[::0]
-except ValueError:
-    pass
-else:
-    assert False, "Zero step slice should raise ValueError"
+assert_raises(ValueError, lambda: b[::0], 'zero step slice')
 
 assert b[::-1] == [2, 1]
 assert b[1::-1] == [2, 1]

tests/snippets/division_by_zero.py

@@ -1,55 +1,11 @@
-try:
-    5 / 0
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
+from testutils import assert_raises
 
-try:
-    5 / -0.0
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
+assert_raises(ZeroDivisionError, lambda: 5 / 0)
+assert_raises(ZeroDivisionError, lambda: 5 / -0.0)
+assert_raises(ZeroDivisionError, lambda: 5 / (2-2))
+assert_raises(ZeroDivisionError, lambda: 5 % 0)
+assert_raises(ZeroDivisionError, lambda: 5 // 0)
+assert_raises(ZeroDivisionError, lambda: 5.3 // (-0.0))
+assert_raises(ZeroDivisionError, lambda: divmod(5, 0))
 
-try:
-    5 / (2-2)
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
-
-try:
-    5 % 0
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
-
-try:
-    5 // 0
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
-
-try:
-    5.3 // (-0.0)
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
-
-try:
-    divmod(5, 0)
-except ZeroDivisionError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
-
-try:
-    raise ZeroDivisionError('Is an ArithmeticError subclass?')
-except ArithmeticError:
-    pass
-else:
-    assert False, 'Expected ZeroDivisionError'
+assert issubclass(ZeroDivisionError, ArithmeticError)

tests/snippets/division_of_big_ints.py

@@ -1,3 +1,5 @@
+from testutils import assert_raises
+
 # 2.456984346552728
 res = 10**500 / (4 * 10**499 + 7 * 10**497 + 3 * 10**494)
 assert 2.456984 <= res <= 2.456985
@@ -8,20 +10,10 @@
 
 assert 10**500 / (2*10**(500-308)) == 5e307
 assert 10**500 / (10**(500-308)) == 1e308
-try:
-    10**500 / (10**(500-309))
-except OverflowError:
-    pass
-else:
-    assert False, 'Expected overflow on too big result'
+assert_raises(OverflowError, lambda: 10**500 / (10**(500-309)), 'too big result')
 
 # a bit more than f64::MAX = 1.7976931348623157e+308_f64
 assert (2 * 10**308) / 2 == 1e308
 
 # when dividing too big int by a float, the operation should fail
-try:
-    (2 * 10**308) / 2.0
-except OverflowError:
-    pass
-else:
-    assert False, 'Expected overflow on division of a big int by a float'
+assert_raises(OverflowError, lambda: (2 * 10**308) / 2.0, 'division of big int by float')

tests/snippets/floats.py

@@ -1,22 +1,6 @@
 import math
 
-def assert_raises(expr, exc_type):
-    """
-    Helper function to assert `expr` raises an exception of type `exc_type`
-    Args:
-        expr: Callable
-        exec_type: Exception
-    Returns:
-        None
-    Raises:
-        Assertion error on failure
-    """
-    try:
-        expr(None)
-    except exc_type:
-        assert True
-    else:
-        assert False
+from testutils import assert_raises
 
 1 + 1.1
 
@@ -79,8 +63,8 @@ def assert_raises(expr, exc_type):
 assert float(b'3.14') == 3.14
 assert float(b'2.99e-23') == 2.99e-23
 
-assert_raises(lambda _: float('foo'), ValueError)
-assert_raises(lambda _: float(2**10000), OverflowError)
+assert_raises(ValueError, lambda: float('foo'))
+assert_raises(OverflowError, lambda: float(2**10000))
 
 # check that magic methods are implemented for ints and floats