Convert remaining exception tests to pytest format

theano/compile/tests/test_debugmode.py

@@ -8,7 +8,6 @@ from six import reraise
 from theano import config
 from theano import gof
 import theano
-from theano.compat import exc_message
 from theano.compile import debugmode
 import theano.tensor
 from theano.tests import unittest_tools as utt
@@ -214,14 +213,10 @@ def test_badthunkoutput():
     if not theano.config.cxx:
         pytest.skip("G++ not available, so we need to skip this test.")
 
-    try:
+    with pytest.raises(debugmode.BadThunkOutput) as einfo:
         f_inconsistent([1.0, 2.0, 3.0], [2, 3, 4])
-    except debugmode.BadThunkOutput as e:
-        # print repr(e)
-        assert e.r.owner.op is inconsistent
-        return  # TEST PASS
 
-    assert False  # an error should have been detected
+    assert einfo.value.r.owner.op is inconsistent
 
 
 def test_badoptimization():
@@ -240,15 +235,11 @@ def test_badoptimization():
 
     f = theano.function([a, b], a + b, mode=debugmode.DebugMode(optimizer=opt))
 
-    try:
+    with pytest.raises(debugmode.BadOptimization) as einfo:
         f(
             [1.0, 2.0, 3.0], [2, 3, 4],
         )
-    except debugmode.BadOptimization as e:
-        assert str(e.reason) == "insert_broken_add"
-        return  # TEST PASS
-
-    assert False
+    assert str(einfo.value.reason) == "insert_broken_add"
 
 
 def test_badoptimization_opt_err():
@@ -283,17 +274,15 @@ def test_badoptimization_opt_err():
     b = theano.tensor.dvector()
 
     f = theano.function([a, b], a + b, mode=debugmode.DebugMode(optimizer=opt))
-    try:
+    with pytest.raises(ValueError, match=r"insert_bigger_b_add"):
         f(
             [1.0, 2.0, 3.0], [2, 3, 4],
         )
-    except ValueError as e:
-        assert "insert_bigger_b_add" in exc_message(e)
-    else:
-        assert False
 
     # Test that opt that do an illegal change still get the error from gof.
-    try:
+    with pytest.raises(
+        theano.gof.toolbox.BadOptimization, match=r"insert_bad_dtype"
+    ) as einfo:
         with theano.change_flags(on_opt_error="raise"):
             f2 = theano.function(
                 [a, b],
@@ -303,20 +292,14 @@ def test_badoptimization_opt_err():
         f2(
             [1.0, 2.0, 3.0], [2, 3, 4],
         )
-    except theano.gof.toolbox.BadOptimization as e:
-        assert "insert_bad_dtype" in str(e)
+
     # Test that we can reraise the error with an extended message
-        try:
+    with pytest.raises(theano.gof.toolbox.BadOptimization):
+        e = einfo.value
         new_e = e.__class__("TTT" + str(e))
         exc_type, exc_value, exc_trace = sys.exc_info()
         exc_value = new_e
         reraise(e.__class__, exc_value, exc_trace)
-        except theano.gof.toolbox.BadOptimization:
-            pass
-        else:
-            assert False
-    else:
-        assert False
 
 
 def test_stochasticoptimization():
@@ -340,7 +323,7 @@ def test_stochasticoptimization():
     a = theano.tensor.dvector()
     b = theano.tensor.dvector()
 
-    try:
+    with pytest.raises(debugmode.StochasticOrder):
         theano.function(
             [a, b],
             theano.tensor.add(a, b),
@@ -350,9 +333,6 @@ def test_stochasticoptimization():
                 stability_patience=max(2, config.DebugMode.patience),
             ),
         )
-    except debugmode.StochasticOrder:
-        return  # TEST PASS
-    assert False
 
 
 def test_just_c_code():
@@ -379,11 +359,8 @@ def test_baddestroymap():
     y = theano.tensor.dvector()
     f = theano.function([x, y], BadAdd()(x, y), mode="DEBUG_MODE")
 
-    try:
+    with pytest.raises(debugmode.BadDestroyMap):
         f([1, 2], [3, 4])
-        assert False  # failed to raise error
-    except debugmode.BadDestroyMap:
-        pass
 
 
 def test_baddestroymap_c():
@@ -391,11 +368,8 @@ def test_baddestroymap_c():
         pytest.skip("G++ not available, so we need to skip this test.")
     x = theano.tensor.dvector()
     f = theano.function([x], wb2i(x), mode=debugmode.DebugMode(check_py_code=False))
-    try:
+    with pytest.raises(debugmode.BadDestroyMap):
         assert np.all(f([1, 2]) == [2, 4])
-        assert False  # failed to raise error
-    except debugmode.BadDestroyMap:
-        pass
 
 
 class TestViewMap:
@@ -423,21 +397,15 @@ class TestViewMap:
         x = theano.tensor.dvector()
         y = theano.tensor.dvector()
         f = theano.function([x, y], self.BadAddRef()(x, y), mode="DEBUG_MODE")
-        try:
+        with pytest.raises(debugmode.BadViewMap):
             f([1, 2], [3, 4])
-            assert False  # failed to raise error
-        except debugmode.BadViewMap:
-            return
 
     def test_badviewmap_slice(self):
         x = theano.tensor.dvector()
         y = theano.tensor.dvector()
         f = theano.function([x, y], self.BadAddSlice()(x, y), mode="DEBUG_MODE")
-        try:
+        with pytest.raises(debugmode.BadViewMap):
             f([1, 2], [3, 4])
-            assert False  # failed to raise error
-        except debugmode.BadViewMap:
-            return
 
     def test_goodviewmap(self):
         goodop = self.BadAddRef()
@@ -445,22 +413,16 @@ class TestViewMap:
         x = theano.tensor.dvector()
         y = theano.tensor.dvector()
         f = theano.function([x, y], goodop(x, y), mode="DEBUG_MODE")
-        try:
+        # Shouldn't raise an error
         f([1, 5, 1], [3, 4, 2, 1, 4])
-            return
-        except debugmode.BadViewMap:
-            assert False  # failed to raise error
 
     def test_badviewmap_c(self):
         if not theano.config.cxx:
-            pytest.skip("G++ not available, so we need to skip this test.")
+            pytest.skip("C++ not available, so we need to skip this test.")
         x = theano.tensor.dvector()
         f = theano.function([x], wb1i(x), mode=debugmode.DebugMode(check_py_code=False))
-        try:
+        with pytest.raises(debugmode.BadViewMap):
             f([1, 2])
-            assert False  # failed to raise error
-        except debugmode.BadViewMap:
-            pass
 
     def test_aliased_outputs_ok(self):
         # here aliased outputs is ok because they are both aliased to an input
@@ -563,12 +525,8 @@ class TestViewMap:
         out = bad_xy0 * 2 + bad_xy1 * 2
         f = theano.function([x, y], out, mode="DEBUG_MODE")
 
-        try:
+        with pytest.raises(debugmode.BadViewMap):
             f([1, 2, 3, 4], [5, 6, 7, 8])
-            assert False  # DebugMode should have caught the error
-        except debugmode.BadViewMap:
-            # print e
-            pass
 
         # the situation can be rescued by picking one of the inputs and
         # pretending that it is aliased to both the outputs.

theano/gof/tests/test_cc.py

@@ -365,14 +365,11 @@ def test_duallinker_mismatch():
     # (purposely) wrong
     assert PerformLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -10.0
 
-    try:
+    with pytest.raises(MyExc):
         # this runs OpWiseCLinker and PerformLinker in parallel and feeds
         # variables of matching operations to _my_checker to verify that they
         # are the same.
         fn(1.0, 2.0, 3.0)
-        raise Exception("An exception should have been raised here!")
-    except MyExc:
-        pass
 
 
 ################################
@@ -407,12 +404,8 @@ def test_c_fail_error():
     e = add_fail(mul(x, y), mul(y, z))
     lnk = OpWiseCLinker().accept(Env([y, z], [e]))
     fn = lnk.make_function()
-    try:
+    with pytest.raises(RuntimeError):
         fn(1.5, 3.0)
-    except RuntimeError:
-        print("Yay, TEST PASSED")
-        return  # test passed
-    assert 0  # test failed
 
 
 def test_shared_input_output():

theano/gof/tests/test_optdb.py

 from __future__ import absolute_import, print_function, division
+import pytest
 
-from theano.compat import exc_message
 from theano.gof.optdb import opt, DB
 
 
 class TestDB:
-    def test_0(self):
+    def test_name_clashes(self):
         class Opt(opt.Optimizer):  # inheritance buys __hash__
             name = "blah"
 
@@ -20,35 +20,11 @@ class TestDB:
         assert "b" in db
         assert "c" in db
 
-        try:
+        with pytest.raises(ValueError, match=r"The name.*"):
             db.register("c", Opt())  # name taken
-            self.fail()
-        except ValueError as e:
-            if exc_message(e).startswith("The name"):
-                pass
-            else:
-                raise
-        except Exception:
-            self.fail()
-
-        try:
+
+        with pytest.raises(ValueError, match=r"The name.*"):
             db.register("z", Opt())  # name collides with tag
-            self.fail()
-        except ValueError as e:
-            if exc_message(e).startswith("The name"):
-                pass
-            else:
-                raise
-        except Exception:
-            self.fail()
-
-        try:
+
+        with pytest.raises(ValueError, match=r"The tag.*"):
             db.register("u", Opt(), "b")  # name new but tag collides with name
-            self.fail()
-        except ValueError as e:
-            if exc_message(e).startswith("The tag"):
-                pass
-            else:
-                raise
-        except Exception:
-            self.fail()

theano/gpuarray/tests/test_basic_ops.py

@@ -187,13 +187,12 @@ def makeTester(
                         raise
 
             for i, (variable, expected) in enumerate(izip(variables, expecteds)):
-                if (
+                condition = (
                     variable.dtype != expected.dtype
                     or variable.shape != expected.shape
                     or not TensorType.values_eq_approx(variable, expected)
-                ):
-                    self.fail(
-                        (
+                )
+                assert not condition, (
                     "Test %s::%s: Output %s gave the wrong "
                     "value. With inputs %s, expected %s "
                     "(dtype %s), got %s (dtype %s)."
@@ -208,17 +207,11 @@ def makeTester(
                         variable.dtype,
                     )
                 )
-                    )
 
             for description, check in iteritems(self.checks):
-                if not check(inputs, variables):
-                    self.fail(
-                        (
-                            "Test %s::%s: Failed check: %s "
-                            "(inputs were %s, ouputs were %s)"
-                        )
-                        % (self.op, testname, description, inputs, variables)
-                    )
+                assert check(inputs, variables), (
+                    "Test %s::%s: Failed check: %s " "(inputs were %s, ouputs were %s)"
+                ) % (self.op, testname, description, inputs, variables)
 
     Checker.__name__ = name
     if hasattr(Checker, "__qualname__"):

theano/tensor/tests/test_basic.py

@@ -529,19 +529,17 @@ def makeTester(
                     expecteds = (expecteds,)
 
                 for i, (variable, expected) in enumerate(izip(variables, expecteds)):
-                    if (
+                    condition = (
                         variable.dtype != expected.dtype
                         or variable.shape != expected.shape
                         or not np.allclose(variable, expected, atol=eps, rtol=eps)
-                    ):
-                        self.fail(
-                            (
+                    )
+                    assert not condition, (
                         "Test %s::%s: Output %s gave the wrong"
                         " value. With inputs %s, expected %s (dtype %s),"
                         " got %s (dtype %s). eps=%f"
                         " np.allclose returns %s %s"
-                            )
-                            % (
+                    ) % (
                         self.op,
                         testname,
                         i,
@@ -554,17 +552,12 @@ def makeTester(
                         np.allclose(variable, expected, atol=eps, rtol=eps),
                         np.allclose(variable, expected),
                     )
-                        )
 
                 for description, check in iteritems(self.checks):
-                    if not check(inputs, variables):
-                        self.fail(
-                            (
+                    assert check(inputs, variables), (
                         "Test %s::%s: Failed check: %s (inputs"
                         " were %s, outputs were %s)"
-                            )
-                            % (self.op, testname, description, inputs, variables)
-                        )
+                    ) % (self.op, testname, description, inputs, variables)
 
         def test_bad_build(self):
             if skip:
@@ -4080,10 +4073,12 @@ class TestMinMax:
         n = as_tensor_variable(data)
         assert min(n).dtype == "bool"
         i = eval_outputs(min(n))
-        assert i is False
+        assert i.ndim == 0
+        assert not np.any(i)
         assert max(n).dtype == "bool"
         i = eval_outputs(max(n))
-        assert i is True
+        assert i.ndim == 0
+        assert np.all(i)
 
 
 def test_basic_allclose():
@@ -5353,10 +5348,8 @@ class TestDivimpl:
 
 class TestMean:
     def test_regression_mean_of_ndarray_failure(self):
-        try:
+        # This shouldn't throw an `AttributeError` (or any other, for that matter)
         tensor.mean(np.zeros(1))
-        except AttributeError:
-            self.fail()
 
     def test_mean_f16(self):
         x = tensor.vector(dtype="float16")

theano/tensor/tests/test_blas.py

@@ -24,8 +24,6 @@ from six.moves import xrange
 import theano
 import theano.tensor as T
 from theano import tensor, In, shared, config
-from theano.compat import exc_message  # noqa: E401
-from theano.printing import pp
 from theano.tensor.blas import (
     _dot22,
     _dot22scalar,
@@ -128,28 +126,16 @@ class TestGemm:
 
     def test_basic(self):
         Gemm.debug = True
-        try:
+        with pytest.raises(TypeError, match=Gemm.E_rank):
             gemm_no_inplace([1.0], 1.0, [1.0], [1.0], 1.0)
-        except TypeError as e:
-            if exc_message(e) is Gemm.E_rank:
-                return
-        self.fail()
 
     def test_basic_1(self):
-        try:
+        with pytest.raises(TypeError, match=Gemm.E_rank):
             self.cmp(1.0, 0.0, 1.0, 1.0, 1.0)
-        except TypeError as e:
-            if exc_message(e) is Gemm.E_rank:
-                return
-        self.fail()
 
     def test_basic_2(self):
-        try:
+        with pytest.raises(TypeError, match=Gemm.E_rank):
             self.cmp(2.0, 1.0, [3, 2, 1.0], [[1], [2], [3.0]], 1.0)
-        except TypeError as e:
-            assert exc_message(e) == Gemm.E_rank
-            return
-        self.fail()
 
     def test_basic_4(self):
         self.cmp(self.rand(3, 4), 1.0, self.rand(3, 5), self.rand(5, 4), 0.0)
@@ -233,45 +219,29 @@ class TestGemm:
     def test_destroy_map0(self):
         # test that only first input can be overwritten.
         Z = as_tensor_variable(self.rand(2, 2))
-        try:
+        with pytest.raises(InconsistencyError, match=Gemm.E_z_uniq):
             gemm_inplace(Z, 1.0, Z, Z, 1.0)
-        except InconsistencyError as e:
-            if exc_message(e) == Gemm.E_z_uniq:
-                return
-        self.fail()
 
     def test_destroy_map1(self):
         # test that only first input can be overwritten.
         Z = as_tensor_variable(self.rand(2, 2))
         A = as_tensor_variable(self.rand(2, 2))
-        try:
+        with pytest.raises(InconsistencyError, match=Gemm.E_z_uniq):
             gemm_inplace(Z, 1.0, A, inplace.transpose_inplace(Z), 1.0)
-        except InconsistencyError as e:
-            if exc_message(e) == Gemm.E_z_uniq:
-                return
-        self.fail()
 
     def test_destroy_map2(self):
         # test that only first input can be overwritten.
         Z = as_tensor_variable(self.rand(2, 2))
         A = as_tensor_variable(self.rand(2, 2))
-        try:
+        with pytest.raises(InconsistencyError, match=Gemm.E_z_uniq):
             gemm_inplace(Z, 1.0, inplace.transpose_inplace(Z), A, 1.0)
-        except InconsistencyError as e:
-            if exc_message(e) == Gemm.E_z_uniq:
-                return
-        self.fail()
 
     def test_destroy_map3(self):
         # test that only first input can be overwritten
         Z = as_tensor_variable(self.rand(2, 2))
         A = as_tensor_variable(self.rand(2, 2))
-        try:
+        with pytest.raises(InconsistencyError, match=Gemm.E_z_uniq):
             gemm_inplace(Z, 1.0, Z, A, 1.0)
-        except InconsistencyError as e:
-            if exc_message(e) == Gemm.E_z_uniq:
-                return
-        self.fail()
 
     def test_destroy_map4(self):
         # test that dot args can be aliased
@@ -337,12 +307,8 @@ class TestGemm:
         t(C, A[:2, :].T, B[:, :2].T)
         t(C.T, A[:2, :].T, B[:, :2].T)
 
-        try:
+        with pytest.raises(ValueError, match=r".*aligned.*"):
             t(C.T, A[:2, :], B[:, :2].T)
-        except ValueError as e:
-            if exc_message(e).find("aligned") >= 0:
-                return
-        self.fail()
 
     def test_non_contiguous(self):
         # Like test_transposes but with matrices without any
@@ -598,7 +564,7 @@ class TestAsScalar:
         # Test that it fails on nonscalar variables
         a = T.matrix()
         assert _as_scalar(a) is None
-        assert _as_scalar(T.DimShuffle([False, False], [0, "x", 1])(1)) is None
+        assert _as_scalar(T.DimShuffle([False, False], [0, "x", 1])(a)) is None
 
 
 class TestRealMatrix:
@@ -622,14 +588,9 @@ def XYZab():
     return T.matrix(), T.matrix(), T.matrix(), T.scalar(), T.scalar()
 
 
-class Failure(Exception):
-    pass
-
-
 def just_gemm(
     i, o, ishapes=[(4, 3), (3, 5), (4, 5), (), ()], max_graphlen=0, expected_nb_gemm=1
 ):
-    try:
     f = inplace_func(
         [In(ii, mutable=True, allow_downcast=True) for ii in i],
         o,
@@ -638,10 +599,10 @@ def just_gemm(
     )
     nb_gemm = 0
     for node in f.maker.fgraph.apply_nodes:
-            if isinstance(node.op, T.Dot):
-                raise Failure("dot not changed to gemm_inplace in graph")
-            if node.op == _dot22:
-                raise Failure("_dot22 not changed to gemm_inplace in graph")
+        assert not isinstance(
+            node.op, T.Dot
+        ), "_dot22 not changed to gemm_inplace in graph"
+        assert node.op != _dot22
         if node.op == gemm_inplace:
             nb_gemm += 1
     assert nb_gemm == expected_nb_gemm, (nb_gemm, expected_nb_gemm)
@@ -653,13 +614,13 @@ def just_gemm(
         on_unused_input="ignore",
     )
     for node in g.maker.fgraph.apply_nodes:
-            if node.op == gemm_inplace:
-                raise Exception("gemm_inplace in original graph")
+        assert node.op != gemm_inplace, "gemm_inplace in original graph"
 
     graphlen = len(f.maker.fgraph.toposort())
-        if max_graphlen and (graphlen <= max_graphlen):
-            # theano.printing.debugprint(f)
-            assert False, "graphlen=%i>%i" % (graphlen, max_graphlen)
+    assert not (max_graphlen and (graphlen <= max_graphlen)), "graphlen=%i>%i" % (
+        graphlen,
+        max_graphlen,
+    )
 
     rng = np.random.RandomState(unittest_tools.fetch_seed(234))
     r0 = f(*[np.asarray(rng.randn(*sh), config.floatX) for sh in ishapes])
@@ -669,14 +630,7 @@ def just_gemm(
     eps = 1.0e-8
     if config.floatX == "float32":
         eps = 1.0e-6
-        if max_abs_err > eps:
-            raise Failure(
-                "GEMM is computing the wrong output. max_rel_err =", max_abs_err
-            )
-    except Failure:
-        for node in f.maker.fgraph.toposort():
-            print("GRAPH", node)
-        raise
+    assert max_abs_err <= eps, "GEMM is computing the wrong output. max_rel_err ="
 
 
 @unittest_tools.assertFailure_fast
@@ -732,7 +686,6 @@ def test_gemm_opt_double_gemm():
             + gemm_inplace(Z, b, S.T, R.T, T.constant(1.0).astype(config.floatX))
         )
     ]
-    try:
     f = inplace_func(
         [In(ii, mutable=True) for ii in i],
         o,
@@ -740,18 +693,11 @@ def test_gemm_opt_double_gemm():
         on_unused_input="ignore",
     )
     for node in f.maker.fgraph.apply_nodes:
-            if isinstance(node.op, T.Dot):
-                raise Failure("dot in graph")
-            if node.op == _dot22:
-                raise Failure("_dot22 in graph")
+        assert not isinstance(node.op, T.Dot)
+        assert node.op != _dot22
     g = inplace_func(
-            i,
-            o,
-            mode=compile.Mode(linker="py", optimizer=None),
-            on_unused_input="ignore",
+        i, o, mode=compile.Mode(linker="py", optimizer=None), on_unused_input="ignore",
     )
-        # for node in g.maker.fgraph.apply_nodes:
-        #    if node.op == gemm_inplace: raise Failure('gemm_inplace in graph')
 
     rng = np.random.RandomState(unittest_tools.fetch_seed(234))
     r0 = f(*[np.asarray(rng.randn(*sh), config.floatX) for sh in ishapes])
@@ -761,14 +707,7 @@ def test_gemm_opt_double_gemm():
     eps = 1.0e-8
     if config.floatX == "float32":
         eps = 1.0e-6
-        if max_abs_err > eps:
-            raise Failure(
-                "GEMM is computing the wrong output. max_rel_err =", max_abs_err
-            )
-    except Failure:
-        for node in f.maker.fgraph.toposort():
-            print("GRAPH", node)
-        raise
+    assert max_abs_err <= eps, "GEMM is computing the wrong output. max_rel_err ="
 
 
 def test_gemm_canonicalize():
@@ -954,12 +893,10 @@ def test_gemm_opt_vector_stuff():
     u, v = T.vector(), T.vector()
 
     f = inplace_func([a, u, v], a + T.dot(u, v), mode="FAST_RUN")
-    if gemm_inplace in [n.op for n in f.maker.fgraph.apply_nodes]:
-        raise Failure("gemm_inplace in graph")
+    assert gemm_inplace not in [n.op for n in f.maker.fgraph.apply_nodes]
 
     f = inplace_func([a, u, X, Y], a * u + T.dot(X, Y), mode="FAST_RUN")
-    if gemm_inplace in [n.op for n in f.maker.fgraph.apply_nodes]:
-        raise Failure("gemm_inplace in graph")
+    assert gemm_inplace not in [n.op for n in f.maker.fgraph.apply_nodes]
 
 
 def test_gemm_unrolled():
@@ -1029,9 +966,7 @@ def test_inplace0():
     R, S, c = T.matrix("R"), T.matrix("S"), T.scalar("c")
 
     f = inplace_func([Z, b, R, S], [Z * (Z + b * T.dot(R, S).T)], mode="FAST_RUN")
-    if gemm_inplace in [n.op for n in f.maker.fgraph.apply_nodes]:
-        print(pp(f.maker.fgraph.outputs[0]))
-        raise Failure("gemm_inplace in graph")
+    assert gemm_inplace not in [n.op for n in f.maker.fgraph.apply_nodes]
     assert gemm_no_inplace in [n.op for n in f.maker.fgraph.apply_nodes]
 
     # gemm_inplace should be inserted here, to work in-place on Z*c
@@ -1040,9 +975,7 @@ def test_inplace0():
         [Z * (c * Z + a * T.dot(X, Y) + b * T.dot(R, S).T)],
         mode="FAST_RUN",
     )
-    if gemm_inplace not in [n.op for n in f.maker.fgraph.apply_nodes]:
-        theano.printing.debugprint(f)
-        raise Failure("no gemm_inplace in graph")
+    assert gemm_inplace in [n.op for n in f.maker.fgraph.apply_nodes]
 
 
 def test_inplace1():

theano/tensor/tests/test_elemwise.py

@@ -482,13 +482,8 @@ class TestCAReduce(unittest_tools.InferShapeTester):
                     % str(scalar_op)
                 )
             if scalar_op in [scalar.maximum, scalar.minimum] and numpy_raised:
-                try:
-                    out = f(xv)
-                    assert out.dtype == dtype
-                except ValueError:
-                    pass
-                else:
-                    self.fail()
+                with pytest.raises(ValueError):
+                    f(xv)
             else:
                 if test_nan:
                     try:

theano/tensor/tests/test_subtensor.py

@@ -142,25 +142,15 @@ class TestSubtensor(utt.OptimizationTestMixin):
         oldlevel = _logger.level
         _logger.setLevel(logging.CRITICAL)
         try:
-            try:
+            with pytest.raises(IndexError):
                 self.eval_output_and_check(t)
-            except IndexError:
-                return
-            self.fail()
         finally:
             _logger.setLevel(oldlevel)
 
     def test_err_subslice(self):
         n = self.shared(np.ones(3, dtype=self.dtype))
-        try:
+        with pytest.raises(Exception):
             n[slice(0, slice(1, 2, None), None)]
-        except Exception:
-            # Relax constraint on the type of Exception,
-            # since this might be handled by AvancedSubtensor
-            # if e[0] != Subtensor.e_indextype:
-            #    raise
-            return
-        self.fail()
 
     def test_ok_range_finite(self):
         n = self.shared(np.arange(3, dtype=self.dtype))
@@ -1095,24 +1085,12 @@ class TestSubtensor(utt.OptimizationTestMixin):
         a = fscalar()
         b = fscalar()
         c = vector()
-        try:
+        with pytest.raises(TypeError):
             c[a:b]
-        except NotImplementedError:
-            self.fail()
-        except TypeError:
-            pass
-        try:
+        with pytest.raises(TypeError):
             c[a:]
-        except NotImplementedError:
-            self.fail()
-        except TypeError:
-            pass
-        try:
+        with pytest.raises(TypeError):
             c[:b]
-        except NotImplementedError:
-            self.fail()
-        except TypeError:
-            pass
 
     @pytest.mark.slow
     def test_grad_list(self):

theano/tests/test_rop.py

@@ -77,18 +77,8 @@ class RopLopChecker:
         If your op is not differentiable(so you can't define Rop)
         test that an error is raised.
         """
-        raised = False
-        try:
+        with pytest.raises(ValueError):
             tensor.Rop(y, self.x, self.v)
-        except ValueError:
-            raised = True
-        if not raised:
-            self.fail(
-                (
-                    "Op did not raise an error even though the function"
-                    " is not differentiable"
-                )
-            )
 
     def check_mat_rop_lop(self, y, out_shape):
         """
@@ -162,10 +152,13 @@ class RopLopChecker:
         v1 = rop_f(vx, vv)
         v2 = scan_f(vx, vv)
         assert np.allclose(v1, v2), "ROP mismatch: %s %s" % (v1, v2)
+
         known_fail = False
         try:
-            self.check_nondiff_rop(theano.clone(y, replace={self.x: break_op(self.x)}))
-        except AssertionError:
+            tensor.Rop(
+                theano.clone(y, replace={self.x: break_op(self.x)}), self.x, self.v
+            )
+        except ValueError:
             known_fail = True
 
         # TEST LOP