diff --git a/unittests/test_argparser.py b/unittests/test_argparser.py
index f20feea5c6..2de1e83ccc 100644
--- a/unittests/test_argparser.py
+++ b/unittests/test_argparser.py
@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
 
 from reframe.frontend.argparse import ArgumentParser
@@ -27,36 +28,37 @@ def setUp(self):
         self.foo_options.add_argument('--barfoo', action='store_true')
 
     def test_arguments(self):
-        self.assertRaises(ValueError, self.foo_options.add_argument,
-                          action='store', default='FOO')
+        with pytest.raises(ValueError):
+            self.foo_options.add_argument(action='store', default='FOO')
+
         self.foo_options.add_argument('--foo-bar', action='store_true')
         self.foo_options.add_argument('--alist', action='append', default=[])
         options = self.parser.parse_args(['--foobar', '--foo-bar'])
-        self.assertTrue(options.foobar)
-        self.assertTrue(options.foo_bar)
+        assert options.foobar
+        assert options.foo_bar
 
     def test_parsing(self):
         options = self.parser.parse_args(
             '--foo name --foolist gag --barfoo --unfoo'.split()
         )
-        self.assertEqual('name', options.foo)
-        self.assertEqual(['gag'], options.foolist)
-        self.assertTrue(options.barfoo)
-        self.assertFalse(options.unfoo)
+        assert 'name' == options.foo
+        assert ['gag'] == options.foolist
+        assert options.barfoo
+        assert not options.unfoo
 
         # Check the defaults now
-        self.assertFalse(options.foobar)
-        self.assertEqual('BAR', options.bar)
-        self.assertEqual([], options.barlist)
+        assert not options.foobar
+        assert 'BAR' == options.bar
+        assert [] == options.barlist
 
         # Reparse based on the already loaded options
         options = self.parser.parse_args(
             '--bar beer --foolist any'.split(), options
         )
-        self.assertEqual('name', options.foo)
-        self.assertEqual(['any'], options.foolist)
-        self.assertFalse(options.foobar)
-        self.assertFalse(options.unfoo)
-        self.assertEqual('beer', options.bar)
-        self.assertEqual([], options.barlist)
-        self.assertTrue(options.barfoo)
+        assert 'name' == options.foo
+        assert ['any'] == options.foolist
+        assert not options.foobar
+        assert not options.unfoo
+        assert 'beer' == options.bar
+        assert [] == options.barlist
+        assert options.barfoo
diff --git a/unittests/test_buildsystems.py b/unittests/test_buildsystems.py
index 9ad23cdc25..d6f7a91caf 100644
--- a/unittests/test_buildsystems.py
+++ b/unittests/test_buildsystems.py
@@ -55,8 +55,7 @@ def test_emit_from_env(self):
             'CFLAGS="-Wall -std=c99" CXXFLAGS="-Wall -std=c++11" '
             'FCFLAGS="-Wall" LDFLAGS="-dynamic" FOO=1'
         ]
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_from_buildsystem(self):
         super().setup_base_buildsystem()
@@ -70,13 +69,12 @@ def test_emit_from_buildsystem(self):
             'CXXFLAGS="-Wall -std=c++11 -O3" FCFLAGS="-Wall -O3" '
             'LDFLAGS="-static" FOO=1'
         ]
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_no_env_defaults(self):
         self.build_system.flags_from_environ = False
-        self.assertEqual(['make -j 1'],
-                         self.build_system.emit_build_commands(self.environ))
+        assert (['make -j 1'] ==
+                self.build_system.emit_build_commands(self.environ))
 
 
 class TestCMake(_BuildSystemTest, unittest.TestCase):
@@ -103,8 +101,7 @@ def test_emit_from_env(self):
             'make -j 32 install'
 
         ]
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_from_buildsystem(self):
         super().setup_base_buildsystem()
@@ -124,13 +121,12 @@ def test_emit_from_buildsystem(self):
 
         ]
         print(self.build_system.emit_build_commands(self.environ))
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_no_env_defaults(self):
         self.build_system.flags_from_environ = False
-        self.assertEqual(['cmake .', 'make -j 1'],
-                         self.build_system.emit_build_commands(self.environ))
+        assert (['cmake .', 'make -j 1'] ==
+                self.build_system.emit_build_commands(self.environ))
 
 
 class TestAutotools(_BuildSystemTest, unittest.TestCase):
@@ -154,8 +150,7 @@ def test_emit_from_env(self):
             'make -j 32 check'
 
         ]
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_from_buildsystem(self):
         super().setup_base_buildsystem()
@@ -173,13 +168,12 @@ def test_emit_from_buildsystem(self):
 
         ]
         print(self.build_system.emit_build_commands(self.environ))
-        self.assertEqual(expected,
-                         self.build_system.emit_build_commands(self.environ))
+        assert expected == self.build_system.emit_build_commands(self.environ)
 
     def test_emit_no_env_defaults(self):
         self.build_system.flags_from_environ = False
-        self.assertEqual(['./configure', 'make -j 1'],
-                         self.build_system.emit_build_commands(self.environ))
+        assert (['./configure', 'make -j 1'] ==
+                self.build_system.emit_build_commands(self.environ))
 
 
 class TestSingleSource(_BuildSystemTest, unittest.TestCase):
@@ -224,8 +218,8 @@ def test_emit_from_env(self):
                 '-o foo.e %s' % (comp, flags,
                                  self.build_system.srcfile, ldflags)
             ]
-            self.assertEqual(expected,
-                             self.build_system.emit_build_commands(self.environ))
+            assert (expected ==
+                    self.build_system.emit_build_commands(self.environ))
 
     def test_emit_no_env(self):
         super().setup_base_buildsystem()
@@ -256,5 +250,5 @@ def test_emit_no_env(self):
                 '-o foo.e %s' % (comp, flags,
                                  self.build_system.srcfile, ldflags)
             ]
-            self.assertEqual(expected,
-                             self.build_system.emit_build_commands(self.environ))
+            assert (expected ==
+                    self.build_system.emit_build_commands(self.environ))
diff --git a/unittests/test_check_filters.py b/unittests/test_check_filters.py
index 6a19eacb31..de3c59e4d8 100644
--- a/unittests/test_check_filters.py
+++ b/unittests/test_check_filters.py
@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
 
 import reframe.core.runtime as rt
@@ -47,67 +48,56 @@ def count_checks(self, filter_fn):
         return sn.count(filter(filter_fn, self.checks))
 
     def test_have_name(self):
-        self.assertEqual(1, self.count_checks(filters.have_name('check1')))
-        self.assertEqual(3, self.count_checks(filters.have_name('check')))
-        self.assertEqual(2, self.count_checks(filters.have_name(r'\S*1|\S*3')))
-        self.assertEqual(0, self.count_checks(filters.have_name('Check')))
-        self.assertEqual(3, self.count_checks(filters.have_name('(?i)Check')))
-        self.assertEqual(
-            2, self.count_checks(filters.have_name('(?i)check1|CHECK2'))
-        )
+        assert 1 == self.count_checks(filters.have_name('check1'))
+        assert 3 == self.count_checks(filters.have_name('check'))
+        assert 2 == self.count_checks(filters.have_name(r'\S*1|\S*3'))
+        assert 0 == self.count_checks(filters.have_name('Check'))
+        assert 3 == self.count_checks(filters.have_name('(?i)Check'))
+        assert 2 == self.count_checks(filters.have_name('(?i)check1|CHECK2'))
 
     def test_have_not_name(self):
-        self.assertEqual(2, self.count_checks(filters.have_not_name('check1')))
-        self.assertEqual(
-            1, self.count_checks(filters.have_not_name('check1|check3'))
-        )
-        self.assertEqual(
-            0, self.count_checks(filters.have_not_name('check1|check2|check3'))
-        )
-        self.assertEqual(3, self.count_checks(filters.have_not_name('Check1')))
-        self.assertEqual(
-            2, self.count_checks(filters.have_not_name('(?i)Check1'))
-        )
+        assert 2 == self.count_checks(filters.have_not_name('check1'))
+        assert 1 == self.count_checks(filters.have_not_name('check1|check3'))
+        assert 0 == self.count_checks(filters.have_not_name(
+            'check1|check2|check3'))
+        assert 3 == self.count_checks(filters.have_not_name('Check1'))
+        assert 2 == self.count_checks(filters.have_not_name('(?i)Check1'))
 
     def test_have_tags(self):
-        self.assertEqual(2, self.count_checks(filters.have_tag('a|c')))
-        self.assertEqual(0, self.count_checks(filters.have_tag('p|q')))
-        self.assertEqual(2, self.count_checks(filters.have_tag('z')))
+        assert 2 == self.count_checks(filters.have_tag('a|c'))
+        assert 0 == self.count_checks(filters.have_tag('p|q'))
+        assert 2 == self.count_checks(filters.have_tag('z'))
 
     def test_have_prgenv(self):
-        self.assertEqual(
-            1, self.count_checks(filters.have_prgenv('env1|env2'))
-        )
-        self.assertEqual(2, self.count_checks(filters.have_prgenv('env3')))
-        self.assertEqual(1, self.count_checks(filters.have_prgenv('env4')))
-        self.assertEqual(
-            3, self.count_checks(filters.have_prgenv('env1|env3'))
-        )
+        assert 1 == self.count_checks(filters.have_prgenv('env1|env2'))
+        assert 2 == self.count_checks(filters.have_prgenv('env3'))
+        assert 1 == self.count_checks(filters.have_prgenv('env4'))
+        assert 3 == self.count_checks(filters.have_prgenv('env1|env3'))
 
     @rt.switch_runtime(fixtures.TEST_SITE_CONFIG, 'testsys')
     def test_partition(self):
         p = rt.runtime().system.partition('gpu')
-        self.assertEqual(2, self.count_checks(filters.have_partition([p])))
+        assert 2 == self.count_checks(filters.have_partition([p]))
         p = rt.runtime().system.partition('login')
-        self.assertEqual(0, self.count_checks(filters.have_partition([p])))
+        assert 0 == self.count_checks(filters.have_partition([p]))
 
     def test_have_gpu_only(self):
-        self.assertEqual(2, self.count_checks(filters.have_gpu_only()))
+        assert 2 == self.count_checks(filters.have_gpu_only())
 
     def test_have_cpu_only(self):
-        self.assertEqual(1, self.count_checks(filters.have_cpu_only()))
+        assert 1 == self.count_checks(filters.have_cpu_only())
 
     def test_invalid_regex(self):
         # We need to explicitly call `evaluate` to make sure the exception
         # is triggered in all cases
-        with self.assertRaises(ReframeError):
+        with pytest.raises(ReframeError):
             self.count_checks(filters.have_name('*foo')).evaluate()
 
-        with self.assertRaises(ReframeError):
+        with pytest.raises(ReframeError):
             self.count_checks(filters.have_not_name('*foo')).evaluate()
 
-        with self.assertRaises(ReframeError):
+        with pytest.raises(ReframeError):
             self.count_checks(filters.have_tag('*foo')).evaluate()
 
-        with self.assertRaises(ReframeError):
+        with pytest.raises(ReframeError):
             self.count_checks(filters.have_prgenv('*foo')).evaluate()
diff --git a/unittests/test_cli.py b/unittests/test_cli.py
index 335ca800e7..75091823c4 100644
--- a/unittests/test_cli.py
+++ b/unittests/test_cli.py
@@ -124,23 +124,23 @@ def _perflog_exists(self, check_name):
 
     def assert_log_file_is_saved(self):
         outputdir = os.path.join(self.prefix, 'output')
-        self.assertTrue(os.path.exists(self.logfile))
-        self.assertTrue(os.path.exists(
-            os.path.join(outputdir, os.path.basename(self.logfile))))
+        assert os.path.exists(self.logfile)
+        assert os.path.exists(
+            os.path.join(outputdir, os.path.basename(self.logfile)))
 
     def test_default_settings(self):
         # Simply make sure that a default settings file exists
         try:
             import reframe.settings as settings
         except ImportError:
-            self.fail('default settings file find could not be found')
+            pytest.fail('default settings file could not be found')
 
     def test_check_success(self):
         self.more_options = ['--save-log-files']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('PASSED', stdout)
-        self.assertNotIn('FAILED', stdout)
-        self.assertEqual(0, returncode)
+        assert 'PASSED' in stdout
+        assert 'FAILED' not in stdout
+        assert 0 == returncode
         self.assert_log_file_is_saved()
 
     @fixtures.switch_to_user_runtime
@@ -148,7 +148,7 @@ def test_check_submit_success(self):
         # This test will run on the auto-detected system
         partition = fixtures.partition_with_scheduler()
         if not partition:
-            self.skipTest('job submission not supported')
+            pytest.skip('job submission not supported')
 
         self.config_file = fixtures.USER_CONFIG_FILE
         self.local = False
@@ -159,20 +159,20 @@ def test_check_submit_success(self):
         self.environs = ['^' + partition.environs[0].name + '$']
 
         returncode, stdout, _ = self._run_reframe()
-        self.assertNotIn('FAILED', stdout)
-        self.assertIn('PASSED', stdout)
+        assert 'FAILED' not in stdout
+        assert 'PASSED' in stdout
 
         # Assert that we have run only one test case
-        self.assertIn('Ran 1 test case(s)', stdout)
-        self.assertEqual(0, returncode)
+        assert 'Ran 1 test case(s)' in stdout
+        assert 0 == returncode
 
     def test_check_failure(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.more_options = ['-t', 'BadSetupCheck']
 
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('FAILED', stdout)
-        self.assertNotEqual(returncode, 0)
+        assert 'FAILED' in stdout
+        assert returncode != 0
 
     def test_check_setup_failure(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
@@ -180,10 +180,10 @@ def test_check_setup_failure(self):
         self.local = False
 
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertIn('FAILED', stdout)
-        self.assertNotEqual(returncode, 0)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 'FAILED' in stdout
+        assert returncode != 0
 
     def test_check_kbd_interrupt(self):
         self.checkpath = [
@@ -193,39 +193,39 @@ def test_check_kbd_interrupt(self):
         self.local = False
 
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertIn('FAILED', stdout)
-        self.assertNotEqual(returncode, 0)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 'FAILED' in stdout
+        assert returncode != 0
 
     def test_check_sanity_failure(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.more_options = ['-t', 'SanityFailureCheck']
 
         returncode, stdout, stderr = self._run_reframe()
-        self.assertIn('FAILED', stdout)
+        assert 'FAILED' in stdout
 
         # This is a normal failure, it should not raise any exception
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertNotEqual(returncode, 0)
-        self.assertTrue(self._stage_exists('SanityFailureCheck',
-                                           ['login'], self.environs))
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert returncode != 0
+        assert self._stage_exists('SanityFailureCheck', ['login'],
+                                  self.environs)
 
     def test_performance_check_failure(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.more_options = ['-t', 'PerformanceFailureCheck']
         returncode, stdout, stderr = self._run_reframe()
 
-        self.assertIn('FAILED', stdout)
+        assert 'FAILED' in stdout
 
         # This is a normal failure, it should not raise any exception
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertNotEqual(0, returncode)
-        self.assertTrue(self._stage_exists('PerformanceFailureCheck',
-                                           ['login'], self.environs))
-        self.assertTrue(self._perflog_exists('PerformanceFailureCheck'))
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 0 != returncode
+        assert self._stage_exists('PerformanceFailureCheck', ['login'],
+                                  self.environs)
+        assert self._perflog_exists('PerformanceFailureCheck')
 
     def test_performance_report(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
@@ -233,21 +233,21 @@ def test_performance_report(self):
                              '--performance-report']
         returncode, stdout, stderr = self._run_reframe()
 
-        self.assertIn(r'PERFORMANCE REPORT', stdout)
-        self.assertIn(r'perf: 10 Gflop/s', stdout)
+        assert r'PERFORMANCE REPORT' in stdout
+        assert r'perf: 10 Gflop/s' in stdout
 
     def test_skip_system_check_option(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.more_options = ['--skip-system-check', '-t', 'NoSystemCheck']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('PASSED', stdout)
+        assert 'PASSED' in stdout
 
     def test_skip_prgenv_check_option(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.more_options = ['--skip-prgenv-check', '-t', 'NoPrgEnvCheck']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('PASSED', stdout)
-        self.assertEqual(0, returncode)
+        assert 'PASSED' in stdout
+        assert 0 == returncode
 
     def test_sanity_of_checks(self):
         # This test will effectively load all the tests in the checks path and
@@ -258,7 +258,7 @@ def test_sanity_of_checks(self):
         self.checkpath = []
         returncode, *_ = self._run_reframe()
 
-        self.assertEqual(0, returncode)
+        assert 0 == returncode
         self.assert_log_file_is_saved()
 
     def test_unknown_system(self):
@@ -266,16 +266,16 @@ def test_unknown_system(self):
         self.system = 'foo'
         self.checkpath = []
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(1, returncode)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 1 == returncode
 
     def test_sanity_of_optconfig(self):
         # Test the sanity of the command line options configuration
         self.action = 'help'
         self.checkpath = []
         returncode, *_ = self._run_reframe()
-        self.assertEqual(0, returncode)
+        assert 0 == returncode
 
     def test_checkpath_colon_separated(self):
         self.action = 'list'
@@ -284,7 +284,7 @@ def test_checkpath_colon_separated(self):
         returncode, stdout, _ = self._run_reframe()
         num_checks = re.search(
             r'Found (\d+) check', stdout, re.MULTILINE).group(1)
-        self.assertEqual(num_checks, '2')
+        assert num_checks == '2'
 
     def test_checkpath_symlink(self):
         self.action = 'list'
@@ -303,7 +303,7 @@ def test_checkpath_symlink(self):
             num_checks_in_checkdir = re.search(
                 r'Found (\d+) check', stdout, re.MULTILINE).group(1)
 
-        self.assertEqual(num_checks_in_checkdir, num_checks_default)
+        assert num_checks_in_checkdir == num_checks_default
 
     def test_checkpath_recursion(self):
         self.action = 'list'
@@ -317,25 +317,25 @@ def test_checkpath_recursion(self):
         returncode, stdout, _ = self._run_reframe()
         num_checks_in_checkdir = re.search(
             r'Found (\d+) check', stdout, re.MULTILINE).group(1)
-        self.assertEqual(num_checks_in_checkdir, num_checks_default)
+        assert num_checks_in_checkdir == num_checks_default
 
         self.more_options = []
         returncode, stdout, stderr = self._run_reframe()
         num_checks_in_checkdir = re.search(
             r'Found (\d+) check', stdout, re.MULTILINE).group(1)
-        self.assertEqual('0', num_checks_in_checkdir)
+        assert '0' == num_checks_in_checkdir
 
     def test_same_output_stage_dir(self):
         output_dir = os.path.join(self.prefix, 'foo')
         self.more_options = ['-o', output_dir, '-s', output_dir]
         returncode, *_ = self._run_reframe()
-        self.assertEqual(1, returncode)
+        assert 1 == returncode
 
         # retry with --keep-stage-files
         self.more_options.append('--keep-stage-files')
         returncode, *_ = self._run_reframe()
-        self.assertEqual(0, returncode)
-        self.assertTrue(os.path.exists(output_dir))
+        assert 0 == returncode
+        assert os.path.exists(output_dir)
 
     def test_execution_modes(self):
         self.checkpath = []
@@ -344,11 +344,11 @@ def test_execution_modes(self):
         self.mode = 'unittest'
 
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertNotIn('FAILED', stdout)
-        self.assertIn('PASSED', stdout)
-        self.assertIn('Ran 1 test case', stdout)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 'FAILED' not in stdout
+        assert 'PASSED' in stdout
+        assert 'Ran 1 test case' in stdout
 
     def test_no_ignore_check_conflicts(self):
         self.checkpath = ['unittests/resources/checks']
@@ -356,7 +356,7 @@ def test_no_ignore_check_conflicts(self):
         self.ignore_check_conflicts = False
         self.action = 'list'
         returncode, *_ = self._run_reframe()
-        self.assertNotEqual(0, returncode)
+        assert 0 != returncode
 
     def test_timestamp_option(self):
         from datetime import datetime
@@ -368,8 +368,8 @@ def test_timestamp_option(self):
         self.more_options = ['--timestamp=xxx_%F']
         timefmt = datetime.now().strftime('xxx_%F')
         returncode, stdout, _ = self._run_reframe()
-        self.assertNotEqual(0, returncode)
-        self.assertIn(timefmt, stdout)
+        assert 0 != returncode
+        assert timefmt in stdout
 
     def test_list_empty_prgenvs_check_and_options(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
@@ -377,8 +377,8 @@ def test_list_empty_prgenvs_check_and_options(self):
         self.environs = []
         self.more_options = ['-n', 'NoPrgEnvCheck']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('Found 0 check(s)', stdout)
-        self.assertEqual(0, returncode)
+        assert 'Found 0 check(s)' in stdout
+        assert 0 == returncode
 
     def test_list_check_with_empty_prgenvs(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
@@ -386,8 +386,8 @@ def test_list_check_with_empty_prgenvs(self):
         self.environs = ['foo']
         self.more_options = ['-n', 'NoPrgEnvCheck']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('Found 0 check(s)', stdout)
-        self.assertEqual(0, returncode)
+        assert 'Found 0 check(s)' in stdout
+        assert 0 == returncode
 
     def test_list_empty_prgenvs_in_check_and_options(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
@@ -395,53 +395,53 @@ def test_list_empty_prgenvs_in_check_and_options(self):
         self.environs = []
         self.more_options = ['-n', 'NoPrgEnvCheck']
         returncode, stdout, _ = self._run_reframe()
-        self.assertIn('Found 0 check(s)', stdout)
-        self.assertEqual(0, returncode)
+        assert 'Found 0 check(s)' in stdout
+        assert 0 == returncode
 
     def test_list_with_details(self):
         self.checkpath = ['unittests/resources/checks/frontend_checks.py']
         self.action = 'list_detailed'
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(0, returncode)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 0 == returncode
 
     def test_show_config(self):
         # Just make sure that this option does not make the frontend crash
         self.more_options = ['--show-config']
         self.system = 'testsys'
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(0, returncode)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 0 == returncode
 
     def test_show_env_config(self):
         # Just make sure that this option does not make the frontend crash
         self.more_options = ['--show-config-env', 'PrgEnv-gnu']
         self.system = 'testsys'
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(0, returncode)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 0 == returncode
 
     def test_show_env_config_unknown_env(self):
         # Just make sure that this option does not make the frontend crash
         self.more_options = ['--show-config-env', 'foobar']
         self.system = 'testsys'
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(1, returncode)
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 1 == returncode
 
     def test_verbosity(self):
         self.more_options = ['-vvvvv']
         self.system = 'testsys'
         self.action = 'list'
         returncode, stdout, stderr = self._run_reframe()
-        self.assertNotEqual('', stdout)
-        self.assertNotIn('Traceback', stdout)
-        self.assertNotIn('Traceback', stderr)
-        self.assertEqual(0, returncode)
+        assert '' != stdout
+        assert 'Traceback' not in stdout
+        assert 'Traceback' not in stderr
+        assert 0 == returncode
 
     @fixtures.switch_to_user_runtime
     def test_unload_module(self):
diff --git a/unittests/test_color.py b/unittests/test_color.py
index 848a092605..46ab55288d 100644
--- a/unittests/test_color.py
+++ b/unittests/test_color.py
@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
 
 import reframe.utility.color as color
@@ -11,22 +12,25 @@
 class TestColors(unittest.TestCase):
     def test_color_rgb(self):
         c = color.ColorRGB(128, 0, 34)
-        self.assertEqual(128, c.r)
-        self.assertEqual(0, c.g)
-        self.assertEqual(34, c.b)
+        assert 128 == c.r
+        assert 0 == c.g
+        assert 34 == c.b
+        with pytest.raises(ValueError):
+            color.ColorRGB(-1, 0, 34)
 
-        self.assertRaises(ValueError, color.ColorRGB, -1, 0, 34)
-        self.assertRaises(ValueError, color.ColorRGB, 0, -1, 34)
-        self.assertRaises(ValueError, color.ColorRGB, 0, 28, -1)
+        with pytest.raises(ValueError):
+            color.ColorRGB(0, -1, 34)
+
+        with pytest.raises(ValueError):
+            color.ColorRGB(0, 28, -1)
 
     def test_colorize(self):
         s = color.colorize('hello', color.RED, palette='ANSI')
-        self.assertIn('\033', s)
-        self.assertIn('[3', s)
-        self.assertIn('1m', s)
-
-        with self.assertRaises(ValueError):
+        assert '\033' in s
+        assert '[3' in s
+        assert '1m' in s
+        with pytest.raises(ValueError):
             color.colorize('hello', color.RED, palette='FOO')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             color.colorize('hello', color.ColorRGB(128, 0, 34), palette='ANSI')
diff --git a/unittests/test_config.py b/unittests/test_config.py
index 0b753a77c5..8a86df044d 100644
--- a/unittests/test_config.py
+++ b/unittests/test_config.py
@@ -4,12 +4,12 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import copy
+import pytest
 import unittest
 
 import reframe.core.config as config
 import unittests.fixtures as fixtures
 from reframe.core.exceptions import ConfigError
-import pytest
 
 
 class TestSiteConfigurationFromDict(unittest.TestCase):
diff --git a/unittests/test_containers.py b/unittests/test_containers.py
index e82c68ca9c..7356031c0f 100644
--- a/unittests/test_containers.py
+++ b/unittests/test_containers.py
@@ -4,9 +4,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import abc
+import pytest
 import unittest
 
-import pytest
 import reframe.core.containers as containers
 from reframe.core.exceptions import ContainerError
 
diff --git a/unittests/test_deferrable.py b/unittests/test_deferrable.py
index 793ed86e66..2f6f8d511c 100644
--- a/unittests/test_deferrable.py
+++ b/unittests/test_deferrable.py
@@ -12,29 +12,29 @@ def test_defer(self):
         from reframe.core.deferrable import _DeferredExpression
 
         a = sn.defer(3)
-        self.assertIsInstance(a, _DeferredExpression)
+        assert isinstance(a, _DeferredExpression)
 
     def test_evaluate(self):
         a = sn.defer(3)
-        self.assertEqual(3, a.evaluate())
-        self.assertEqual(3, sn.evaluate(a))
-        self.assertEqual(3, sn.evaluate(3))
+        assert 3 == a.evaluate()
+        assert 3 == sn.evaluate(a)
+        assert 3 == sn.evaluate(3)
 
     def test_implicit_eval(self):
         # Call to bool() on a deferred expression triggers its immediate
         # evaluation.
         a = sn.defer(3)
-        self.assertEqual(3, a)
+        assert 3 == a
 
     def test_str(self):
-        self.assertEqual('[1, 2]', str(sn.defer([1, 2])))
+        assert '[1, 2]' == str(sn.defer([1, 2]))
 
     def test_iter(self):
         l = [1, 2, 3]
         dl = sn.defer(l)
         l.append(4)
         for i, e in enumerate(dl, start=1):
-            self.assertEqual(i, e)
+            assert i == e
 
 
 class TestKeywordArgs(unittest.TestCase):
@@ -44,7 +44,7 @@ def add(self, a, b):
 
     def test_kwargs_passing(self):
         expr = self.add(a=4, b=2) / 3
-        self.assertEqual(2, expr)
+        assert 2 == expr
 
 
 class TestDeferredRichComparison(unittest.TestCase):
@@ -59,37 +59,37 @@ def value(self):
     def test_eq(self):
         expr = self.value == 2
         self._value = 2
-        self.assertTrue(expr)
+        assert expr
 
     def test_ne(self):
         expr = self.value != 0
         self._value = 2
-        self.assertTrue(expr)
+        assert expr
 
     def test_lt(self):
         expr = self.value < 0
         self._value = -1
-        self.assertTrue(expr)
+        assert expr
 
     def test_le(self):
         expr = self.value <= 0
-        self.assertTrue(expr)
+        assert expr
 
         self._value = -1
-        self.assertTrue(expr)
+        assert expr
 
     def test_gt(self):
         expr = self.value > 1
         self._value = 2
-        self.assertTrue(expr)
+        assert expr
 
     def test_ge(self):
         expr = self.value >= 1
         self._value = 1
-        self.assertTrue(expr)
+        assert expr
 
         self._value = 2
-        self.assertTrue(expr)
+        assert expr
 
 
 class TestDeferredContainerOps(unittest.TestCase):
@@ -97,19 +97,19 @@ def test_list_getitem(self):
         l = [1, 2]
         expr = sn.defer(l)[1] == 3
         l[1] = 3
-        self.assertTrue(expr)
+        assert expr
 
     def test_list_contains(self):
         l = [1, 2]
-        self.assertIn(2, sn.defer(l))
+        assert 2 in sn.defer(l)
 
     def test_set_contains(self):
         s = {1, 2}
-        self.assertIn(2, sn.defer(s))
+        assert 2 in sn.defer(s)
 
     def test_dict_contains(self):
         d = {1: 'a', 2: 'b'}
-        self.assertIn(2, sn.defer(d))
+        assert 2 in sn.defer(d)
 
 
 class V:
@@ -177,175 +177,175 @@ def __repr__(self):
 class TestDeferredNumericOps(unittest.TestCase):
     def test_add(self):
         a = sn.defer(1)
-        self.assertEqual(4, a + 3)
-        self.assertEqual(4, 3 + a)
+        assert 4 == a + 3
+        assert 4 == 3 + a
 
     def test_sub(self):
         a = sn.defer(1)
-        self.assertEqual(-2, a - 3)
-        self.assertEqual(2, 3 - a)
+        assert -2 == a - 3
+        assert 2 == 3 - a
 
     def test_mul(self):
         a = sn.defer(1)
-        self.assertEqual(3, a * 3)
-        self.assertEqual(3, 3 * a)
+        assert 3 == a * 3
+        assert 3 == 3 * a
 
     def test_truediv(self):
         a = sn.defer(3)
-        self.assertEqual(1.5, a / 2)
-        self.assertEqual(2 / 3, 2 / a)
+        assert 1.5 == a / 2
+        assert 2 / 3 == 2 / a
 
     def test_floordiv(self):
         a = sn.defer(3)
-        self.assertEqual(1, a // 2)
-        self.assertEqual(0, 2 // a)
+        assert 1 == a // 2
+        assert 0 == 2 // a
 
     def test_mod(self):
         a = sn.defer(3)
-        self.assertEqual(1, a % 2)
-        self.assertEqual(2, 2 % a)
+        assert 1 == a % 2
+        assert 2 == 2 % a
 
     def test_divmod(self):
         a = sn.defer(3)
         q, r = divmod(a, 2)
-        self.assertEqual(1, q)
-        self.assertEqual(1, r)
+        assert 1 == q
+        assert 1 == r
 
         # Test rdivmod here
         q, r = divmod(2, a)
-        self.assertEqual(0, q)
-        self.assertEqual(2, r)
+        assert 0 == q
+        assert 2 == r
 
     def test_pow(self):
         a = sn.defer(3)
-        self.assertEqual(9, a**2)
-        self.assertEqual(8, 2**a)
+        assert 9 == a**2
+        assert 8 == 2**a
 
     def test_lshift(self):
         a = sn.defer(1)
-        self.assertEqual(4, a << 2)
-        self.assertEqual(2 << 1, 2 << a)
+        assert 4 == a << 2
+        assert 2 << 1 == 2 << a
 
     def test_rshift(self):
         a = sn.defer(8)
-        self.assertEqual(1, a >> 3)
-        self.assertEqual(3 >> 8, 3 >> a)
+        assert 1 == a >> 3
+        assert 3 >> 8 == 3 >> a
 
     def test_and(self):
         a = sn.defer(7)
-        self.assertEqual(2, a & 2)
-        self.assertEqual(2, 2 & a)
+        assert 2 == a & 2
+        assert 2 == 2 & a
 
     def test_xor(self):
         a = sn.defer(7)
-        self.assertEqual(0, a ^ 7)
-        self.assertEqual(0, 7 ^ a)
+        assert 0 == a ^ 7
+        assert 0 == 7 ^ a
 
     def test_or(self):
         a = sn.defer(2)
-        self.assertEqual(7, a | 5)
-        self.assertEqual(7, 5 | a)
+        assert 7 == a | 5
+        assert 7 == 5 | a
 
     def test_expr_chaining(self):
         a = sn.defer(2)
-        self.assertEqual(64, a**((a + 1) * a))
+        assert 64 == a**((a + 1) * a)
 
     def test_neg(self):
         a = sn.defer(3)
-        self.assertEqual(-3, -a)
+        assert -3 == -a
 
     def test_pos(self):
         a = sn.defer(3)
-        self.assertEqual(+3, +a)
+        assert +3 == +a
 
     def test_abs(self):
         a = sn.defer(-3)
-        self.assertEqual(3, abs(a))
+        assert 3 == abs(a)
 
     def test_invert(self):
         a = sn.defer(3)
-        self.assertEqual(~3, ~a)
+        assert ~3 == ~a
 
     def test_iadd(self):
         v = V(1)
         dv = sn.defer(v)
         dv += V(3)
         sn.evaluate(dv)
-        self.assertEqual(4, v._value)
+        assert 4 == v._value
 
     def test_isub(self):
         v = V(1)
         dv = sn.defer(v)
         dv -= V(3)
         sn.evaluate(dv)
-        self.assertEqual(-2, v._value)
+        assert -2 == v._value
 
     def test_imul(self):
         v = V(1)
         dv = sn.defer(v)
         dv *= V(3)
         sn.evaluate(dv)
-        self.assertEqual(3, v._value)
+        assert 3 == v._value
 
     def test_itruediv(self):
         v = V(3)
         dv = sn.defer(v)
         dv /= V(2)
         sn.evaluate(dv)
-        self.assertEqual(1.5, v._value)
+        assert 1.5 == v._value
 
     def test_ifloordiv(self):
         v = V(3)
         dv = sn.defer(v)
         dv //= V(2)
         sn.evaluate(dv)
-        self.assertEqual(1, v._value)
+        assert 1 == v._value
 
     def test_imod(self):
         v = V(3)
         dv = sn.defer(v)
         dv %= V(2)
         sn.evaluate(dv)
-        self.assertEqual(1, v._value)
+        assert 1 == v._value
 
     def test_ipow(self):
         v = V(3)
         dv = sn.defer(v)
         dv **= V(2)
         sn.evaluate(dv)
-        self.assertEqual(9, v._value)
+        assert 9 == v._value
 
     def test_ilshift(self):
         v = V(1)
         dv = sn.defer(v)
         dv <<= V(2)
         sn.evaluate(dv)
-        self.assertEqual(4, v._value)
+        assert 4 == v._value
 
     def test_irshift(self):
         v = V(8)
         dv = sn.defer(v)
         dv >>= V(3)
         sn.evaluate(dv)
-        self.assertEqual(1, v._value)
+        assert 1 == v._value
 
     def test_iand(self):
         v = V(7)
         dv = sn.defer(v)
         dv &= V(2)
         sn.evaluate(dv)
-        self.assertEqual(2, v._value)
+        assert 2 == v._value
 
     def test_ixor(self):
         v = V(7)
         dv = sn.defer(v)
         dv ^= V(7)
         sn.evaluate(dv)
-        self.assertEqual(0, v._value)
+        assert 0 == v._value
 
     def test_ior(self):
         v = V(2)
         dv = sn.defer(v)
         dv |= V(5)
         sn.evaluate(dv)
-        self.assertEqual(7, v._value)
+        assert 7 == v._value
diff --git a/unittests/test_environments.py b/unittests/test_environments.py
index d2a1f44123..bbfdb58963 100644
--- a/unittests/test_environments.py
+++ b/unittests/test_environments.py
@@ -25,7 +25,7 @@ def assertModulesNotLoaded(self, modules):
 
     def setup_modules_system(self):
         if not fixtures.has_sane_modules_system():
-            self.skipTest('no modules system configured')
+            pytest.skip('no modules system configured')
 
         self.modules_system = runtime().modules_system
         self.modules_system.searchpath_add(fixtures.TEST_MODULES)
diff --git a/unittests/test_exceptions.py b/unittests/test_exceptions.py
index 69dcc5c50f..a9849e5426 100644
--- a/unittests/test_exceptions.py
+++ b/unittests/test_exceptions.py
@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
 
 import reframe.core.exceptions as exc
@@ -15,11 +16,12 @@ def raise_exc(exc):
 class TestExceptions(unittest.TestCase):
     def assert_args(self, exc_type, *args):
         e = exc_type(*args)
-        self.assertEqual(args, e.args)
+        assert args == e.args
 
     def test_soft_error(self):
-        self.assertRaisesRegex(exc.ReframeError, r'random error', raise_exc,
-                               exc.ReframeError('random error'))
+        with pytest.raises(exc.ReframeError, match=r'random error'):
+            raise_exc(exc.ReframeError('random error'))
+
         self.assert_args(exc.ReframeError, 'error msg')
         self.assert_args(exc.ReframeError, 'error msg', 'another arg')
 
@@ -31,13 +33,13 @@ def test_reraise_soft_error(self):
                 # reraise as ReframeError
                 raise exc.ReframeError('soft error') from e
         except exc.ReframeError as e:
-            self.assertEqual('soft error: random value error', str(e))
+            assert 'soft error: random value error' == str(e)
 
     def test_fatal_error(self):
         try:
             raise exc.ReframeFatalError('fatal error')
         except Exception:
-            self.fail('fatal error should not derive from Exception')
+            pytest.fail('fatal error should not derive from Exception')
         except BaseException:
             pass
 
@@ -49,79 +51,85 @@ def test_reraise_fatal_error(self):
                 # reraise as ReframeError
                 raise exc.ReframeFatalError('fatal error') from e
         except exc.ReframeFatalError as e:
-            self.assertEqual('fatal error: random value error', str(e))
+            assert 'fatal error: random value error' == str(e)
 
     def test_spawned_process_error(self):
         exc_args = ('foo bar', 'partial output', 'error message', 1)
         e = exc.SpawnedProcessError(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' failed with exit code 1:\n"
-                               r"=== STDOUT ===\n"
-                               r'partial output\n'
-                               r"=== STDERR ===\n"
-                               r"error message",
-                               raise_exc, e)
-        self.assertEqual(exc_args, e.args)
+        with pytest.raises(
+            exc.ReframeError,
+            match=r"command 'foo bar' failed with exit code 1:\n"
+                  r"=== STDOUT ===\n"
+                  r'partial output\n'
+                  r"=== STDERR ===\n"
+                  r"error message"):
+            raise_exc(e)
+
+        assert exc_args == e.args
 
     def test_spawned_process_error_nostdout(self):
         exc_args = ('foo bar', '', 'error message', 1)
         e = exc.SpawnedProcessError(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' failed with exit code 1:\n"
-                               r"=== STDOUT ===\n"
-                               r"=== STDERR ===\n"
-                               r"error message",
-                               raise_exc, e)
+        with pytest.raises(
+            exc.ReframeError,
+            match=r"command 'foo bar' failed with exit code 1:\n"
+                  r"=== STDOUT ===\n"
+                  r"=== STDERR ===\n"
+                  r"error message"):
+            raise_exc(e)
 
     def test_spawned_process_error_nostderr(self):
         exc_args = ('foo bar', 'partial output', '', 1)
         e = exc.SpawnedProcessError(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' failed with exit code 1:\n"
-                               r"=== STDOUT ===\n"
-                               r'partial output\n'
-                               r"=== STDERR ===",
-                               raise_exc, e)
+        with pytest.raises(
+            exc.ReframeError,
+            match=r"command 'foo bar' failed with exit code 1:\n"
+                  r"=== STDOUT ===\n"
+                  r'partial output\n'
+                  r"=== STDERR ==="):
+            raise_exc(e)
 
     def test_spawned_process_timeout(self):
         exc_args = ('foo bar', 'partial output', 'partial error', 10)
         e = exc.SpawnedProcessTimeout(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' timed out after 10s:\n"
-                               r"=== STDOUT ===\n"
-                               r'partial output\n'
-                               r"=== STDERR ===\n"
-                               r"partial error",
-                               raise_exc, e)
-        self.assertEqual(exc_args, e.args)
+        with pytest.raises(exc.ReframeError,
+                           match=r"command 'foo bar' timed out after 10s:\n"
+                                 r"=== STDOUT ===\n"
+                                 r'partial output\n'
+                                 r"=== STDERR ===\n"
+                                 r"partial error"):
+            raise_exc(e)
+
+        assert exc_args == e.args
 
     def test_spawned_process_timeout_nostdout(self):
         exc_args = ('foo bar', '', 'partial error', 10)
         e = exc.SpawnedProcessTimeout(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' timed out after 10s:\n"
-                               r"=== STDOUT ===\n"
-                               r"=== STDERR ===\n"
-                               r"partial error",
-                               raise_exc, e)
+        with pytest.raises(exc.ReframeError,
+                           match=r"command 'foo bar' timed out after 10s:\n"
+                                 r"=== STDOUT ===\n"
+                                 r"=== STDERR ===\n"
+                                 r"partial error"):
+            raise_exc(e)
 
     def test_spawned_process_timeout_nostderr(self):
         exc_args = ('foo bar', 'partial output', '', 10)
         e = exc.SpawnedProcessTimeout(*exc_args)
-        self.assertRaisesRegex(exc.ReframeError,
-                               r"command 'foo bar' timed out after 10s:\n"
-                               r"=== STDOUT ===\n"
-                               r'partial output\n'
-                               r"=== STDERR ===",
-                               raise_exc, e)
+        with pytest.raises(exc.ReframeError,
+                           match=r"command 'foo bar' timed out after 10s:\n"
+                                 r"=== STDOUT ===\n"
+                                 r'partial output\n'
+                                 r"=== STDERR ==="):
+            raise_exc(e)
 
     def test_job_error(self):
         exc_args = ('some error',)
         e = exc.JobError(*exc_args, jobid=1234)
-        self.assertEqual(1234, e.jobid)
-        self.assertRaisesRegex(exc.JobError, r'\[jobid=1234\] some error',
-                               raise_exc, e)
-        self.assertEqual(exc_args, e.args)
+        assert 1234 == e.jobid
+        with pytest.raises(exc.JobError, match=r'\[jobid=1234\] some error'):
+            raise_exc(e)
+
+        assert exc_args == e.args
 
     def test_reraise_job_error(self):
         try:
@@ -130,8 +138,7 @@ def test_reraise_job_error(self):
             except ValueError as e:
                 raise exc.JobError('some error', jobid=1234) from e
         except exc.JobError as e:
-            self.assertEqual('[jobid=1234] some error: random value error',
-                             str(e))
+            assert '[jobid=1234] some error: random value error' == str(e)
 
     def test_reraise_job_error_no_message(self):
         try:
@@ -140,5 +147,4 @@ def test_reraise_job_error_no_message(self):
             except ValueError as e:
                 raise exc.JobError(jobid=1234) from e
         except exc.JobError as e:
-            self.assertEqual('[jobid=1234]: random value error',
-                             str(e))
+            assert '[jobid=1234]: random value error' == str(e)
diff --git a/unittests/test_fields.py b/unittests/test_fields.py
index 6a980e7fb2..8b4135aa3d 100644
--- a/unittests/test_fields.py
+++ b/unittests/test_fields.py
@@ -19,9 +19,11 @@ class FieldTester:
             var = fields.Field('var')
 
         c = FieldTester()
-        self.assertRaises(AttributeError, exec, "a = c.var",
-                          globals(), locals())
-        self.assertRaises(AttributeError, getattr, c, 'var')
+        with pytest.raises(AttributeError):
+            a = c.var
+
+        with pytest.raises(AttributeError):
+            getattr(c, 'var')
 
     def test_copy_on_write_field(self):
         class FieldTester:
@@ -34,22 +36,22 @@ class FieldTester:
         tester.cow = var
 
         # Verify that the lists are different
-        self.assertIsNot(var, tester.cow)
+        assert var is not tester.cow
 
         # Make sure we have a deep copy
         var[1].append(5)
-        self.assertEqual(tester.cow, [1, [2, 4], 3])
-        self.assertIsInstance(FieldTester.cow, fields.CopyOnWriteField)
+        assert tester.cow == [1, [2, 4], 3]
+        assert isinstance(FieldTester.cow, fields.CopyOnWriteField)
 
     def test_constant_field(self):
         class FieldTester:
             ro = fields.ConstantField('foo')
 
         tester = FieldTester()
-        self.assertEqual(FieldTester.ro, 'foo')
-        self.assertEqual(tester.ro, 'foo')
-        self.assertRaises(ValueError, exec, "tester.ro = 'bar'",
-                          globals(), locals())
+        assert FieldTester.ro == 'foo'
+        assert tester.ro == 'foo'
+        with pytest.raises(ValueError):
+            tester.ro = 'bar'
 
     def test_typed_field(self):
         class ClassA:
@@ -68,19 +70,20 @@ def __init__(self, value):
                 self.field = value
 
         tester = FieldTester(ClassA(3))
-        self.assertIsInstance(FieldTester.field, fields.TypedField)
-        self.assertEqual(3, tester.field.value)
-        self.assertRaises(TypeError, FieldTester, 3)
+        assert isinstance(FieldTester.field, fields.TypedField)
+        assert 3 == tester.field.value
+        with pytest.raises(TypeError):
+            FieldTester(3)
 
         tester.field = ClassB()
-        self.assertEqual(10, tester.field.value)
-        with self.assertRaises(TypeError):
+        assert 10 == tester.field.value
+        with pytest.raises(TypeError):
             tester.field = None
 
         tester.field_any = None
         tester.field_any = 'foo'
         tester.field_any = ClassA(5)
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             tester.field_any = 3
 
     def test_timer_field(self):
@@ -92,7 +95,6 @@ class FieldTester:
         tester = FieldTester()
         tester.field = '1d65h22m87s'
         tester.field_maybe_none = None
-
         assert isinstance(FieldTester.field, fields.TimerField)
         assert (datetime.timedelta(days=1, hours=65,
                                    minutes=22, seconds=87) == tester.field)
@@ -107,31 +109,31 @@ class FieldTester:
             tester.field = (65, 22, 87)
 
         with pytest.raises(ValueError):
-            exec('tester.field = "1e"', globals(), locals())
+            tester.field = '1e'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "-10m5s"', globals(), locals())
+            tester.field = '-10m5s'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10m-5s"', globals(), locals())
+            tester.field = '10m-5s'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "m10s"', globals(), locals())
+            tester.field = 'm10s'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10m10"', globals(), locals())
+            tester.field = '10m10'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10m10m1s"', globals(), locals())
+            tester.field = '10m10m1s'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10m5s3m"', globals(), locals())
+            tester.field = '10m5s3m'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10ms"', globals(), locals())
+            tester.field = '10ms'
 
         with pytest.raises(ValueError):
-            exec('tester.field = "10"', globals(), locals())
+            tester.field = '10'
 
     def test_proxy_field(self):
         class Target:
@@ -146,14 +148,14 @@ class Proxy:
             b = fields.ForwardField(t, 'b')
 
         proxy = Proxy()
-        self.assertIsInstance(Proxy.a, fields.ForwardField)
-        self.assertEqual(1, proxy.a)
-        self.assertEqual(2, proxy.b)
+        assert isinstance(Proxy.a, fields.ForwardField)
+        assert 1 == proxy.a
+        assert 2 == proxy.b
 
         proxy.a = 3
         proxy.b = 4
-        self.assertEqual(3, t.a)
-        self.assertEqual(4, t.b)
+        assert 3 == t.a
+        assert 4 == t.b
 
     def test_deprecated_field(self):
         class FieldTester:
@@ -176,27 +178,27 @@ def __init__(self):
         tester = FieldTester()
 
         # Test set operation
-        with self.assertWarns(ReframeDeprecationWarning):
+        with pytest.warns(ReframeDeprecationWarning):
             tester.value = 2
 
-        with self.assertWarns(ReframeDeprecationWarning):
+        with pytest.warns(ReframeDeprecationWarning):
             tester.ro = 1
 
         try:
             tester.wo = 20
         except ReframeDeprecationWarning:
-            self.fail('deprecation warning not expected here')
+            pytest.fail('deprecation warning not expected here')
 
         # Test get operation
         try:
             a = tester.ro
         except ReframeDeprecationWarning:
-            self.fail('deprecation warning not expected here')
+            pytest.fail('deprecation warning not expected here')
 
-        with self.assertWarns(ReframeDeprecationWarning):
+        with pytest.warns(ReframeDeprecationWarning):
             a = tester.value
 
-        with self.assertWarns(ReframeDeprecationWarning):
+        with pytest.warns(ReframeDeprecationWarning):
             a = tester.wo
 
     def test_absolute_path_field(self):
@@ -207,15 +209,15 @@ def __init__(self, value):
                 self.value = value
 
         tester = FieldTester('foo')
-        self.assertEqual(os.path.abspath('foo'), tester.value)
+        assert os.path.abspath('foo') == tester.value
 
         # Test set with an absolute path already
         tester.value = os.path.abspath('foo')
-        self.assertEqual(os.path.abspath('foo'), tester.value)
+        assert os.path.abspath('foo') == tester.value
 
         # This should not raise
         tester.value = None
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             tester.value = 1
 
     def test_scoped_dict_field(self):
@@ -236,21 +238,19 @@ class FieldTester:
         tester.field_maybe_none = None
 
         # Check that we have indeed a ScopedDict here
-        self.assertIsInstance(FieldTester.field, fields.ScopedDictField)
-        self.assertIsInstance(tester.field, ScopedDict)
-        self.assertEqual(10, tester.field['a:k4'])
+        assert isinstance(FieldTester.field, fields.ScopedDictField)
+        assert isinstance(tester.field, ScopedDict)
+        assert 10 == tester.field['a:k4']
 
         # Test invalid assignments
-        self.assertRaises(TypeError, exec,
-                          'tester.field = {1: "a", 2: "b" }',
-                          globals(), locals())
-        self.assertRaises(TypeError, exec,
-                          "tester.field = [('a', 1), ('b', 2)]",
-                          globals(), locals())
-        self.assertRaises(TypeError, exec,
-                          '''tester.field = {'a': {1: 'k1'},
-                                             'b': {2: 'k2'}}''',
-                          globals(), locals())
+        with pytest.raises(TypeError):
+            tester.field = {1: "a", 2: "b"}
+
+        with pytest.raises(TypeError):
+            tester.field = [('a', 1), ('b', 2)]
+
+        with pytest.raises(TypeError):
+            tester.field = {'a': {1: 'k1'}, 'b': {2: 'k2'}}
 
         # Test assigning a ScopedDict already
         tester.field = ScopedDict({})
diff --git a/unittests/test_launchers.py b/unittests/test_launchers.py
index 689add6bd3..c809ff6768 100644
--- a/unittests/test_launchers.py
+++ b/unittests/test_launchers.py
@@ -89,11 +89,11 @@ def run_command(self, job):
 
     def test_run_command(self):
         emitted_command = self.run_command(self.job)
-        self.assertEqual(self.expected_command, emitted_command)
+        assert self.expected_command == emitted_command
 
     def test_run_minimal_command(self):
         emitted_command = self.run_command(self.minimal_job)
-        self.assertEqual(self.expected_minimal_command, emitted_command)
+        assert self.expected_minimal_command == emitted_command
 
 
 class TestSrunLauncher(_TestLauncher, unittest.TestCase):
diff --git a/unittests/test_loader.py b/unittests/test_loader.py
index d600eef3ea..8d0a20b3af 100644
--- a/unittests/test_loader.py
+++ b/unittests/test_loader.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import os
+import pytest
 import unittest
 
 from reframe.core.exceptions import (ConfigError, NameConflictError,
@@ -25,47 +26,48 @@ def setUp(self):
     def test_load_file_relative(self):
         checks = self.loader.load_from_file(
             'unittests/resources/checks/emptycheck.py')
-        self.assertEqual(1, len(checks))
-        self.assertEqual(checks[0].name, 'EmptyTest')
+        assert 1 == len(checks)
+        assert checks[0].name == 'EmptyTest'
 
     def test_load_file_absolute(self):
         checks = self.loader.load_from_file(
             os.path.abspath('unittests/resources/checks/emptycheck.py'))
-        self.assertEqual(1, len(checks))
-        self.assertEqual(checks[0].name, 'EmptyTest')
+        assert 1 == len(checks)
+        assert checks[0].name == 'EmptyTest'
 
     def test_load_recursive(self):
         checks = self.loader.load_from_dir('unittests/resources/checks',
                                            recurse=True)
-        self.assertEqual(12, len(checks))
+        assert 12 == len(checks)
 
     def test_load_all(self):
         checks = self.loader_with_path.load_all()
-        self.assertEqual(11, len(checks))
+        assert 11 == len(checks)
 
     def test_load_all_with_prefix(self):
         checks = self.loader_with_prefix.load_all()
-        self.assertEqual(1, len(checks))
+        assert 1 == len(checks)
 
     def test_load_new_syntax(self):
         checks = self.loader.load_from_file(
             'unittests/resources/checks_unlisted/good.py')
-        self.assertEqual(13, len(checks))
+        assert 13 == len(checks)
 
     def test_conflicted_checks(self):
         self.loader_with_path._ignore_conflicts = False
-        self.assertRaises(NameConflictError, self.loader_with_path.load_all)
+        with pytest.raises(NameConflictError):
+            self.loader_with_path.load_all()
 
     def test_load_error(self):
-        self.assertRaises(OSError, self.loader.load_from_file,
-                          'unittests/resources/checks/foo.py')
+        with pytest.raises(OSError):
+            self.loader.load_from_file('unittests/resources/checks/foo.py')
 
     def test_load_bad_required_version(self):
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             self.loader.load_from_file('unittests/resources/checks_unlisted/'
                                        'no_required_version.py')
 
     def test_load_bad_init(self):
         tests = self.loader.load_from_file(
             'unittests/resources/checks_unlisted/bad_init_check.py')
-        self.assertEqual(0, len(tests))
+        assert 0 == len(tests)
diff --git a/unittests/test_logging.py b/unittests/test_logging.py
index e6c0cba4ac..6ea020d358 100644
--- a/unittests/test_logging.py
+++ b/unittests/test_logging.py
@@ -6,6 +6,7 @@
 import logging
 import logging.handlers
 import os
+import pytest
 import sys
 import re
 import tempfile
@@ -67,36 +68,39 @@ def found_in_logfile(self, pattern):
         return found
 
     def test_invalid_loglevel(self):
-        self.assertRaises(ValueError, self.logger.setLevel, 'level')
-        self.assertRaises(ValueError, rlog.Logger, 'logger', 'level')
+        with pytest.raises(ValueError):
+            self.logger.setLevel('level')
+
+        with pytest.raises(ValueError):
+            rlog.Logger('logger', 'level')
 
     def test_custom_loglevels(self):
         self.logger_without_check.info('foo')
         self.logger_without_check.verbose('bar')
 
-        self.assertTrue(os.path.exists(self.logfile))
-        self.assertTrue(self.found_in_logfile('info'))
-        self.assertTrue(self.found_in_logfile('verbose'))
-        self.assertTrue(self.found_in_logfile('reframe'))
+        assert os.path.exists(self.logfile)
+        assert self.found_in_logfile('info')
+        assert self.found_in_logfile('verbose')
+        assert self.found_in_logfile('reframe')
 
     def test_check_logger(self):
         self.logger_with_check.info('foo')
         self.logger_with_check.verbose('bar')
 
-        self.assertTrue(os.path.exists(self.logfile))
-        self.assertTrue(self.found_in_logfile('info'))
-        self.assertTrue(self.found_in_logfile('verbose'))
-        self.assertTrue(self.found_in_logfile('_FakeCheck'))
+        assert os.path.exists(self.logfile)
+        assert self.found_in_logfile('info')
+        assert self.found_in_logfile('verbose')
+        assert self.found_in_logfile('_FakeCheck')
 
     def test_handler_types(self):
-        self.assertTrue(issubclass(logging.Handler, rlog.Handler))
-        self.assertTrue(issubclass(logging.StreamHandler, rlog.Handler))
-        self.assertTrue(issubclass(logging.FileHandler, rlog.Handler))
-        self.assertTrue(issubclass(logging.handlers.RotatingFileHandler,
-                                   rlog.Handler))
+        assert issubclass(logging.Handler, rlog.Handler)
+        assert issubclass(logging.StreamHandler, rlog.Handler)
+        assert issubclass(logging.FileHandler, rlog.Handler)
+        assert issubclass(logging.handlers.RotatingFileHandler, rlog.Handler)
 
         # Try to instantiate rlog.Handler
-        self.assertRaises(TypeError, rlog.Handler)
+        with pytest.raises(TypeError):
+            rlog.Handler()
 
     def test_custom_handler_levels(self):
         self.handler.setLevel('verbose')
@@ -105,8 +109,8 @@ def test_custom_handler_levels(self):
         self.logger_with_check.debug('foo')
         self.logger_with_check.verbose('bar')
 
-        self.assertFalse(self.found_in_logfile('foo'))
-        self.assertTrue(self.found_in_logfile('bar'))
+        assert not self.found_in_logfile('foo')
+        assert self.found_in_logfile('bar')
 
     def test_logger_levels(self):
         self.logger_with_check.setLevel('verbose')
@@ -115,8 +119,8 @@ def test_logger_levels(self):
         self.logger_with_check.debug('bar')
         self.logger_with_check.verbose('foo')
 
-        self.assertFalse(self.found_in_logfile('bar'))
-        self.assertTrue(self.found_in_logfile('foo'))
+        assert not self.found_in_logfile('bar')
+        assert self.found_in_logfile('foo')
 
     def test_rfc3339_timezone_extension(self):
         self.formatter = rlog.RFC3339Formatter(
@@ -184,25 +188,25 @@ def flush_handlers(self):
 
     def test_valid_level(self):
         rlog.configure_logging(self.logging_config)
-        self.assertEqual(rlog.INFO, rlog.getlogger().getEffectiveLevel())
+        assert rlog.INFO == rlog.getlogger().getEffectiveLevel()
 
     def test_no_handlers(self):
         del self.logging_config['handlers']
-        self.assertRaises(ValueError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ValueError):
+            rlog.configure_logging(self.logging_config)
 
     def test_empty_handlers(self):
         self.logging_config['handlers'] = []
-        self.assertRaises(ValueError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ValueError):
+            rlog.configure_logging(self.logging_config)
 
     def test_handler_level(self):
         rlog.configure_logging(self.logging_config)
         rlog.getlogger().info('foo')
         rlog.getlogger().warning('bar')
 
-        self.assertFalse(self.found_in_logfile('foo'))
-        self.assertTrue(self.found_in_logfile('bar'))
+        assert not self.found_in_logfile('foo')
+        assert self.found_in_logfile('bar')
 
     def test_handler_append(self):
         rlog.configure_logging(self.logging_config)
@@ -213,8 +217,8 @@ def test_handler_append(self):
         rlog.configure_logging(self.logging_config)
         rlog.getlogger().warning('bar')
 
-        self.assertTrue(self.found_in_logfile('foo'))
-        self.assertTrue(self.found_in_logfile('bar'))
+        assert self.found_in_logfile('foo')
+        assert self.found_in_logfile('bar')
 
     def test_handler_noappend(self):
         self.logging_config = {
@@ -239,13 +243,13 @@ def test_handler_noappend(self):
         rlog.configure_logging(self.logging_config)
         rlog.getlogger().warning('bar')
 
-        self.assertFalse(self.found_in_logfile('foo'))
-        self.assertTrue(self.found_in_logfile('bar'))
+        assert not self.found_in_logfile('foo')
+        assert self.found_in_logfile('bar')
 
     def test_date_format(self):
         rlog.configure_logging(self.logging_config)
         rlog.getlogger().warning('foo')
-        self.assertTrue(self.found_in_logfile(datetime.now().strftime('%F')))
+        assert self.found_in_logfile(datetime.now().strftime('%F'))
 
     def test_unknown_handler(self):
         self.logging_config = {
@@ -255,16 +259,16 @@ def test_unknown_handler(self):
                 {'type': 'foo'}
             ],
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_handler_syntax_no_type(self):
         self.logging_config = {
             'level': 'INFO',
             'handlers': [{'name': 'stderr'}]
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_handler_convert_syntax(self):
         old_syntax = {
@@ -315,11 +319,11 @@ def test_stream_handler_stdout(self):
         }
         rlog.configure_logging(self.logging_config)
         raw_logger = rlog.getlogger().logger
-        self.assertEqual(len(raw_logger.handlers), 1)
+        assert len(raw_logger.handlers) == 1
         handler = raw_logger.handlers[0]
 
-        self.assertIsInstance(handler, logging.StreamHandler)
-        self.assertEqual(handler.stream, sys.stdout)
+        assert isinstance(handler, logging.StreamHandler)
+        assert handler.stream == sys.stdout
 
     def test_stream_handler_stderr(self):
         self.logging_config = {
@@ -329,11 +333,11 @@ def test_stream_handler_stderr(self):
 
         rlog.configure_logging(self.logging_config)
         raw_logger = rlog.getlogger().logger
-        self.assertEqual(len(raw_logger.handlers), 1)
+        assert len(raw_logger.handlers) == 1
         handler = raw_logger.handlers[0]
 
-        self.assertIsInstance(handler, logging.StreamHandler)
-        self.assertEqual(handler.stream, sys.stderr)
+        assert isinstance(handler, logging.StreamHandler)
+        assert handler.stream == sys.stderr
 
     def test_multiple_handlers(self):
         self.logging_config = {
@@ -345,14 +349,14 @@ def test_multiple_handlers(self):
             ],
         }
         rlog.configure_logging(self.logging_config)
-        self.assertEqual(len(rlog.getlogger().logger.handlers), 3)
+        assert len(rlog.getlogger().logger.handlers) == 3
 
     def test_file_handler_timestamp(self):
         self.logging_config['handlers'][0]['timestamp'] = '%F'
         rlog.configure_logging(self.logging_config)
         rlog.getlogger().warning('foo')
         logfile = '%s_%s' % (self.logfile, datetime.now().strftime('%F'))
-        self.assertTrue(os.path.exists(logfile))
+        assert os.path.exists(logfile)
         os.remove(logfile)
 
     def test_file_handler_syntax_no_name(self):
@@ -362,8 +366,8 @@ def test_file_handler_syntax_no_name(self):
                 {'type': 'file'}
             ],
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_stream_handler_unknown_stream(self):
         self.logging_config = {
@@ -372,8 +376,8 @@ def test_stream_handler_unknown_stream(self):
                 {'type': 'stream', 'name': 'foo'},
             ],
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_syslog_handler(self):
         import platform
@@ -383,7 +387,7 @@ def test_syslog_handler(self):
         elif platform.system() == 'Darwin':
             addr = '/dev/run/syslog'
         else:
-            self.skipTest()
+            pytest.skip()
 
         self.logging_config = {
             'level': 'INFO',
@@ -396,24 +400,24 @@ def test_syslog_handler_no_address(self):
             'level': 'INFO',
             'handlers': [{'type': 'syslog'}]
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_syslog_handler_unknown_facility(self):
         self.logging_config = {
             'level': 'INFO',
             'handlers': [{'type': 'syslog', 'facility': 'foo'}]
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_syslog_handler_unknown_socktype(self):
         self.logging_config = {
             'level': 'INFO',
             'handlers': [{'type': 'syslog', 'socktype': 'foo'}]
         }
-        self.assertRaises(ConfigError, rlog.configure_logging,
-                          self.logging_config)
+        with pytest.raises(ConfigError):
+            rlog.configure_logging(self.logging_config)
 
     def test_global_noconfig(self):
         # This is to test the case when no configuration is set, but since the
@@ -421,21 +425,21 @@ def test_global_noconfig(self):
         # 'no-config' state by passing `None` to `configure_logging()`
 
         rlog.configure_logging(None)
-        self.assertIs(rlog.getlogger(), rlog.null_logger)
+        assert rlog.getlogger() is rlog.null_logger
 
     def test_global_config(self):
         rlog.configure_logging(self.logging_config)
-        self.assertIsNot(rlog.getlogger(), rlog.null_logger)
+        assert rlog.getlogger() is not rlog.null_logger
 
     def test_logging_context(self):
         rlog.configure_logging(self.logging_config)
         with rlog.logging_context() as logger:
-            self.assertIs(logger, rlog.getlogger())
-            self.assertIsNot(logger, rlog.null_logger)
+            assert logger is rlog.getlogger()
+            assert logger is not rlog.null_logger
             rlog.getlogger().error('error from context')
 
-        self.assertTrue(self.found_in_logfile('reframe'))
-        self.assertTrue(self.found_in_logfile('error from context'))
+        assert self.found_in_logfile('reframe')
+        assert self.found_in_logfile('error from context')
 
     def test_logging_context_check(self):
         rlog.configure_logging(self.logging_config)
@@ -443,10 +447,10 @@ def test_logging_context_check(self):
             rlog.getlogger().error('error from context')
 
         rlog.getlogger().error('error outside context')
-        self.assertTrue(self.found_in_logfile(
-            '_FakeCheck: %s: error from context' % sys.argv[0]))
-        self.assertTrue(self.found_in_logfile(
-            'reframe: %s: error outside context' % sys.argv[0]))
+        assert self.found_in_logfile(
+            '_FakeCheck: %s: error from context' % sys.argv[0])
+        assert self.found_in_logfile(
+            'reframe: %s: error outside context' % sys.argv[0])
 
     def test_logging_context_error(self):
         rlog.configure_logging(self.logging_config)
@@ -454,9 +458,9 @@ def test_logging_context_error(self):
             with rlog.logging_context(level=rlog.ERROR):
                 raise ReframeError('error from context')
 
-            self.fail('logging_context did not propagate the exception')
+            pytest.fail('logging_context did not propagate the exception')
         except ReframeError:
             pass
 
-        self.assertTrue(self.found_in_logfile('reframe'))
-        self.assertTrue(self.found_in_logfile('error from context'))
+        assert self.found_in_logfile('reframe')
+        assert self.found_in_logfile('error from context')
diff --git a/unittests/test_modules.py b/unittests/test_modules.py
index f51df0c677..b909baff03 100644
--- a/unittests/test_modules.py
+++ b/unittests/test_modules.py
@@ -5,6 +5,7 @@
 
 import abc
 import os
+import pytest
 import unittest
 from tempfile import NamedTemporaryFile
 
@@ -24,53 +25,55 @@ def tearDown(self):
         self.environ_save.restore()
 
     def test_searchpath(self):
-        self.assertIn(TEST_MODULES, self.modules_system.searchpath)
+        assert TEST_MODULES in self.modules_system.searchpath
 
         self.modules_system.searchpath_remove(TEST_MODULES)
-        self.assertNotIn(TEST_MODULES, self.modules_system.searchpath)
+        assert TEST_MODULES not in self.modules_system.searchpath
 
     def test_module_load(self):
-        self.assertRaises(EnvironError, self.modules_system.load_module, 'foo')
-        self.assertFalse(self.modules_system.is_module_loaded('foo'))
-        self.assertNotIn('foo', self.modules_system.loaded_modules())
+        with pytest.raises(EnvironError):
+            self.modules_system.load_module('foo')
+
+        assert not self.modules_system.is_module_loaded('foo')
+        assert 'foo' not in self.modules_system.loaded_modules()
 
         self.modules_system.load_module('testmod_foo')
-        self.assertTrue(self.modules_system.is_module_loaded('testmod_foo'))
-        self.assertIn('testmod_foo', self.modules_system.loaded_modules())
-        self.assertIn('TESTMOD_FOO', os.environ)
+        assert self.modules_system.is_module_loaded('testmod_foo')
+        assert 'testmod_foo' in self.modules_system.loaded_modules()
+        assert 'TESTMOD_FOO' in os.environ
 
         self.modules_system.unload_module('testmod_foo')
-        self.assertFalse(self.modules_system.is_module_loaded('testmod_foo'))
-        self.assertNotIn('testmod_foo', self.modules_system.loaded_modules())
-        self.assertNotIn('TESTMOD_FOO', os.environ)
+        assert not self.modules_system.is_module_loaded('testmod_foo')
+        assert 'testmod_foo' not in self.modules_system.loaded_modules()
+        assert 'TESTMOD_FOO' not in os.environ
 
     def test_module_load_force(self):
         self.modules_system.load_module('testmod_foo')
 
         unloaded = self.modules_system.load_module('testmod_foo', force=True)
-        self.assertEqual(0, len(unloaded))
-        self.assertTrue(self.modules_system.is_module_loaded('testmod_foo'))
+        assert 0 == len(unloaded)
+        assert self.modules_system.is_module_loaded('testmod_foo')
 
         unloaded = self.modules_system.load_module('testmod_bar', force=True)
-        self.assertTrue(self.modules_system.is_module_loaded('testmod_bar'))
-        self.assertFalse(self.modules_system.is_module_loaded('testmod_foo'))
-        self.assertIn('testmod_foo', unloaded)
-        self.assertIn('TESTMOD_BAR', os.environ)
+        assert self.modules_system.is_module_loaded('testmod_bar')
+        assert not self.modules_system.is_module_loaded('testmod_foo')
+        assert 'testmod_foo' in unloaded
+        assert 'TESTMOD_BAR' in os.environ
 
     def test_module_unload_all(self):
         self.modules_system.load_module('testmod_base')
         self.modules_system.unload_all()
-        self.assertEqual(0, len(self.modules_system.loaded_modules()))
+        assert 0 == len(self.modules_system.loaded_modules())
 
     def test_module_list(self):
         self.modules_system.load_module('testmod_foo')
-        self.assertIn('testmod_foo', self.modules_system.loaded_modules())
+        assert 'testmod_foo' in self.modules_system.loaded_modules()
         self.modules_system.unload_module('testmod_foo')
 
     def test_module_conflict_list(self):
         conflict_list = self.modules_system.conflicted_modules('testmod_bar')
-        self.assertIn('testmod_foo', conflict_list)
-        self.assertIn('testmod_boo', conflict_list)
+        assert 'testmod_foo' in conflict_list
+        assert 'testmod_boo' in conflict_list
 
     @abc.abstractmethod
     def expected_load_instr(self, module):
@@ -84,25 +87,25 @@ def test_emit_load_commands(self):
         self.modules_system.module_map = {
             'm0': ['m1', 'm2']
         }
-        self.assertEqual([self.expected_load_instr('foo')],
-                         self.modules_system.emit_load_commands('foo'))
-        self.assertEqual([self.expected_load_instr('foo/1.2')],
-                         self.modules_system.emit_load_commands('foo/1.2'))
-        self.assertEqual([self.expected_load_instr('m1'),
-                          self.expected_load_instr('m2')],
-                         self.modules_system.emit_load_commands('m0'))
+        assert ([self.expected_load_instr('foo')] ==
+                self.modules_system.emit_load_commands('foo'))
+        assert ([self.expected_load_instr('foo/1.2')] ==
+                self.modules_system.emit_load_commands('foo/1.2'))
+        assert ([self.expected_load_instr('m1'),
+                 self.expected_load_instr('m2')] ==
+                self.modules_system.emit_load_commands('m0'))
 
     def test_emit_unload_commands(self):
         self.modules_system.module_map = {
             'm0': ['m1', 'm2']
         }
-        self.assertEqual([self.expected_unload_instr('foo')],
-                         self.modules_system.emit_unload_commands('foo'))
-        self.assertEqual([self.expected_unload_instr('foo/1.2')],
-                         self.modules_system.emit_unload_commands('foo/1.2'))
-        self.assertEqual([self.expected_unload_instr('m2'),
-                          self.expected_unload_instr('m1')],
-                         self.modules_system.emit_unload_commands('m0'))
+        assert ([self.expected_unload_instr('foo')] ==
+                self.modules_system.emit_unload_commands('foo'))
+        assert ([self.expected_unload_instr('foo/1.2')] ==
+                self.modules_system.emit_unload_commands('foo/1.2'))
+        assert ([self.expected_unload_instr('m2'),
+                 self.expected_unload_instr('m1')] ==
+                self.modules_system.emit_unload_commands('m0'))
 
 
 class TestTModModulesSystem(_TestModulesSystem, unittest.TestCase):
@@ -110,7 +113,7 @@ def setUp(self):
         try:
             self.modules_system = modules.ModulesSystem.create('tmod')
         except ConfigError:
-            self.skipTest('tmod not supported')
+            pytest.skip('tmod not supported')
         else:
             super().setUp()
 
@@ -126,7 +129,7 @@ def setUp(self):
         try:
             self.modules_system = modules.ModulesSystem.create('tmod4')
         except ConfigError:
-            self.skipTest('tmod4 not supported')
+            pytest.skip('tmod4 not supported')
         else:
             super().setUp()
 
@@ -142,7 +145,7 @@ def setUp(self):
         try:
             self.modules_system = modules.ModulesSystem.create('lmod')
         except ConfigError:
-            self.skipTest('lmod not supported')
+            pytest.skip('lmod not supported')
         else:
             super().setUp()
 
@@ -158,7 +161,7 @@ def setUp(self):
         try:
             self.modules_system = modules.ModulesSystem.create()
         except ConfigError:
-            self.skipTest('nomod not supported')
+            pytest.skip('nomod not supported')
         else:
             super().setUp()
 
@@ -183,10 +186,10 @@ def test_module_unload_all(self):
         self.modules_system.unload_all()
 
     def test_module_list(self):
-        self.assertEqual(0, len(self.modules_system.loaded_modules()))
+        assert 0 == len(self.modules_system.loaded_modules())
 
     def test_module_conflict_list(self):
-        self.assertEqual(0, len(self.modules_system.conflicted_modules('foo')))
+        assert 0 == len(self.modules_system.conflicted_modules('foo'))
 
 
 class TestModule(unittest.TestCase):
@@ -194,30 +197,33 @@ def setUp(self):
         self.module = modules.Module('foo/1.2')
 
     def test_invalid_initialization(self):
-        self.assertRaises(ValueError, modules.Module, '')
-        self.assertRaises(ValueError, modules.Module, ' ')
-        self.assertRaises(TypeError, modules.Module, None)
-        self.assertRaises(TypeError, modules.Module, 23)
+        with pytest.raises(ValueError):
+            modules.Module('')
+
+        with pytest.raises(ValueError):
+            modules.Module(' ')
+
+        with pytest.raises(TypeError):
+            modules.Module(None)
+
+        with pytest.raises(TypeError):
+            modules.Module(23)
 
     def test_name_version(self):
-        self.assertEqual(self.module.name, 'foo')
-        self.assertEqual(self.module.version, '1.2')
+        assert self.module.name == 'foo'
+        assert self.module.version == '1.2'
 
     def test_equal(self):
-        self.assertEqual(modules.Module('foo'), modules.Module('foo'))
-        self.assertEqual(modules.Module('foo/1.2'),
-                         modules.Module('foo/1.2'))
-        self.assertEqual(modules.Module('foo'), modules.Module('foo/1.2'))
-        self.assertEqual(hash(modules.Module('foo')),
-                         hash(modules.Module('foo')))
-        self.assertEqual(hash(modules.Module('foo/1.2')),
-                         hash(modules.Module('foo/1.2')))
-        self.assertEqual(hash(modules.Module('foo')),
-                         hash(modules.Module('foo/1.2')))
-        self.assertNotEqual(modules.Module('foo/1.2'),
-                            modules.Module('foo/1.3'))
-        self.assertNotEqual(modules.Module('foo'), modules.Module('bar'))
-        self.assertNotEqual(modules.Module('foo'), modules.Module('foobar'))
+        assert modules.Module('foo') == modules.Module('foo')
+        assert modules.Module('foo/1.2') == modules.Module('foo/1.2')
+        assert modules.Module('foo') == modules.Module('foo/1.2')
+        assert hash(modules.Module('foo')) == hash(modules.Module('foo'))
+        assert (hash(modules.Module('foo/1.2')) ==
+                hash(modules.Module('foo/1.2')))
+        assert hash(modules.Module('foo')) == hash(modules.Module('foo/1.2'))
+        assert modules.Module('foo/1.2') != modules.Module('foo/1.3')
+        assert modules.Module('foo') != modules.Module('bar')
+        assert modules.Module('foo') != modules.Module('foobar')
 
 
 class ModulesSystemEmulator(modules.ModulesSystemImpl):
@@ -291,14 +297,14 @@ def test_mapping_simple(self):
         #
         self.modules_system.module_map = {'m0': ['m1']}
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertEqual(['m1'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert ['m1'] == self.modules_system.backend.load_seq
 
         # Unload module
         self.modules_system.unload_module('m1')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertFalse(self.modules_system.is_module_loaded('m1'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert not self.modules_system.is_module_loaded('m1')
 
     def test_mapping_chain(self):
         #
@@ -309,16 +315,16 @@ def test_mapping_chain(self):
             'm1': ['m2']
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertEqual(['m2'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert ['m2'] == self.modules_system.backend.load_seq
 
         # Unload module
         self.modules_system.unload_module('m1')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertFalse(self.modules_system.is_module_loaded('m1'))
-        self.assertFalse(self.modules_system.is_module_loaded('m2'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert not self.modules_system.is_module_loaded('m1')
+        assert not self.modules_system.is_module_loaded('m2')
 
     def test_mapping_n_to_one(self):
         #
@@ -329,16 +335,16 @@ def test_mapping_n_to_one(self):
             'm1': ['m2']
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertEqual(['m2'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert ['m2'] == self.modules_system.backend.load_seq
 
         # Unload module
         self.modules_system.unload_module('m0')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertFalse(self.modules_system.is_module_loaded('m1'))
-        self.assertFalse(self.modules_system.is_module_loaded('m2'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert not self.modules_system.is_module_loaded('m1')
+        assert not self.modules_system.is_module_loaded('m2')
 
     def test_mapping_one_to_n(self):
         #
@@ -348,15 +354,15 @@ def test_mapping_one_to_n(self):
             'm0': ['m1', 'm2'],
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertEqual(['m1', 'm2'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert ['m1', 'm2'] == self.modules_system.backend.load_seq
 
         # m0 is loaded only if m1 and m2 are.
         self.modules_system.unload_module('m2')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
 
     def test_mapping_deep_dfs_order(self):
         #
@@ -371,21 +377,20 @@ def test_mapping_deep_dfs_order(self):
             'm1': ['m3', 'm4']
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertTrue(self.modules_system.is_module_loaded('m3'))
-        self.assertTrue(self.modules_system.is_module_loaded('m4'))
-        self.assertEqual(['m3', 'm4', 'm2'],
-                         self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert self.modules_system.is_module_loaded('m3')
+        assert self.modules_system.is_module_loaded('m4')
+        assert ['m3', 'm4', 'm2'] == self.modules_system.backend.load_seq
 
         # Test unloading
         self.modules_system.unload_module('m2')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertFalse(self.modules_system.is_module_loaded('m2'))
-        self.assertTrue(self.modules_system.is_module_loaded('m3'))
-        self.assertTrue(self.modules_system.is_module_loaded('m4'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert not self.modules_system.is_module_loaded('m2')
+        assert self.modules_system.is_module_loaded('m3')
+        assert self.modules_system.is_module_loaded('m4')
 
     def test_mapping_deep_dfs_unload_order(self):
         #
@@ -401,8 +406,7 @@ def test_mapping_deep_dfs_unload_order(self):
         }
         self.modules_system.load_module('m0')
         self.modules_system.unload_module('m0')
-        self.assertEqual(['m2', 'm4', 'm3'],
-                         self.modules_system.backend.unload_seq)
+        assert ['m2', 'm4', 'm3'] == self.modules_system.backend.unload_seq
 
     def test_mapping_multiple_paths(self):
         #
@@ -417,16 +421,16 @@ def test_mapping_multiple_paths(self):
             'm2': ['m1'],
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertEqual(['m1'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert ['m1'] == self.modules_system.backend.load_seq
 
         # Test unloading
         self.modules_system.unload_module('m2')
-        self.assertFalse(self.modules_system.is_module_loaded('m0'))
-        self.assertFalse(self.modules_system.is_module_loaded('m1'))
-        self.assertFalse(self.modules_system.is_module_loaded('m2'))
+        assert not self.modules_system.is_module_loaded('m0')
+        assert not self.modules_system.is_module_loaded('m1')
+        assert not self.modules_system.is_module_loaded('m2')
 
     def test_mapping_deep_multiple_paths(self):
         #
@@ -442,12 +446,12 @@ def test_mapping_deep_multiple_paths(self):
             'm2': ['m1']
         }
         self.modules_system.load_module('m0')
-        self.assertTrue(self.modules_system.is_module_loaded('m0'))
-        self.assertTrue(self.modules_system.is_module_loaded('m1'))
-        self.assertTrue(self.modules_system.is_module_loaded('m2'))
-        self.assertTrue(self.modules_system.is_module_loaded('m3'))
-        self.assertTrue(self.modules_system.is_module_loaded('m4'))
-        self.assertEqual(['m3', 'm4'], self.modules_system.backend.load_seq)
+        assert self.modules_system.is_module_loaded('m0')
+        assert self.modules_system.is_module_loaded('m1')
+        assert self.modules_system.is_module_loaded('m2')
+        assert self.modules_system.is_module_loaded('m3')
+        assert self.modules_system.is_module_loaded('m4')
+        assert ['m3', 'm4'] == self.modules_system.backend.load_seq
 
     def test_mapping_cycle_simple(self):
         #
@@ -457,8 +461,11 @@ def test_mapping_cycle_simple(self):
             'm0': ['m1'],
             'm1': ['m0'],
         }
-        self.assertRaises(EnvironError, self.modules_system.load_module, 'm0')
-        self.assertRaises(EnvironError, self.modules_system.load_module, 'm1')
+        with pytest.raises(EnvironError):
+            self.modules_system.load_module('m0')
+
+        with pytest.raises(EnvironError):
+            self.modules_system.load_module('m1')
 
     def test_mapping_single_module_self_loop(self):
         #
@@ -486,8 +493,8 @@ def test_mapping_deep_cycle(self):
             'm3': ['m4'],
             'm4': ['m2']
         }
-        self.assertRaisesRegex(EnvironError, 'm0->m1->m3->m4->m2->m1',
-                               self.modules_system.load_module, 'm0')
+        with pytest.raises(EnvironError, match='m0->m1->m3->m4->m2->m1'):
+            self.modules_system.load_module('m0')
 
     def test_mapping_from_file_simple(self):
         with self.mapping_file:
@@ -504,44 +511,39 @@ def test_mapping_from_file_simple(self):
             'm9': ['m10']
         }
         self.modules_system.load_mapping_from_file(self.mapping_file.name)
-        self.assertEqual(reference_map, self.modules_system.module_map)
+        assert reference_map == self.modules_system.module_map
 
     def test_mapping_from_file_missing_key_separator(self):
         with self.mapping_file:
             self.mapping_file.write('m1 m2')
 
-        self.assertRaises(ConfigError,
-                          self.modules_system.load_mapping_from_file,
-                          self.mapping_file.name)
+        with pytest.raises(ConfigError):
+            self.modules_system.load_mapping_from_file(self.mapping_file.name)
 
     def test_mapping_from_file_empty_value(self):
         with self.mapping_file:
             self.mapping_file.write('m1: # m2')
 
-        self.assertRaises(ConfigError,
-                          self.modules_system.load_mapping_from_file,
-                          self.mapping_file.name)
+        with pytest.raises(ConfigError):
+            self.modules_system.load_mapping_from_file(self.mapping_file.name)
 
     def test_mapping_from_file_multiple_key_separators(self):
         with self.mapping_file:
             self.mapping_file.write('m1 : m2 : m3')
 
-        self.assertRaises(ConfigError,
-                          self.modules_system.load_mapping_from_file,
-                          self.mapping_file.name)
+        with pytest.raises(ConfigError):
+            self.modules_system.load_mapping_from_file(self.mapping_file.name)
 
     def test_mapping_from_file_empty_key(self):
         with self.mapping_file:
             self.mapping_file.write(' :  m2')
 
-        self.assertRaises(ConfigError,
-                          self.modules_system.load_mapping_from_file,
-                          self.mapping_file.name)
+        with pytest.raises(ConfigError):
+            self.modules_system.load_mapping_from_file(self.mapping_file.name)
 
     def test_mapping_from_file_missing_file(self):
-        self.assertRaises(OSError,
-                          self.modules_system.load_mapping_from_file,
-                          'foo')
+        with pytest.raises(OSError):
+            self.modules_system.load_mapping_from_file('foo')
 
     def test_mapping_with_self_loop(self):
         self.modules_system.module_map = {
diff --git a/unittests/test_pipeline.py b/unittests/test_pipeline.py
index 1bcc8422db..75da6c222b 100644
--- a/unittests/test_pipeline.py
+++ b/unittests/test_pipeline.py
@@ -101,13 +101,13 @@ def test_environ_setup(self):
         test.setup(self.partition, self.prgenv)
 
         for k in test.variables.keys():
-            self.assertNotIn(k, os.environ)
+            assert k not in os.environ
 
     def _run_test(self, test, compile_only=False):
         _run(test, self.partition, self.prgenv)
-        self.assertFalse(os.path.exists(test.stagedir))
+        assert not os.path.exists(test.stagedir)
         for f in self.keep_files_list(test, compile_only):
-            self.assertTrue(os.path.exists(f))
+            assert os.path.exists(f)
 
     @fixtures.switch_to_user_runtime
     def test_hellocheck(self):
@@ -215,7 +215,8 @@ def test_compile_only_failure(self):
         test.valid_systems = ['*']
         test.setup(self.partition, self.prgenv)
         test.compile()
-        self.assertRaises(BuildError, test.compile_wait)
+        with pytest.raises(BuildError):
+            test.compile_wait()
 
     def test_compile_only_warning(self):
         test = rfm.CompileOnlyRegressionTest()
@@ -234,43 +235,43 @@ def test_supports_system(self):
             'unittests/resources/checks/hellocheck.py')[0]
 
         test.valid_systems = ['*']
-        self.assertTrue(test.supports_system('gpu'))
-        self.assertTrue(test.supports_system('login'))
-        self.assertTrue(test.supports_system('testsys:gpu'))
-        self.assertTrue(test.supports_system('testsys:login'))
+        assert test.supports_system('gpu')
+        assert test.supports_system('login')
+        assert test.supports_system('testsys:gpu')
+        assert test.supports_system('testsys:login')
 
         test.valid_systems = ['testsys']
-        self.assertTrue(test.supports_system('gpu'))
-        self.assertTrue(test.supports_system('login'))
-        self.assertTrue(test.supports_system('testsys:gpu'))
-        self.assertTrue(test.supports_system('testsys:login'))
+        assert test.supports_system('gpu')
+        assert test.supports_system('login')
+        assert test.supports_system('testsys:gpu')
+        assert test.supports_system('testsys:login')
 
         test.valid_systems = ['testsys:gpu']
-        self.assertTrue(test.supports_system('gpu'))
-        self.assertFalse(test.supports_system('login'))
-        self.assertTrue(test.supports_system('testsys:gpu'))
-        self.assertFalse(test.supports_system('testsys:login'))
+        assert test.supports_system('gpu')
+        assert not test.supports_system('login')
+        assert test.supports_system('testsys:gpu')
+        assert not test.supports_system('testsys:login')
 
         test.valid_systems = ['testsys:login']
-        self.assertFalse(test.supports_system('gpu'))
-        self.assertTrue(test.supports_system('login'))
-        self.assertFalse(test.supports_system('testsys:gpu'))
-        self.assertTrue(test.supports_system('testsys:login'))
+        assert not test.supports_system('gpu')
+        assert test.supports_system('login')
+        assert not test.supports_system('testsys:gpu')
+        assert test.supports_system('testsys:login')
 
         test.valid_systems = ['foo']
-        self.assertFalse(test.supports_system('gpu'))
-        self.assertFalse(test.supports_system('login'))
-        self.assertFalse(test.supports_system('testsys:gpu'))
-        self.assertFalse(test.supports_system('testsys:login'))
+        assert not test.supports_system('gpu')
+        assert not test.supports_system('login')
+        assert not test.supports_system('testsys:gpu')
+        assert not test.supports_system('testsys:login')
 
     def test_supports_environ(self):
         test = self.loader.load_from_file(
             'unittests/resources/checks/hellocheck.py')[0]
 
         test.valid_prog_environs = ['*']
-        self.assertTrue(test.supports_environ('foo1'))
-        self.assertTrue(test.supports_environ('foo-env'))
-        self.assertTrue(test.supports_environ('*'))
+        assert test.supports_environ('foo1')
+        assert test.supports_environ('foo-env')
+        assert test.supports_environ('*')
 
     def test_sourcesdir_none(self):
         test = rfm.RegressionTest()
@@ -278,7 +279,8 @@ def test_sourcesdir_none(self):
         test.sourcesdir = None
         test.valid_prog_environs = ['*']
         test.valid_systems = ['*']
-        self.assertRaises(ReframeError, self._run_test, test)
+        with pytest.raises(ReframeError):
+            self._run_test(test)
 
     def test_sourcesdir_build_system(self):
         test = rfm.RegressionTest()
@@ -313,7 +315,8 @@ def test_sourcesdir_none_compile_only(self):
         test.sourcesdir = None
         test.valid_prog_environs = ['*']
         test.valid_systems = ['*']
-        self.assertRaises(BuildError, self._run_test, test)
+        with pytest.raises(BuildError):
+            self._run_test(test)
 
     def test_sourcesdir_none_run_only(self):
         test = rfm.RunOnlyRegressionTest()
@@ -334,7 +337,8 @@ def test_sourcepath_abs(self):
         test.valid_systems = ['*']
         test.setup(self.partition, self.prgenv)
         test.sourcepath = '/usr/src'
-        self.assertRaises(PipelineError, test.compile)
+        with pytest.raises(PipelineError):
+            test.compile()
 
     def test_sourcepath_upref(self):
         test = rfm.CompileOnlyRegressionTest()
@@ -343,7 +347,8 @@ def test_sourcepath_upref(self):
         test.valid_systems = ['*']
         test.setup(self.partition, self.prgenv)
         test.sourcepath = '../hellosrc'
-        self.assertRaises(PipelineError, test.compile)
+        with pytest.raises(PipelineError):
+            test.compile()
 
     @rt.switch_runtime(fixtures.TEST_SITE_CONFIG, 'testsys')
     def test_extra_resources(self):
@@ -626,10 +631,9 @@ def __init__(self, a, b):
                 self.b = b
 
         test = MyTest(1, 2)
-        self.assertEqual(os.path.abspath(os.path.dirname(__file__)),
-                         test.prefix)
-        self.assertEqual('TestSyntax.test_regression_test.'
-                         '<locals>.MyTest_1_2', test.name)
+        assert os.path.abspath(os.path.dirname(__file__)) == test.prefix
+        assert ('TestSyntax.test_regression_test.<locals>.MyTest_1_2' ==
+                test.name)
 
     def test_regression_test_strange_names(self):
         class C:
@@ -645,9 +649,8 @@ def __init__(self, a, b):
                 self.b = b
 
         test = MyTest('(a*b+c)/12', C(33))
-        self.assertEqual(
-            'TestSyntax.test_regression_test_strange_names.'
-            '<locals>.MyTest__a_b_c__12_C_33_', test.name)
+        assert ('TestSyntax.test_regression_test_strange_names.'
+                '<locals>.MyTest__a_b_c__12_C_33_' == test.name)
 
     def test_user_inheritance(self):
         class MyBaseTest(rfm.RegressionTest):
@@ -660,8 +663,7 @@ def __init__(self):
                 super().__init__(1, 2)
 
         test = MyTest()
-        self.assertEqual('TestSyntax.test_user_inheritance.'
-                         '<locals>.MyTest', test.name)
+        assert 'TestSyntax.test_user_inheritance.<locals>.MyTest' == test.name
 
     def test_runonly_test(self):
         class MyTest(rfm.RunOnlyRegressionTest):
@@ -670,10 +672,8 @@ def __init__(self, a, b):
                 self.b = b
 
         test = MyTest(1, 2)
-        self.assertEqual(os.path.abspath(os.path.dirname(__file__)),
-                         test.prefix)
-        self.assertEqual('TestSyntax.test_runonly_test.'
-                         '<locals>.MyTest_1_2', test.name)
+        assert os.path.abspath(os.path.dirname(__file__)) == test.prefix
+        assert 'TestSyntax.test_runonly_test.<locals>.MyTest_1_2' == test.name
 
     def test_compileonly_test(self):
         class MyTest(rfm.CompileOnlyRegressionTest):
@@ -682,29 +682,28 @@ def __init__(self, a, b):
                 self.b = b
 
         test = MyTest(1, 2)
-        self.assertEqual(os.path.abspath(os.path.dirname(__file__)),
-                         test.prefix)
-        self.assertEqual('TestSyntax.test_compileonly_test.'
-                         '<locals>.MyTest_1_2', test.name)
+        assert os.path.abspath(os.path.dirname(__file__)) == test.prefix
+        assert ('TestSyntax.test_compileonly_test.<locals>.MyTest_1_2' ==
+                test.name)
 
     def test_registration(self):
         import sys
         import unittests.resources.checks_unlisted.good as mod
         checks = mod._rfm_gettests()
-        self.assertEqual(13, len(checks))
-        self.assertEqual([mod.MyBaseTest(0, 0),
-                          mod.MyBaseTest(0, 1),
-                          mod.MyBaseTest(1, 0),
-                          mod.MyBaseTest(1, 1),
-                          mod.MyBaseTest(2, 0),
-                          mod.MyBaseTest(2, 1),
-                          mod.AnotherBaseTest(0, 0),
-                          mod.AnotherBaseTest(0, 1),
-                          mod.AnotherBaseTest(1, 0),
-                          mod.AnotherBaseTest(1, 1),
-                          mod.AnotherBaseTest(2, 0),
-                          mod.AnotherBaseTest(2, 1),
-                          mod.MyBaseTest(10, 20)], checks)
+        assert 13 == len(checks)
+        assert [mod.MyBaseTest(0, 0),
+                mod.MyBaseTest(0, 1),
+                mod.MyBaseTest(1, 0),
+                mod.MyBaseTest(1, 1),
+                mod.MyBaseTest(2, 0),
+                mod.MyBaseTest(2, 1),
+                mod.AnotherBaseTest(0, 0),
+                mod.AnotherBaseTest(0, 1),
+                mod.AnotherBaseTest(1, 0),
+                mod.AnotherBaseTest(1, 1),
+                mod.AnotherBaseTest(2, 0),
+                mod.AnotherBaseTest(2, 1),
+                mod.MyBaseTest(10, 20)] == checks
 
 
 class TestSanityPatterns(unittest.TestCase):
@@ -773,14 +772,16 @@ def test_success(self):
     def test_sanity_failure(self):
         self.output_file.write('result = failure\n')
         self.output_file.close()
-        self.assertRaises(SanityError, self.test.check_sanity)
+        with pytest.raises(SanityError):
+            self.test.check_sanity()
 
     def test_sanity_failure_noassert(self):
         self.test.sanity_patterns = sn.findall(r'result = success',
                                                self.output_file.name)
         self.output_file.write('result = failure\n')
         self.output_file.close()
-        self.assertRaises(SanityError, self.test.check_sanity)
+        with pytest.raises(SanityError):
+            self.test.check_sanity()
 
     def test_sanity_multiple_patterns(self):
         self.output_file.write('result1 = success\n')
@@ -798,7 +799,8 @@ def test_sanity_multiple_patterns(self):
         self.test.sanity_patterns = sn.assert_eq(
             sn.count(sn.findall(r'result\d = success', self.output_file.name)),
             3)
-        self.assertRaises(SanityError, self.test.check_sanity)
+        with pytest.raises(SanityError):
+            self.test.check_sanity()
 
     def test_sanity_multiple_files(self):
         files = [tempfile.NamedTemporaryFile(mode='wt', prefix='regtmp',
@@ -825,7 +827,8 @@ def test_performance_failure(self):
         self.output_file.write('result = success\n')
         self.output_file.close()
         self.test.check_sanity()
-        self.assertRaises(PerformanceError, self.test.check_performance)
+        with pytest.raises(PerformanceError):
+            self.test.check_performance()
 
     def test_unknown_tag(self):
         self.test.reference = {
@@ -839,7 +842,8 @@ def test_unknown_tag(self):
         self.write_performance_output(performance1=1.3,
                                       performance2=1.8,
                                       performance3=3.3)
-        self.assertRaises(SanityError, self.test.check_performance)
+        with pytest.raises(SanityError):
+            self.test.check_performance()
 
     def test_unknown_system(self):
         self.write_performance_output(performance1=1.3,
@@ -917,16 +921,16 @@ def extract_perf(patt, tag):
         self.write_performance_output(performance1=1.0,
                                       performance2=1.8,
                                       performance3=3.3)
-        with self.assertRaises(PerformanceError) as cm:
+        with pytest.raises(PerformanceError) as cm:
             self.test.check_performance()
 
         logfile = os.path.join(self.test.stagedir, logfile)
         with open(logfile) as fp:
             log_output = fp.read()
 
-        self.assertIn('v1', log_output)
-        self.assertIn('v2', log_output)
-        self.assertIn('v3', log_output)
+        assert 'v1' in log_output
+        assert 'v2' in log_output
+        assert 'v3' in log_output
 
 
 class TestRegressionTestWithContainer(unittest.TestCase):
diff --git a/unittests/test_policies.py b/unittests/test_policies.py
index 0d84024a02..6e417c5f7b 100644
--- a/unittests/test_policies.py
+++ b/unittests/test_policies.py
@@ -80,82 +80,82 @@ def assert_all_dead(self):
             except JobNotStartedError:
                 finished = True
 
-            self.assertTrue(finished)
+            assert finished
 
     def test_runall(self):
         self.runall(self.checks)
 
         stats = self.runner.stats
-        self.assertEqual(8, stats.num_cases())
+        assert 8 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(5, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(1, self._num_failures_stage('sanity'))
-        self.assertEqual(1, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 5 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 1 == self._num_failures_stage('sanity')
+        assert 1 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_runall_skip_system_check(self):
         self.runall(self.checks, skip_system_check=True)
 
         stats = self.runner.stats
-        self.assertEqual(9, stats.num_cases())
+        assert 9 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(5, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(1, self._num_failures_stage('sanity'))
-        self.assertEqual(1, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 5 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 1 == self._num_failures_stage('sanity')
+        assert 1 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_runall_skip_prgenv_check(self):
         self.runall(self.checks, skip_environ_check=True)
 
         stats = self.runner.stats
-        self.assertEqual(9, stats.num_cases())
+        assert 9 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(5, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(1, self._num_failures_stage('sanity'))
-        self.assertEqual(1, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 5 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 1 == self._num_failures_stage('sanity')
+        assert 1 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_runall_skip_sanity_check(self):
         self.runner.policy.skip_sanity_check = True
         self.runall(self.checks)
 
         stats = self.runner.stats
-        self.assertEqual(8, stats.num_cases())
+        assert 8 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(4, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(0, self._num_failures_stage('sanity'))
-        self.assertEqual(1, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 4 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 0 == self._num_failures_stage('sanity')
+        assert 1 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_runall_skip_performance_check(self):
         self.runner.policy.skip_performance_check = True
         self.runall(self.checks)
 
         stats = self.runner.stats
-        self.assertEqual(8, stats.num_cases())
+        assert 8 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(4, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(1, self._num_failures_stage('sanity'))
-        self.assertEqual(0, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 4 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 1 == self._num_failures_stage('sanity')
+        assert 0 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_strict_performance_check(self):
         self.runner.policy.strict_check = True
         self.runall(self.checks)
 
         stats = self.runner.stats
-        self.assertEqual(8, stats.num_cases())
+        assert 8 == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(6, len(stats.failures()))
-        self.assertEqual(2, self._num_failures_stage('setup'))
-        self.assertEqual(1, self._num_failures_stage('sanity'))
-        self.assertEqual(2, self._num_failures_stage('performance'))
-        self.assertEqual(1, self._num_failures_stage('cleanup'))
+        assert 6 == len(stats.failures())
+        assert 2 == self._num_failures_stage('setup')
+        assert 1 == self._num_failures_stage('sanity')
+        assert 2 == self._num_failures_stage('performance')
+        assert 1 == self._num_failures_stage('cleanup')
 
     def test_force_local_execution(self):
         self.runner.policy.force_local = True
@@ -163,13 +163,15 @@ def test_force_local_execution(self):
         self.assertRunall()
         stats = self.runner.stats
         for t in stats.tasks():
-            self.assertTrue(t.check.local)
+            assert t.check.local
 
     def test_kbd_interrupt_within_test(self):
         check = KeyboardInterruptCheck()
-        self.assertRaises(KeyboardInterrupt, self.runall, [check])
+        with pytest.raises(KeyboardInterrupt):
+            self.runall([check])
+
         stats = self.runner.stats
-        self.assertEqual(1, len(stats.failures()))
+        assert 1 == len(stats.failures())
         self.assert_all_dead()
 
     def test_system_exit_within_test(self):
@@ -178,7 +180,7 @@ def test_system_exit_within_test(self):
         # This should not raise and should not exit
         self.runall([check])
         stats = self.runner.stats
-        self.assertEqual(1, len(stats.failures()))
+        assert 1 == len(stats.failures())
 
     def test_retries_bad_check(self):
         max_retries = 2
@@ -187,10 +189,10 @@ def test_retries_bad_check(self):
         self.runall(checks)
 
         # Ensure that the test was retried #max_retries times and failed.
-        self.assertEqual(2, self.runner.stats.num_cases())
+        assert 2 == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(max_retries, rt.runtime().current_run)
-        self.assertEqual(2, len(self.runner.stats.failures()))
+        assert max_retries == rt.runtime().current_run
+        assert 2 == len(self.runner.stats.failures())
 
         # Ensure that the report does not raise any exception.
         self.runner.stats.retry_report()
@@ -202,10 +204,10 @@ def test_retries_good_check(self):
         self.runall(checks)
 
         # Ensure that the test passed without retries.
-        self.assertEqual(1, self.runner.stats.num_cases())
+        assert 1 == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(0, rt.runtime().current_run)
-        self.assertEqual(0, len(self.runner.stats.failures()))
+        assert 0 == rt.runtime().current_run
+        assert 0 == len(self.runner.stats.failures())
 
     def test_pass_in_retries(self):
         max_retries = 3
@@ -220,11 +222,11 @@ def test_pass_in_retries(self):
         self.runall(checks)
 
         # Ensure that the test passed after retries in run #run_to_pass.
-        self.assertEqual(1, self.runner.stats.num_cases())
+        assert 1 == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(1, len(self.runner.stats.failures(run=0)))
-        self.assertEqual(run_to_pass, rt.runtime().current_run)
-        self.assertEqual(0, len(self.runner.stats.failures()))
+        assert 1 == len(self.runner.stats.failures(run=0))
+        assert run_to_pass == rt.runtime().current_run
+        assert 0 == len(self.runner.stats.failures())
         os.remove(fp.name)
 
     def test_dependencies(self):
@@ -335,13 +337,13 @@ def test_concurrency_unlimited(self):
         self.runall(checks)
 
         # Ensure that all tests were run and without failures.
-        self.assertEqual(len(checks), self.runner.stats.num_cases())
+        assert len(checks) == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(0, len(self.runner.stats.failures()))
+        assert 0 == len(self.runner.stats.failures())
 
         # Ensure that maximum concurrency was reached as fast as possible
-        self.assertEqual(len(checks), max(self.monitor.num_tasks))
-        self.assertEqual(len(checks), self.monitor.num_tasks[len(checks)])
+        assert len(checks) == max(self.monitor.num_tasks)
+        assert len(checks) == self.monitor.num_tasks[len(checks)]
 
         self.read_timestamps(self.monitor.tasks)
 
@@ -351,7 +353,7 @@ def test_concurrency_unlimited(self):
         #     self.assertTrue(self.begin_stamps[-1] <= self.end_stamps[0])
         #
         if self.begin_stamps[-1] > self.end_stamps[0]:
-            self.skipTest('the system seems too much loaded.')
+            pytest.skip('the system seems too much loaded.')
 
     def test_concurrency_limited(self):
         # The number of checks must be <= 2*max_jobs.
@@ -361,13 +363,13 @@ def test_concurrency_limited(self):
         self.runall(checks)
 
         # Ensure that all tests were run and without failures.
-        self.assertEqual(len(checks), self.runner.stats.num_cases())
+        assert len(checks) == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(0, len(self.runner.stats.failures()))
+        assert 0 == len(self.runner.stats.failures())
 
         # Ensure that maximum concurrency was reached as fast as possible
-        self.assertEqual(max_jobs, max(self.monitor.num_tasks))
-        self.assertEqual(max_jobs, self.monitor.num_tasks[max_jobs])
+        assert max_jobs == max(self.monitor.num_tasks)
+        assert max_jobs == self.monitor.num_tasks[max_jobs]
 
         self.read_timestamps(self.monitor.tasks)
 
@@ -377,7 +379,7 @@ def test_concurrency_limited(self):
         # Note: we may ensure this strictly as we may ensure serial behaviour.
         begin_after_end = (b > e for b, e in zip(self.begin_stamps[max_jobs:],
                                                  self.end_stamps[:-max_jobs]))
-        self.assertTrue(all(begin_after_end))
+        assert all(begin_after_end)
 
         # NOTE: to ensure that these remaining jobs were also run
         # in parallel one could do the command hereafter; however, it would
@@ -391,7 +393,7 @@ def test_concurrency_limited(self):
         # corresponding strict check would be:
         # self.assertTrue(self.begin_stamps[max_jobs-1] <= self.end_stamps[0])
         if self.begin_stamps[max_jobs-1] > self.end_stamps[0]:
-            self.skipTest('the system seems too loaded.')
+            pytest.skip('the system seems too loaded.')
 
     def test_concurrency_none(self):
         checks = [SleepCheck(0.5) for i in range(3)]
@@ -400,12 +402,12 @@ def test_concurrency_none(self):
         self.runall(checks)
 
         # Ensure that all tests were run and without failures.
-        self.assertEqual(len(checks), self.runner.stats.num_cases())
+        assert len(checks) == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(0, len(self.runner.stats.failures()))
+        assert 0 == len(self.runner.stats.failures())
 
         # Ensure that a single task was running all the time
-        self.assertEqual(1, max(self.monitor.num_tasks))
+        assert 1 == max(self.monitor.num_tasks)
 
         # Read the timestamps sorted to permit simple concurrency tests.
         self.read_timestamps(self.monitor.tasks)
@@ -414,15 +416,16 @@ def test_concurrency_none(self):
         # (e.g. begin[1] > end[0]).
         begin_after_end = (b > e for b, e in zip(self.begin_stamps[1:],
                                                  self.end_stamps[:-1]))
-        self.assertTrue(all(begin_after_end))
+        assert all(begin_after_end)
 
     def _run_checks(self, checks, max_jobs):
         self.set_max_jobs(max_jobs)
-        self.assertRaises(KeyboardInterrupt, self.runall, checks)
+        with pytest.raises(KeyboardInterrupt):
+            self.runall(checks)
 
-        self.assertEqual(4, self.runner.stats.num_cases())
+        assert 4 == self.runner.stats.num_cases()
         self.assertRunall()
-        self.assertEqual(4, len(self.runner.stats.failures()))
+        assert 4 == len(self.runner.stats.failures())
         self.assert_all_dead()
 
     def test_kbd_interrupt_in_wait_with_concurrency(self):
@@ -457,9 +460,9 @@ def test_poll_fails_main_loop(self):
         self.set_max_jobs(1)
         self.runall(checks)
         stats = self.runner.stats
-        self.assertEqual(num_tasks, stats.num_cases())
+        assert num_tasks == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(num_tasks, len(stats.failures()))
+        assert num_tasks == len(stats.failures())
 
     def test_poll_fails_busy_loop(self):
         num_tasks = 3
@@ -468,9 +471,9 @@ def test_poll_fails_busy_loop(self):
         self.set_max_jobs(1)
         self.runall(checks)
         stats = self.runner.stats
-        self.assertEqual(num_tasks, stats.num_cases())
+        assert num_tasks == stats.num_cases()
         self.assertRunall()
-        self.assertEqual(num_tasks, len(stats.failures()))
+        assert num_tasks == len(stats.failures())
 
 
 class TestDependencies(unittest.TestCase):
diff --git a/unittests/test_runtime.py b/unittests/test_runtime.py
index 2d072d753d..961efa3bc2 100644
--- a/unittests/test_runtime.py
+++ b/unittests/test_runtime.py
@@ -13,14 +13,14 @@ class TestRuntime(unittest.TestCase):
     @rt.switch_runtime(fixtures.TEST_SITE_CONFIG, 'testsys')
     def test_hostsystem_api(self):
         system = rt.runtime().system
-        self.assertEqual('testsys', system.name)
-        self.assertEqual('Fake system for unit tests', system.descr)
-        self.assertEqual(2, len(system.partitions))
-        self.assertIsNotNone(system.partition('login'))
-        self.assertIsNotNone(system.partition('gpu'))
-        self.assertIsNone(system.partition('foobar'))
+        assert 'testsys' == system.name
+        assert 'Fake system for unit tests' == system.descr
+        assert 2 == len(system.partitions)
+        assert system.partition('login') is not None
+        assert system.partition('gpu') is not None
+        assert system.partition('foobar') is None
 
         # Test delegation to the underlying System
-        self.assertEqual('.rfm_testing', system.prefix)
-        self.assertEqual('.rfm_testing/resources', system.resourcesdir)
-        self.assertEqual('.rfm_testing/perflogs', system.perflogdir)
+        assert '.rfm_testing' == system.prefix
+        assert '.rfm_testing/resources' == system.resourcesdir
+        assert '.rfm_testing/perflogs' == system.perflogdir
diff --git a/unittests/test_sanity_functions.py b/unittests/test_sanity_functions.py
index 4a8db714e4..76e3d65bfc 100644
--- a/unittests/test_sanity_functions.py
+++ b/unittests/test_sanity_functions.py
@@ -7,6 +7,7 @@
 import io
 import itertools
 import os
+import pytest
 import sys
 import unittest
 
@@ -38,101 +39,101 @@ def b(self):
         return sn.getattr(self, '_b')
 
     def test_abs(self):
-        self.assertEqual(1.0, sn.abs(1.0))
-        self.assertEqual(0.0, sn.abs(0.0))
-        self.assertEqual(1.0, sn.abs(-1.0))
-        self.assertEqual(2.0, sn.abs(sn.defer(-2.0)))
+        assert 1.0 == sn.abs(1.0)
+        assert 0.0 == sn.abs(0.0)
+        assert 1.0 == sn.abs(-1.0)
+        assert 2.0 == sn.abs(sn.defer(-2.0))
 
     def test_and(self):
         expr = sn.and_(self.a, self.b)
         self._a = 1
         self._b = 1
 
-        self.assertTrue(expr)
-        self.assertFalse(sn.not_(expr))
+        assert expr
+        assert not sn.not_(expr)
 
     def test_or(self):
         expr = sn.or_(self.a, self.b)
         self._a = 0
         self._b = 0
-        self.assertFalse(expr)
-        self.assertTrue(sn.not_(expr))
+        assert not expr
+        assert sn.not_(expr)
 
     def test_all(self):
         l = [1, 1, 0]
         expr = sn.all(l)
         l[2] = 1
-        self.assertTrue(expr)
+        assert expr
 
     def test_allx(self):
-        self.assertTrue(sn.allx([1, 1, 1]))
-        self.assertFalse(sn.allx([1, 0]))
-        self.assertFalse(sn.allx([]))
-        self.assertFalse(sn.allx(i for i in range(0)))
-        self.assertTrue(sn.allx(i for i in range(1, 2)))
-        with self.assertRaises(TypeError):
+        assert sn.allx([1, 1, 1])
+        assert not sn.allx([1, 0])
+        assert not sn.allx([])
+        assert not sn.allx(i for i in range(0))
+        assert sn.allx(i for i in range(1, 2))
+        with pytest.raises(TypeError):
             sn.evaluate(sn.allx(None))
 
     def test_any(self):
         l = [0, 0, 1]
         expr = sn.any(l)
         l[2] = 0
-        self.assertFalse(expr)
+        assert not expr
 
     def test_enumerate(self):
         de = sn.enumerate(sn.defer([1, 2]), start=1)
         for i, e in de:
-            self.assertEqual(i, e)
+            assert i == e
 
     def test_filter(self):
         df = sn.filter(lambda x: x if x % 2 else None,
                        sn.defer([1, 2, 3, 4, 5]))
 
         for i, x in sn.enumerate(df, start=1):
-            self.assertEqual(2*i - 1, x)
+            assert 2*i - 1 == x
 
         # Alternative testing
-        self.assertEqual([1, 3, 5], list(sn.evaluate(df)))
+        assert [1, 3, 5] == list(sn.evaluate(df))
 
     def test_hasattr(self):
         e = sn.hasattr(self, '_c')
-        self.assertFalse(e)
+        assert not e
 
         self._c = 1
-        self.assertTrue(e)
+        assert e
 
     def test_len(self):
         l = [1, 2]
         dl = sn.defer(l)
-        self.assertEqual(2, sn.len(dl))
+        assert 2 == sn.len(dl)
 
         l.append(3)
-        self.assertEqual(3, sn.len(dl))
+        assert 3 == sn.len(dl)
 
     def test_map(self):
         l = [1, 2, 3]
         dm = sn.map(lambda x: 2*x + 1, l)
         for i, x in sn.enumerate(dm, start=1):
-            self.assertEqual(2*i + 1, x)
+            assert 2*i + 1 == x
 
         # Alternative test
-        self.assertEqual([3, 5, 7], list(sn.evaluate(dm)))
+        assert [3, 5, 7] == list(sn.evaluate(dm))
 
     def test_max(self):
         l = [1, 2]
         dl = sn.defer(l)
-        self.assertEqual(2, sn.max(dl))
+        assert 2 == sn.max(dl)
 
         l.append(3)
-        self.assertEqual(3, sn.max(dl))
+        assert 3 == sn.max(dl)
 
     def test_min(self):
         l = [1, 2]
         dl = sn.defer(l)
-        self.assertEqual(1, sn.min(dl))
+        assert 1 == sn.min(dl)
 
         l.append(0)
-        self.assertEqual(0, sn.min(dl))
+        assert 0 == sn.min(dl)
 
     def test_print_stdout(self):
         stdout = io.StringIO()
@@ -173,25 +174,25 @@ def test_print_end(self):
     def test_reversed(self):
         l = [1, 2, 3]
         dr = sn.reversed(l)
-        self.assertEqual([3, 2, 1], list(sn.evaluate(dr)))
+        assert [3, 2, 1] == list(sn.evaluate(dr))
 
     def test_round(self):
-        self.assertEqual(1.0, sn.round(sn.defer(1.4)))
+        assert 1.0 == sn.round(sn.defer(1.4))
 
     def test_setattr(self):
         dset = sn.setattr(self, '_a', 5)
-        self.assertEqual(0, self._a)
+        assert 0 == self._a
         sn.evaluate(dset)
-        self.assertEqual(5, self._a)
+        assert 5 == self._a
 
     def test_sorted(self):
         l = [2, 3, 1]
         ds = sn.sorted(l)
-        self.assertEqual([1, 2, 3], list(sn.evaluate(ds)))
+        assert [1, 2, 3] == list(sn.evaluate(ds))
 
     def test_sum(self):
-        self.assertEqual(3, sn.sum([1, 1, 1]))
-        self.assertEqual(3, sn.sum(sn.defer([1, 1, 1])))
+        assert 3 == sn.sum([1, 1, 1])
+        assert 3 == sn.sum(sn.defer([1, 1, 1]))
 
     def test_zip(self):
         la = [1, 2, 3]
@@ -203,8 +204,8 @@ def test_zip(self):
             la_new.append(a)
             lb_new.append(b)
 
-        self.assertEqual([1, 2, 3], la_new)
-        self.assertEqual(['a', 'b', 'c'], lb_new)
+        assert [1, 2, 3] == la_new
+        assert ['a', 'b', 'c'] == lb_new
 
 
 class TestAsserts(unittest.TestCase):
@@ -213,247 +214,254 @@ def setUp(self):
                                        'src', 'homer.txt')
 
     def test_assert_true(self):
-        self.assertTrue(sn.assert_true(True))
-        self.assertTrue(sn.assert_true(1))
-        self.assertTrue(sn.assert_true([1]))
-        self.assertTrue(sn.assert_true(range(1)))
-        self.assertRaisesRegex(SanityError, 'False is not True',
-                               sn.evaluate, sn.assert_true(False))
-        self.assertRaisesRegex(SanityError, '0 is not True',
-                               sn.evaluate, sn.assert_true(0))
-        self.assertRaisesRegex(SanityError, r'\[\] is not True',
-                               sn.evaluate, sn.assert_true([]))
-        self.assertRaisesRegex(SanityError, r'range\(.+\) is not True',
-                               sn.evaluate, sn.assert_true(range(0)))
-        self.assertRaisesRegex(SanityError, 'not true',
-                               sn.evaluate, sn.assert_true(0, msg='not true'))
+        assert sn.assert_true(True)
+        assert sn.assert_true(1)
+        assert sn.assert_true([1])
+        assert sn.assert_true(range(1))
+        with pytest.raises(SanityError, match='False is not True'):
+            sn.evaluate(sn.assert_true(False))
+
+        with pytest.raises(SanityError, match='0 is not True'):
+            sn.evaluate(sn.assert_true(0))
+
+        with pytest.raises(SanityError, match=r'\[\] is not True'):
+            sn.evaluate(sn.assert_true([]))
+
+        with pytest.raises(SanityError, match=r'range\(.+\) is not True'):
+            sn.evaluate(sn.assert_true(range(0)))
+
+        with pytest.raises(SanityError, match='not true'):
+            sn.evaluate(sn.assert_true(0, msg='not true'))
 
     def test_assert_true_with_deferrables(self):
-        self.assertTrue(sn.assert_true(sn.defer(True)))
-        self.assertTrue(sn.assert_true(sn.defer(1)))
-        self.assertTrue(sn.assert_true(sn.defer([1])))
-        self.assertRaisesRegex(SanityError, 'False is not True',
-                               sn.evaluate, sn.assert_true(sn.defer(False)))
-        self.assertRaisesRegex(SanityError, '0 is not True',
-                               sn.evaluate, sn.assert_true(sn.defer(0)))
-        self.assertRaisesRegex(SanityError, r'\[\] is not True',
-                               sn.evaluate, sn.assert_true(sn.defer([])))
+        assert sn.assert_true(sn.defer(True))
+        assert sn.assert_true(sn.defer(1))
+        assert sn.assert_true(sn.defer([1]))
+        with pytest.raises(SanityError, match='False is not True'):
+            sn.evaluate(sn.assert_true(sn.defer(False)))
+
+        with pytest.raises(SanityError, match='0 is not True'):
+            sn.evaluate(sn.assert_true(sn.defer(0)))
+
+        with pytest.raises(SanityError, match=r'\[\] is not True'):
+            sn.evaluate(sn.assert_true(sn.defer([])))
 
     def test_assert_false(self):
-        self.assertTrue(sn.assert_false(False))
-        self.assertTrue(sn.assert_false(0))
-        self.assertTrue(sn.assert_false([]))
-        self.assertTrue(sn.assert_false(range(0)))
-        self.assertRaisesRegex(SanityError, 'True is not False',
-                               sn.evaluate, sn.assert_false(True))
-        self.assertRaisesRegex(SanityError, '1 is not False',
-                               sn.evaluate, sn.assert_false(1))
-        self.assertRaisesRegex(SanityError, r'\[1\] is not False',
-                               sn.evaluate, sn.assert_false([1]))
-        self.assertRaisesRegex(SanityError, r'range\(.+\) is not False',
-                               sn.evaluate, sn.assert_false(range(1)))
+        assert sn.assert_false(False)
+        assert sn.assert_false(0)
+        assert sn.assert_false([])
+        assert sn.assert_false(range(0))
+        with pytest.raises(SanityError, match='True is not False'):
+            sn.evaluate(sn.assert_false(True))
+
+        with pytest.raises(SanityError, match='1 is not False'):
+            sn.evaluate(sn.assert_false(1))
+
+        with pytest.raises(SanityError, match=r'\[1\] is not False'):
+            sn.evaluate(sn.assert_false([1]))
+
+        with pytest.raises(SanityError, match=r'range\(.+\) is not False'):
+            sn.evaluate(sn.assert_false(range(1)))
 
     def test_assert_false_with_deferrables(self):
-        self.assertTrue(sn.assert_false(sn.defer(False)))
-        self.assertTrue(sn.assert_false(sn.defer(0)))
-        self.assertTrue(sn.assert_false(sn.defer([])))
-        self.assertRaisesRegex(SanityError, 'True is not False',
-                               sn.evaluate, sn.assert_false(sn.defer(True)))
-        self.assertRaisesRegex(SanityError, '1 is not False',
-                               sn.evaluate, sn.assert_false(sn.defer(1)))
-        self.assertRaisesRegex(SanityError, r'\[1\] is not False',
-                               sn.evaluate, sn.assert_false(sn.defer([1])))
+        assert sn.assert_false(sn.defer(False))
+        assert sn.assert_false(sn.defer(0))
+        assert sn.assert_false(sn.defer([]))
+        with pytest.raises(SanityError, match='True is not False'):
+            sn.evaluate(sn.assert_false(sn.defer(True)))
+
+        with pytest.raises(SanityError, match='1 is not False'):
+            sn.evaluate(sn.assert_false(sn.defer(1)))
+
+        with pytest.raises(SanityError, match=r'\[1\] is not False'):
+            sn.evaluate(sn.assert_false(sn.defer([1])))
 
     def test_assert_eq(self):
-        self.assertTrue(sn.assert_eq(1, 1))
-        self.assertTrue(sn.assert_eq(1, True))
-        self.assertRaisesRegex(SanityError, '1 != 2',
-                               sn.evaluate, sn.assert_eq(1, 2))
-        self.assertRaisesRegex(SanityError, '1 != False',
-                               sn.evaluate, sn.assert_eq(1, False))
-        self.assertRaisesRegex(
-            SanityError, '1 is not equals to 2',
-            sn.evaluate, sn.assert_eq(1, 2, '{0} is not equals to {1}'))
+        assert sn.assert_eq(1, 1)
+        assert sn.assert_eq(1, True)
+        with pytest.raises(SanityError, match='1 != 2'):
+            sn.evaluate(sn.assert_eq(1, 2))
+
+        with pytest.raises(SanityError, match='1 != False'):
+            sn.evaluate(sn.assert_eq(1, False))
+
+        with pytest.raises(SanityError, match='1 is not equals to 2'):
+            sn.evaluate(sn.assert_eq(1, 2, '{0} is not equals to {1}'))
 
     def test_assert_eq_with_deferrables(self):
-        self.assertTrue(sn.assert_eq(1, sn.defer(1)))
-        self.assertTrue(sn.assert_eq(sn.defer(1), True))
-        self.assertRaisesRegex(SanityError, '1 != 2',
-                               sn.evaluate, sn.assert_eq(sn.defer(1), 2))
-        self.assertRaisesRegex(SanityError, '1 != False',
-                               sn.evaluate, sn.assert_eq(sn.defer(1), False))
+        assert sn.assert_eq(1, sn.defer(1))
+        assert sn.assert_eq(sn.defer(1), True)
+        with pytest.raises(SanityError, match='1 != 2'):
+            sn.evaluate(sn.assert_eq(sn.defer(1), 2))
+
+        with pytest.raises(SanityError, match='1 != False'):
+            sn.evaluate(sn.assert_eq(sn.defer(1), False))
 
     def test_assert_ne(self):
-        self.assertTrue(sn.assert_ne(1, 2))
-        self.assertTrue(sn.assert_ne(1, False))
-        self.assertRaisesRegex(SanityError, '1 == 1',
-                               sn.evaluate, sn.assert_ne(1, 1))
-        self.assertRaisesRegex(SanityError, '1 == True',
-                               sn.evaluate, sn.assert_ne(1, True))
+        assert sn.assert_ne(1, 2)
+        assert sn.assert_ne(1, False)
+        with pytest.raises(SanityError, match='1 == 1'):
+            sn.evaluate(sn.assert_ne(1, 1))
+
+        with pytest.raises(SanityError, match='1 == True'):
+            sn.evaluate(sn.assert_ne(1, True))
 
     def test_assert_ne_with_deferrables(self):
-        self.assertTrue(sn.assert_ne(1, sn.defer(2)))
-        self.assertTrue(sn.assert_ne(sn.defer(1), False))
-        self.assertRaisesRegex(SanityError, '1 == 1',
-                               sn.evaluate, sn.assert_ne(sn.defer(1), 1))
-        self.assertRaisesRegex(SanityError, '1 == True',
-                               sn.evaluate, sn.assert_ne(sn.defer(1), True))
+        assert sn.assert_ne(1, sn.defer(2))
+        assert sn.assert_ne(sn.defer(1), False)
+        with pytest.raises(SanityError, match='1 == 1'):
+            sn.evaluate(sn.assert_ne(sn.defer(1), 1))
+
+        with pytest.raises(SanityError, match='1 == True'):
+            sn.evaluate(sn.assert_ne(sn.defer(1), True))
 
     def test_assert_gt(self):
-        self.assertTrue(sn.assert_gt(3, 1))
-        self.assertRaisesRegex(SanityError, '1 <= 3',
-                               sn.evaluate, sn.assert_gt(1, 3))
+        assert sn.assert_gt(3, 1)
+        with pytest.raises(SanityError, match='1 <= 3'):
+            sn.evaluate(sn.assert_gt(1, 3))
 
     def test_assert_gt_with_deferrables(self):
-        self.assertTrue(sn.assert_gt(3, sn.defer(1)))
-        self.assertRaisesRegex(SanityError, '1 <= 3',
-                               sn.evaluate, sn.assert_gt(1, sn.defer(3)))
+        assert sn.assert_gt(3, sn.defer(1))
+        with pytest.raises(SanityError, match='1 <= 3'):
+            sn.evaluate(sn.assert_gt(1, sn.defer(3)))
 
     def test_assert_ge(self):
-        self.assertTrue(sn.assert_ge(3, 1))
-        self.assertTrue(sn.assert_ge(3, 3))
-        self.assertRaisesRegex(SanityError, '1 < 3',
-                               sn.evaluate, sn.assert_ge(1, 3))
+        assert sn.assert_ge(3, 1)
+        assert sn.assert_ge(3, 3)
+        with pytest.raises(SanityError, match='1 < 3'):
+            sn.evaluate(sn.assert_ge(1, 3))
 
     def test_assert_ge_with_deferrables(self):
-        self.assertTrue(sn.assert_ge(3, sn.defer(1)))
-        self.assertTrue(sn.assert_ge(3, sn.defer(3)))
-        self.assertRaisesRegex(SanityError, '1 < 3',
-                               sn.evaluate, sn.assert_ge(1, sn.defer(3)))
+        assert sn.assert_ge(3, sn.defer(1))
+        assert sn.assert_ge(3, sn.defer(3))
+        with pytest.raises(SanityError, match='1 < 3'):
+            sn.evaluate(sn.assert_ge(1, sn.defer(3)))
 
     def test_assert_lt(self):
-        self.assertTrue(sn.assert_lt(1, 3))
-        self.assertRaisesRegex(SanityError, '3 >= 1',
-                               sn.evaluate, sn.assert_lt(3, 1))
+        assert sn.assert_lt(1, 3)
+        with pytest.raises(SanityError, match='3 >= 1'):
+            sn.evaluate(sn.assert_lt(3, 1))
 
     def test_assert_lt_with_deferrables(self):
-        self.assertTrue(sn.assert_lt(1, sn.defer(3)))
-        self.assertRaisesRegex(SanityError, '3 >= 1',
-                               sn.evaluate, sn.assert_lt(3, sn.defer(1)))
+        assert sn.assert_lt(1, sn.defer(3))
+        with pytest.raises(SanityError, match='3 >= 1'):
+            sn.evaluate(sn.assert_lt(3, sn.defer(1)))
 
     def test_assert_le(self):
-        self.assertTrue(sn.assert_le(1, 1))
-        self.assertTrue(sn.assert_le(3, 3))
-        self.assertRaisesRegex(SanityError, '3 > 1',
-                               sn.evaluate, sn.assert_le(3, 1))
+        assert sn.assert_le(1, 1)
+        assert sn.assert_le(3, 3)
+        with pytest.raises(SanityError, match='3 > 1'):
+            sn.evaluate(sn.assert_le(3, 1))
 
     def test_assert_le_with_deferrables(self):
-        self.assertTrue(sn.assert_le(1, sn.defer(3)))
-        self.assertTrue(sn.assert_le(3, sn.defer(3)))
-        self.assertRaisesRegex(SanityError, '3 > 1',
-                               sn.evaluate, sn.assert_le(3, sn.defer(1)))
+        assert sn.assert_le(1, sn.defer(3))
+        assert sn.assert_le(3, sn.defer(3))
+        with pytest.raises(SanityError, match='3 > 1'):
+            sn.evaluate(sn.assert_le(3, sn.defer(1)))
 
     def test_assert_in(self):
-        self.assertTrue(sn.assert_in(1, [1, 2, 3]))
-        self.assertRaisesRegex(SanityError, r'0 is not in \[1, 2, 3\]',
-                               sn.evaluate, sn.assert_in(0, [1, 2, 3]))
+        assert sn.assert_in(1, [1, 2, 3])
+        with pytest.raises(SanityError, match=r'0 is not in \[1, 2, 3\]'):
+            sn.evaluate(sn.assert_in(0, [1, 2, 3]))
 
     def test_assert_in_with_deferrables(self):
-        self.assertTrue(sn.assert_in(1, sn.defer([1, 2, 3])))
-        self.assertRaisesRegex(
-            SanityError, r'0 is not in \[1, 2, 3\]',
-            sn.evaluate, sn.assert_in(0, sn.defer([1, 2, 3])))
+        assert sn.assert_in(1, sn.defer([1, 2, 3]))
+        with pytest.raises(SanityError, match=r'0 is not in \[1, 2, 3\]'):
+            sn.evaluate(sn.assert_in(0, sn.defer([1, 2, 3])))
 
     def test_assert_not_in(self):
-        self.assertTrue(sn.assert_not_in(0, [1, 2, 3]))
-        self.assertRaisesRegex(SanityError, r'1 is in \[1, 2, 3\]',
-                               sn.evaluate, sn.assert_not_in(1, [1, 2, 3]))
+        assert sn.assert_not_in(0, [1, 2, 3])
+        with pytest.raises(SanityError, match=r'1 is in \[1, 2, 3\]'):
+            sn.evaluate(sn.assert_not_in(1, [1, 2, 3]))
 
     def test_assert_not_in_with_deferrables(self):
-        self.assertTrue(sn.assert_not_in(0, sn.defer([1, 2, 3])))
-        self.assertRaisesRegex(
-            SanityError, r'1 is in \[1, 2, 3\]',
-            sn.evaluate, sn.assert_not_in(1, sn.defer([1, 2, 3])))
+        assert sn.assert_not_in(0, sn.defer([1, 2, 3]))
+        with pytest.raises(SanityError, match=r'1 is in \[1, 2, 3\]'):
+            sn.evaluate(sn.assert_not_in(1, sn.defer([1, 2, 3])))
 
     def test_assert_bounded(self):
-        self.assertTrue(sn.assert_bounded(1, -1.5, 1.5))
-        self.assertTrue(sn.assert_bounded(1, upper=1.5))
-        self.assertTrue(sn.assert_bounded(1, lower=-1.5))
-        self.assertTrue(sn.assert_bounded(1))
-        self.assertRaisesRegex(SanityError,
-                               r'value 1 not within bounds -0\.5\.\.0\.5',
-                               sn.evaluate, sn.assert_bounded(1, -0.5, 0.5))
-        self.assertRaisesRegex(SanityError,
-                               r'value 1 not within bounds -inf\.\.0\.5',
-                               sn.evaluate, sn.assert_bounded(1, upper=0.5))
-        self.assertRaisesRegex(SanityError,
-                               r'value 1 not within bounds 1\.5\.\.inf',
-                               sn.evaluate, sn.assert_bounded(1, lower=1.5))
-        self.assertRaisesRegex(
-            SanityError, 'value 1 is out of bounds', sn.evaluate,
-            sn.assert_bounded(1, -0.5, 0.5, 'value {0} is out of bounds'))
+        assert sn.assert_bounded(1, -1.5, 1.5)
+        assert sn.assert_bounded(1, upper=1.5)
+        assert sn.assert_bounded(1, lower=-1.5)
+        assert sn.assert_bounded(1)
+        with pytest.raises(SanityError,
+                           match=r'value 1 not within bounds -0\.5\.\.0\.5'):
+            sn.evaluate(sn.assert_bounded(1, -0.5, 0.5))
+
+        with pytest.raises(SanityError,
+                           match=r'value 1 not within bounds -inf\.\.0\.5'):
+            sn.evaluate(sn.assert_bounded(1, upper=0.5))
+
+        with pytest.raises(SanityError,
+                           match=r'value 1 not within bounds 1\.5\.\.inf'):
+            sn.evaluate(sn.assert_bounded(1, lower=1.5))
+
+        with pytest.raises(SanityError, match='value 1 is out of bounds'):
+            sn.evaluate(sn.assert_bounded(
+                1, -0.5, 0.5, 'value {0} is out of bounds'))
 
     def test_assert_reference(self):
-        self.assertTrue(sn.assert_reference(0.9, 1, -0.2, 0.1))
-        self.assertTrue(sn.assert_reference(0.9, 1, upper_thres=0.1))
-        self.assertTrue(sn.assert_reference(0.9, 1, lower_thres=-0.2))
-        self.assertTrue(sn.assert_reference(0.9, 1))
+        assert sn.assert_reference(0.9, 1, -0.2, 0.1)
+        assert sn.assert_reference(0.9, 1, upper_thres=0.1)
+        assert sn.assert_reference(0.9, 1, lower_thres=-0.2)
+        assert sn.assert_reference(0.9, 1)
 
         # Check negatives
-        self.assertTrue(sn.assert_reference(-0.9, -1, -0.2, 0.1))
-        self.assertTrue(sn.assert_reference(-0.9, -1, -0.2))
-        self.assertTrue(sn.assert_reference(-0.9, -1, upper_thres=0.1))
-        self.assertTrue(sn.assert_reference(-0.9, -1))
+        assert sn.assert_reference(-0.9, -1, -0.2, 0.1)
+        assert sn.assert_reference(-0.9, -1, -0.2)
+        assert sn.assert_reference(-0.9, -1, upper_thres=0.1)
+        assert sn.assert_reference(-0.9, -1)
 
         # Check upper threshold values greater than 1
-        self.assertTrue(sn.assert_reference(20.0, 10.0, None, 3.0))
-        self.assertTrue(sn.assert_reference(-50.0, -20.0, -2.0, 0.5))
-
-        self.assertRaisesRegex(
-            SanityError,
-            r'0\.5 is beyond reference value 1 \(l=0\.8, u=1\.1\)',
-            sn.evaluate, sn.assert_reference(0.5, 1, -0.2, 0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'0\.5 is beyond reference value 1 \(l=0\.8, u=inf\)',
-            sn.evaluate, sn.assert_reference(0.5, 1, -0.2)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'1\.5 is beyond reference value 1 \(l=0\.8, u=1\.1\)',
-            sn.evaluate, sn.assert_reference(1.5, 1, -0.2, 0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'1\.5 is beyond reference value 1 \(l=-inf, u=1\.1\)',
-            sn.evaluate, sn.assert_reference(
-                1.5, 1, lower_thres=None, upper_thres=0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'-0\.8 is beyond reference value -1 \(l=-1\.2, u=-0\.9\)',
-            sn.evaluate, sn.assert_reference(-0.8, -1, -0.2, 0.1)
-        )
+        assert sn.assert_reference(20.0, 10.0, None, 3.0)
+        assert sn.assert_reference(-50.0, -20.0, -2.0, 0.5)
+        with pytest.raises(SanityError,
+                           match=r'0\.5 is beyond reference value 1 '
+                                 r'\(l=0\.8, u=1\.1\)'):
+            sn.evaluate(sn.assert_reference(0.5, 1, -0.2, 0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'0\.5 is beyond reference value 1 '
+                                 r'\(l=0\.8, u=inf\)'):
+            sn.evaluate(sn.assert_reference(0.5, 1, -0.2))
+
+        with pytest.raises(SanityError,
+                           match=r'1\.5 is beyond reference value 1 '
+                                 r'\(l=0\.8, u=1\.1\)'):
+            sn.evaluate(sn.assert_reference(1.5, 1, -0.2, 0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'1\.5 is beyond reference value 1 '
+                                 r'\(l=-inf, u=1\.1\)'):
+            sn.evaluate(sn.assert_reference(1.5, 1, lower_thres=None,
+                                            upper_thres=0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'-0\.8 is beyond reference value -1 '
+                                 r'\(l=-1\.2, u=-0\.9\)'):
+            sn.evaluate(sn.assert_reference(-0.8, -1, -0.2, 0.1))
 
         # Check invalid thresholds
-        self.assertRaisesRegex(
-            SanityError,
-            r'invalid high threshold value: -0\.1',
-            sn.evaluate, sn.assert_reference(0.9, 1, -0.2, -0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'invalid low threshold value: 0\.2',
-            sn.evaluate, sn.assert_reference(0.9, 1, 0.2, 0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'invalid low threshold value: 1\.2',
-            sn.evaluate, sn.assert_reference(0.9, 1, 1.2, 0.1)
-        )
+        with pytest.raises(SanityError,
+                           match=r'invalid high threshold value: -0\.1'):
+            sn.evaluate(sn.assert_reference(0.9, 1, -0.2, -0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'invalid low threshold value: 0\.2'):
+            sn.evaluate(sn.assert_reference(0.9, 1, 0.2, 0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'invalid low threshold value: 1\.2'):
+            sn.evaluate(sn.assert_reference(0.9, 1, 1.2, 0.1))
 
         # check invalid thresholds greater than 1
-        self.assertRaisesRegex(
-            SanityError,
-            r'invalid low threshold value: -2\.0',
-            sn.evaluate, sn.assert_reference(0.9, 1, -2.0, 0.1)
-        )
-        self.assertRaisesRegex(
-            SanityError,
-            r'invalid high threshold value: 1\.5',
-            sn.evaluate, sn.assert_reference(-1.5, -1, -0.5, 1.5)
-        )
+        with pytest.raises(SanityError,
+                           match=r'invalid low threshold value: -2\.0'):
+            sn.evaluate(sn.assert_reference(0.9, 1, -2.0, 0.1))
+
+        with pytest.raises(SanityError,
+                           match=r'invalid high threshold value: 1\.5'):
+            sn.evaluate(sn.assert_reference(-1.5, -1, -0.5, 1.5))
 
     def _write_tempfile(self):
         ret = None
@@ -467,32 +475,29 @@ def _write_tempfile(self):
 
     def test_assert_found(self):
         tempfile = self._write_tempfile()
-        self.assertTrue(sn.assert_found(r'Step: \d+', tempfile))
-        self.assertTrue(sn.assert_found(
-            r'Step: \d+', sn.defer(tempfile)))
-        self.assertRaises(SanityError, sn.evaluate,
-                          sn.assert_found(r'foo: \d+', tempfile))
+        assert sn.assert_found(r'Step: \d+', tempfile)
+        assert sn.assert_found(
+            r'Step: \d+', sn.defer(tempfile))
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.assert_found(r'foo: \d+', tempfile))
+
         os.remove(tempfile)
 
     def test_assert_found_encoding(self):
-        self.assertTrue(
-            sn.assert_found('Odyssey', self.utf16_file, encoding='utf-16')
-        )
+        assert sn.assert_found('Odyssey', self.utf16_file, encoding='utf-16')
 
     def test_assert_not_found(self):
         tempfile = self._write_tempfile()
-        self.assertTrue(sn.assert_not_found(r'foo: \d+', tempfile))
-        self.assertTrue(
-            sn.assert_not_found(r'foo: \d+', sn.defer(tempfile))
-        )
-        self.assertRaises(SanityError, sn.evaluate,
-                          sn.assert_not_found(r'Step: \d+', tempfile))
+        assert sn.assert_not_found(r'foo: \d+', tempfile)
+        assert sn.assert_not_found(r'foo: \d+', sn.defer(tempfile))
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.assert_not_found(r'Step: \d+', tempfile))
+
         os.remove(tempfile)
 
     def test_assert_not_found_encoding(self):
-        self.assertTrue(
-            sn.assert_not_found(r'Iliad', self.utf16_file, encoding='utf-16')
-        )
+        assert sn.assert_not_found(r'Iliad', self.utf16_file,
+                                   encoding='utf-16')
 
 
 class TestUtilityFunctions(unittest.TestCase):
@@ -500,23 +505,25 @@ def test_getitem(self):
         l = [1, 2, 3]
         d = {'a': 1, 'b': 2, 'c': 3}
 
-        self.assertEqual(2, sn.getitem(l, 1))
-        self.assertEqual(2, sn.getitem(d, 'b'))
-        self.assertRaisesRegex(SanityError, 'index out of bounds: 10',
-                               sn.evaluate, sn.getitem(l, 10))
-        self.assertRaisesRegex(SanityError, 'key not found: k',
-                               sn.evaluate, sn.getitem(d, 'k'))
+        assert 2 == sn.getitem(l, 1)
+        assert 2 == sn.getitem(d, 'b')
+        with pytest.raises(SanityError, match='index out of bounds: 10'):
+            sn.evaluate(sn.getitem(l, 10))
+
+        with pytest.raises(SanityError, match='key not found: k'):
+            sn.evaluate(sn.getitem(d, 'k'))
 
     def test_getitem_with_deferrables(self):
         l = sn.defer([1, 2, 3])
         d = sn.defer({'a': 1, 'b': 2, 'c': 3})
 
-        self.assertEqual(2, sn.getitem(l, 1))
-        self.assertEqual(2, sn.getitem(d, 'b'))
-        self.assertRaisesRegex(SanityError, 'index out of bounds: 10',
-                               sn.evaluate, sn.getitem(l, 10))
-        self.assertRaisesRegex(SanityError, 'key not found: k',
-                               sn.evaluate, sn.getitem(d, 'k'))
+        assert 2 == sn.getitem(l, 1)
+        assert 2 == sn.getitem(d, 'b')
+        with pytest.raises(SanityError, match='index out of bounds: 10'):
+            sn.evaluate(sn.getitem(l, 10))
+
+        with pytest.raises(SanityError, match='key not found: k'):
+            sn.evaluate(sn.getitem(d, 'k'))
 
     def test_count(self):
         # Use a custom generator for testing
@@ -524,19 +531,19 @@ def myrange(n):
             for i in range(n):
                 yield i
 
-        self.assertEqual(3, sn.count([1, 2, 3]))
-        self.assertEqual(3, sn.count((1, 2, 3)))
-        self.assertEqual(3, sn.count({1, 2, 3}))
-        self.assertEqual(3, sn.count({'a': 1, 'b': 2, 'c': 3}))
-        self.assertEqual(3, sn.count(range(3)))
-        self.assertEqual(3, sn.count(myrange(3)))
+        assert 3 == sn.count([1, 2, 3])
+        assert 3 == sn.count((1, 2, 3))
+        assert 3 == sn.count({1, 2, 3})
+        assert 3 == sn.count({'a': 1, 'b': 2, 'c': 3})
+        assert 3 == sn.count(range(3))
+        assert 3 == sn.count(myrange(3))
 
         # Test empty sequences
-        self.assertEqual(0, sn.count([]))
-        self.assertEqual(0, sn.count({}))
-        self.assertEqual(0, sn.count(set()))
-        self.assertEqual(0, sn.count(range(0)))
-        self.assertEqual(0, sn.count(myrange(0)))
+        assert 0 == sn.count([])
+        assert 0 == sn.count({})
+        assert 0 == sn.count(set())
+        assert 0 == sn.count(range(0))
+        assert 0 == sn.count(myrange(0))
 
     def test_count_uniq(self):
         # Use a custom generator for testing
@@ -544,40 +551,40 @@ def my_mod_range(n, mod=2):
             for i in range(n):
                 yield i % mod
 
-        self.assertEqual(4, sn.count_uniq([1, 2, 3, 4, 4, 3, 2, 1]))
-        self.assertEqual(1, sn.count_uniq((1, 1, 1)))
-        self.assertEqual(3, sn.count_uniq({1, 2, 3, 2, 3}))
-        self.assertEqual(3, sn.count_uniq({'a': 1, 'b': 2, 'c': 3}))
-        self.assertEqual(2, sn.count_uniq(my_mod_range(10)))
-        self.assertEqual(3, sn.count_uniq(my_mod_range(10, 3)))
+        assert 4 == sn.count_uniq([1, 2, 3, 4, 4, 3, 2, 1])
+        assert 1 == sn.count_uniq((1, 1, 1))
+        assert 3 == sn.count_uniq({1, 2, 3, 2, 3})
+        assert 3 == sn.count_uniq({'a': 1, 'b': 2, 'c': 3})
+        assert 2 == sn.count_uniq(my_mod_range(10))
+        assert 3 == sn.count_uniq(my_mod_range(10, 3))
 
         # Test empty sequences
-        self.assertEqual(0, sn.count_uniq([]))
-        self.assertEqual(0, sn.count_uniq({}))
-        self.assertEqual(0, sn.count_uniq(set()))
-        self.assertEqual(0, sn.count_uniq(my_mod_range(0)))
-        self.assertEqual(0, sn.count_uniq(range(0)))
+        assert 0 == sn.count_uniq([])
+        assert 0 == sn.count_uniq({})
+        assert 0 == sn.count_uniq(set())
+        assert 0 == sn.count_uniq(my_mod_range(0))
+        assert 0 == sn.count_uniq(range(0))
 
         # Test deferred expressions
         d = [1, 2, 2, 1]
-        self.assertEqual(2, sn.count_uniq(sn.defer(d)))
+        assert 2 == sn.count_uniq(sn.defer(d))
 
     def test_glob(self):
         filepatt = os.path.join(TEST_RESOURCES_CHECKS, '*.py')
-        self.assertTrue(sn.glob(filepatt))
-        self.assertTrue(sn.glob(sn.defer(filepatt)))
+        assert sn.glob(filepatt)
+        assert sn.glob(sn.defer(filepatt))
 
     def test_iglob(self):
         filepatt = os.path.join(TEST_RESOURCES_CHECKS, '*.py')
-        self.assertTrue(sn.count(sn.iglob(filepatt)))
-        self.assertTrue(sn.count(sn.iglob(sn.defer(filepatt))))
+        assert sn.count(sn.iglob(filepatt))
+        assert sn.count(sn.iglob(sn.defer(filepatt)))
 
     def test_chain(self):
         list1 = ['A', 'B', 'C']
         list2 = ['D', 'E', 'F']
         chain1 = sn.evaluate(sn.chain(sn.defer(list1), list2))
         chain2 = itertools.chain(list1, list2)
-        self.assertTrue(all((a == b for a, b in zip(chain1, chain2))))
+        assert all((a == b for a, b in zip(chain1, chain2)))
 
 
 class TestPatternMatchingFunctions(unittest.TestCase):
@@ -596,142 +603,136 @@ def tearDown(self):
 
     def test_findall(self):
         res = sn.evaluate(sn.findall(r'Step: \d+', self.tempfile))
-        self.assertEqual(3, len(res))
+        assert 3 == len(res)
 
         res = sn.evaluate(sn.findall('Step:.*', self.tempfile))
-        self.assertEqual(3, len(res))
+        assert 3 == len(res)
 
         res = sn.evaluate(sn.findall('Step: [12]', self.tempfile))
-        self.assertEqual(2, len(res))
+        assert 2 == len(res)
 
         # Check the matches
         for expected, match in zip(['Step: 1', 'Step: 2'], res):
-            self.assertEqual(expected, match.group(0))
+            assert expected == match.group(0)
 
         # Check groups
         res = sn.evaluate(sn.findall(r'Step: (?P<no>\d+)', self.tempfile))
         for step, match in enumerate(res, start=1):
-            self.assertEqual(step, int(match.group(1)))
-            self.assertEqual(step, int(match.group('no')))
+            assert step == int(match.group(1))
+            assert step == int(match.group('no'))
 
     def test_findall_encoding(self):
         res = sn.evaluate(
             sn.findall('Odyssey', self.utf16_file, encoding='utf-16')
         )
-        self.assertEqual(1, len(res))
+        assert 1 == len(res)
 
     def test_findall_error(self):
-        self.assertRaises(SanityError, sn.evaluate,
-                          sn.findall(r'Step: \d+', 'foo.txt'))
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.findall(r'Step: \d+', 'foo.txt'))
 
     def test_extractall(self):
         # Check numeric groups
         res = sn.evaluate(sn.extractall(
             r'Step: (?P<no>\d+)', self.tempfile, 1))
         for expected, v in enumerate(res, start=1):
-            self.assertEqual(str(expected), v)
+            assert str(expected) == v
 
         # Check named groups
         res = sn.evaluate(sn.extractall(
             r'Step: (?P<no>\d+)', self.tempfile, 'no'))
         for expected, v in enumerate(res, start=1):
-            self.assertEqual(str(expected), v)
+            assert str(expected) == v
 
         # Check convert function
         res = sn.evaluate(sn.extractall(r'Step: (?P<no>\d+)',
                                         self.tempfile, 'no', int))
         for expected, v in enumerate(res, start=1):
-            self.assertEqual(expected, v)
+            assert expected == v
 
     def test_extractall_encoding(self):
         res = sn.evaluate(
             sn.extractall('Odyssey', self.utf16_file, encoding='utf-16')
         )
-        self.assertEqual(1, len(res))
+        assert 1 == len(res)
 
     def test_extractall_error(self):
-        self.assertRaises(SanityError, sn.evaluate,
-                          sn.extractall(r'Step: (\d+)', 'foo.txt', 1))
-        self.assertRaises(
-            SanityError, sn.evaluate,
-            sn.extractall(r'Step: (?P<no>\d+)',
-                          self.tempfile, conv=int)
-        )
-        self.assertRaises(SanityError, sn.evaluate,
-                          sn.extractall(r'Step: (\d+)', self.tempfile, 2))
-        self.assertRaises(
-            SanityError, sn.evaluate,
-            sn.extractall(r'Step: (?P<no>\d+)', self.tempfile, 'foo'))
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (\d+)', 'foo.txt', 1))
+
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (?P<no>\d+)',
+                        self.tempfile, conv=int))
+
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (\d+)', self.tempfile, 2))
+
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (?P<no>\d+)', self.tempfile,
+                                      'foo'))
 
     def test_extractall_custom_conv(self):
         res = sn.evaluate(sn.extractall(r'Step: (\d+)', self.tempfile, 1,
                                         lambda x: int(x)))
         for expected, v in enumerate(res, start=1):
-            self.assertEqual(expected, v)
+            assert expected == v
 
         # Check error in custom function
-        self.assertRaises(
-            SanityError, sn.evaluate,
-            sn.extractall(r'Step: (\d+)', self.tempfile,
-                          conv=lambda x: int(x))
-        )
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (\d+)', self.tempfile,
+                                      conv=lambda x: int(x)))
 
         # Check error with a callable object
         class C:
             def __call__(self, x):
                 return int(x)
 
-        self.assertRaises(
-            SanityError, sn.evaluate,
-            sn.extractall(r'Step: (\d+)', self.tempfile, conv=C())
-        )
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractall(r'Step: (\d+)', self.tempfile, conv=C()))
 
     def test_extractsingle(self):
         for i in range(1, 4):
-            self.assertEqual(
-                i,
-                sn.extractsingle(r'Step: (\d+)', self.tempfile, 1, int, i-1)
-            )
+            assert i == sn.extractsingle(r'Step: (\d+)', self.tempfile, 1, int,
+                                         i-1)
 
         # Test out of bounds access
-        self.assertRaises(
-            SanityError, sn.evaluate,
-            sn.extractsingle(r'Step: (\d+)', self.tempfile, 1, int, 100)
-        )
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.extractsingle(r'Step: (\d+)', self.tempfile, 1, int,
+                                         100))
 
     def test_extractsingle_encoding(self):
         res = sn.evaluate(
             sn.extractsingle(r'Odyssey', self.utf16_file, encoding='utf-16')
         )
-        self.assertNotEqual(-1, res.find('Odyssey'))
+        assert -1 != res.find('Odyssey')
 
     def test_safe_format(self):
         from reframe.utility.sanity import _format
 
         s = 'There is {0} and {1}.'
-        self.assertEqual(s, _format(s))
-        self.assertEqual(s, _format(s, 'bacon'))
-        self.assertEqual('There is egg and spam.', _format(s, 'egg', 'spam'))
-        self.assertEqual('There is egg and bacon.',
-                         _format(s, 'egg', 'bacon', 'spam'))
+        assert s == _format(s)
+        assert s == _format(s, 'bacon')
+        assert 'There is egg and spam.' == _format(s, 'egg', 'spam')
+        assert 'There is egg and bacon.' == _format(s, 'egg', 'bacon', 'spam')
 
         s = 'no placeholders'
-        self.assertEqual(s, _format(s))
-        self.assertEqual(s, _format(s, 'bacon'))
+        assert s == _format(s)
+        assert s == _format(s, 'bacon')
 
 
 class TestNumericFunctions(unittest.TestCase):
     def test_avg(self):
         res = sn.evaluate(sn.avg([1, 2, 3, 4]))
-        self.assertEqual(2.5, res)
+        assert 2.5 == res
 
         # Check result when passing a generator
         res = sn.evaluate(sn.avg(range(1, 5)))
-        self.assertEqual(2.5, res)
+        assert 2.5 == res
 
         # Check with single element container
         res = sn.evaluate(sn.avg(range(1, 2)))
-        self.assertEqual(1, res)
+        assert 1 == res
 
         # Check with empty container
-        self.assertRaises(SanityError, sn.evaluate, sn.avg([]))
+        with pytest.raises(SanityError):
+            sn.evaluate(sn.avg([]))
diff --git a/unittests/test_schedulers.py b/unittests/test_schedulers.py
index 8543c5a44a..0a45608ffb 100644
--- a/unittests/test_schedulers.py
+++ b/unittests/test_schedulers.py
@@ -5,6 +5,7 @@
 
 import abc
 import os
+import pytest
 import re
 import socket
 import tempfile
@@ -86,7 +87,7 @@ def setup_user(self, msg=None):
         partition = fixtures.partition_with_scheduler(self.sched_name)
         if partition is None:
             msg = msg or "scheduler '%s' not configured" % self.sched_name
-            self.skipTest(msg)
+            pytest.skip(msg)
 
         self.testjob._sched_access = partition.access
 
@@ -95,8 +96,7 @@ def assertScriptSanity(self, script_file):
         with open(self.testjob.script_filename) as fp:
             matches = re.findall(r'echo prerun|echo postrun|hostname',
                                  fp.read())
-            self.assertEqual(['echo prerun', 'hostname', 'echo postrun'],
-                             matches)
+            assert ['echo prerun', 'hostname', 'echo postrun'] == matches
 
     def setup_job(self):
         # Mock up a job submission
@@ -125,9 +125,9 @@ def test_prepare(self):
     def test_submit(self):
         self.setup_user()
         self.prepare()
-        self.assertIsNone(self.testjob.nodelist)
+        assert self.testjob.nodelist is None
         self.testjob.submit()
-        self.assertIsNotNone(self.testjob.jobid)
+        assert self.testjob.jobid is not None
         self.testjob.wait()
 
     @fixtures.switch_to_user_runtime
@@ -138,15 +138,15 @@ def test_submit_timelimit(self, check_elapsed_time=True):
         self.prepare()
         t_job = datetime.now()
         self.testjob.submit()
-        self.assertIsNotNone(self.testjob.jobid)
+        assert self.testjob.jobid is not None
         self.testjob.wait()
         t_job = datetime.now() - t_job
         if check_elapsed_time:
-            self.assertGreaterEqual(t_job.total_seconds(), 2)
-            self.assertLess(t_job.total_seconds(), 3)
+            assert t_job.total_seconds() >= 2
+            assert t_job.total_seconds() < 3
 
         with open(self.testjob.stdout) as fp:
-            self.assertIsNone(re.search('postrun', fp.read()))
+            assert re.search('postrun', fp.read()) is None
 
     @fixtures.switch_to_user_runtime
     def test_cancel(self):
@@ -158,18 +158,20 @@ def test_cancel(self):
         self.testjob.cancel()
         self.testjob.wait()
         t_job = datetime.now() - t_job
-        self.assertTrue(self.testjob.finished())
-        self.assertLess(t_job.total_seconds(), 30)
+        assert self.testjob.finished()
+        assert t_job.total_seconds() < 30
 
     def test_cancel_before_submit(self):
         self.parallel_cmd = 'sleep 3'
         self.prepare()
-        self.assertRaises(JobNotStartedError, self.testjob.cancel)
+        with pytest.raises(JobNotStartedError):
+            self.testjob.cancel()
 
     def test_wait_before_submit(self):
         self.parallel_cmd = 'sleep 3'
         self.prepare()
-        self.assertRaises(JobNotStartedError, self.testjob.wait)
+        with pytest.raises(JobNotStartedError):
+            self.testjob.wait()
 
     @fixtures.switch_to_user_runtime
     def test_poll(self):
@@ -177,21 +179,22 @@ def test_poll(self):
         self.parallel_cmd = 'sleep 2'
         self.prepare()
         self.testjob.submit()
-        self.assertFalse(self.testjob.finished())
+        assert not self.testjob.finished()
         self.testjob.wait()
 
     def test_poll_before_submit(self):
         self.parallel_cmd = 'sleep 3'
         self.prepare()
-        self.assertRaises(JobNotStartedError, self.testjob.finished)
+        with pytest.raises(JobNotStartedError):
+            self.testjob.finished()
 
     def test_no_empty_lines_in_preamble(self):
         for l in self.testjob.scheduler.emit_preamble(self.testjob):
-            self.assertNotEqual(l, '')
+            assert l != ''
 
     def test_guess_num_tasks(self):
         self.testjob.num_tasks = 0
-        with self.assertRaises(NotImplementedError):
+        with pytest.raises(NotImplementedError):
             self.testjob.guess_num_tasks()
 
 
@@ -199,7 +202,7 @@ class TestLocalJob(_TestJob, unittest.TestCase):
     def assertProcessDied(self, pid):
         try:
             os.kill(pid, 0)
-            self.fail('process %s is still alive' % pid)
+            pytest.fail('process %s is still alive' % pid)
         except (ProcessLookupError, PermissionError):
             pass
 
@@ -221,12 +224,12 @@ def setup_user(self, msg=None):
 
     def test_submit(self):
         super().test_submit()
-        self.assertEqual(0, self.testjob.exitcode)
-        self.assertEqual([socket.gethostname()], self.testjob.nodelist)
+        assert 0 == self.testjob.exitcode
+        assert [socket.gethostname()] == self.testjob.nodelist
 
     def test_submit_timelimit(self):
         super().test_submit_timelimit()
-        self.assertEqual(self.testjob.state, 'TIMEOUT')
+        assert self.testjob.state == 'TIMEOUT'
 
     def test_cancel_with_grace(self):
         # This test emulates a spawned process that ignores the SIGTERM signal
@@ -262,9 +265,9 @@ def test_cancel_with_grace(self):
         with open(self.testjob.stdout) as f:
             sleep_pid = int(f.read())
 
-        self.assertGreaterEqual(t_grace.total_seconds(), 2)
-        self.assertLess(t_grace.total_seconds(), 5)
-        self.assertEqual(self.testjob.state, 'TIMEOUT')
+        assert t_grace.total_seconds() >= 2
+        assert t_grace.total_seconds() < 5
+        assert self.testjob.state == 'TIMEOUT'
 
         # Verify that the spawned sleep is killed, too
         self.assertProcessDied(sleep_pid)
@@ -302,8 +305,8 @@ def test_cancel_term_ignore(self):
         with open(self.testjob.stdout) as f:
             sleep_pid = int(f.read())
 
-        self.assertGreaterEqual(t_grace.total_seconds(), 2)
-        self.assertEqual(self.testjob.state, 'TIMEOUT')
+        assert t_grace.total_seconds() >= 2
+        assert self.testjob.state == 'TIMEOUT'
 
         # Verify that the spawned sleep is killed, too
         self.assertProcessDied(sleep_pid)
@@ -365,50 +368,50 @@ def test_prepare(self):
             found_directives = set(re.findall(r'^\#\w+ .*', fp.read(),
                                               re.MULTILINE))
 
-        self.assertEqual(expected_directives, found_directives)
+        assert expected_directives == found_directives
 
     def test_prepare_no_exclusive(self):
         self.setup_job()
         self.testjob._sched_exclusive_access = False
         super().test_prepare()
         with open(self.testjob.script_filename) as fp:
-            self.assertIsNone(re.search(r'--exclusive', fp.read()))
+            assert re.search(r'--exclusive', fp.read()) is None
 
     def test_prepare_no_smt(self):
         self.setup_job()
         self.testjob.use_smt = None
         super().test_prepare()
         with open(self.testjob.script_filename) as fp:
-            self.assertIsNone(re.search(r'--hint', fp.read()))
+            assert re.search(r'--hint', fp.read()) is None
 
     def test_prepare_with_smt(self):
         self.setup_job()
         self.testjob.use_smt = True
         super().test_prepare()
         with open(self.testjob.script_filename) as fp:
-            self.assertIsNotNone(re.search(r'--hint=multithread', fp.read()))
+            assert re.search(r'--hint=multithread', fp.read()) is not None
 
     def test_prepare_without_smt(self):
         self.setup_job()
         self.testjob.use_smt = False
         super().test_prepare()
         with open(self.testjob.script_filename) as fp:
-            self.assertIsNotNone(re.search(r'--hint=nomultithread', fp.read()))
+            assert re.search(r'--hint=nomultithread', fp.read()) is not None
 
     def test_submit(self):
         super().test_submit()
-        self.assertEqual(0, self.testjob.exitcode)
+        assert 0 == self.testjob.exitcode
         num_tasks_per_node = self.testjob.num_tasks_per_node or 1
         num_nodes = self.testjob.num_tasks // num_tasks_per_node
-        self.assertEqual(num_nodes, len(self.testjob.nodelist))
+        assert num_nodes == len(self.testjob.nodelist)
 
     def test_submit_timelimit(self):
         # Skip this test for Slurm, since we the minimum time limit is 1min
-        self.skipTest("SLURM's minimum time limit is 60s")
+        pytest.skip("SLURM's minimum time limit is 60s")
 
     def test_cancel(self):
         super().test_cancel()
-        self.assertEqual(self.testjob.state, 'CANCELLED')
+        assert self.testjob.state == 'CANCELLED'
 
     def test_guess_num_tasks(self):
         self.testjob.num_tasks = 0
@@ -443,7 +446,7 @@ def setup_user(self, msg=None):
         partition = (fixtures.partition_with_scheduler(self.sched_name) or
                      fixtures.partition_with_scheduler('slurm'))
         if partition is None:
-            self.skipTest('SLURM not configured')
+            pytest.skip('SLURM not configured')
 
         self.testjob.options += partition.access
 
@@ -493,7 +496,7 @@ def test_prepare(self):
             found_directives = set(re.findall(r'^\#\w+ .*', fp.read(),
                                               re.MULTILINE))
 
-        self.assertEqual(expected_directives, found_directives)
+        assert expected_directives == found_directives
 
     def test_prepare_no_cpus(self):
         self.setup_job()
@@ -520,11 +523,11 @@ def test_prepare_no_cpus(self):
             found_directives = set(re.findall(r'^\#\w+ .*', fp.read(),
                                               re.MULTILINE))
 
-        self.assertEqual(expected_directives, found_directives)
+        assert expected_directives == found_directives
 
     def test_submit_timelimit(self):
         # Skip this test for PBS, since we the minimum time limit is 1min
-        self.skipTest("PBS minimum time limit is 60s")
+        pytest.skip("PBS minimum time limit is 60s")
 
 
 class TestSlurmFlexibleNodeAllocation(unittest.TestCase):
@@ -657,97 +660,97 @@ def test_positive_flex_alloc_nodes(self):
         self.testjob._sched_flex_alloc_nodes = 12
         self.testjob._sched_access = ['--constraint=f1']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 48)
+        assert self.testjob.num_tasks == 48
 
     def test_zero_flex_alloc_nodes(self):
         self.testjob._sched_flex_alloc_nodes = 0
         self.testjob._sched_access = ['--constraint=f1']
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_negative_flex_alloc_nodes(self):
         self.testjob._sched_flex_alloc_nodes = -1
         self.testjob._sched_access = ['--constraint=f1']
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_sched_access_idle(self):
         self.testjob._sched_flex_alloc_nodes = 'idle'
         self.testjob._sched_access = ['--constraint=f1']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_sched_access_constraint_partition(self):
         self.testjob._sched_flex_alloc_nodes = 'all'
         self.testjob._sched_access = ['--constraint=f1', '--partition=p2']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_sched_access_partition(self):
         self.testjob._sched_access = ['--partition=p1']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 16)
+        assert self.testjob.num_tasks == 16
 
     def test_default_partition_all(self):
         self.testjob._sched_flex_alloc_nodes = 'all'
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 16)
+        assert self.testjob.num_tasks == 16
 
     def test_constraint_idle(self):
         self.testjob._sched_flex_alloc_nodes = 'idle'
         self.testjob.options = ['--constraint=f1']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_partition_idle(self):
         self.testjob._sched_flex_alloc_nodes = 'idle'
         self.testjob._sched_partition = 'p2'
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_valid_constraint_opt(self):
         self.testjob.options = ['-C f1']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 12)
+        assert self.testjob.num_tasks == 12
 
     def test_valid_multiple_constraints(self):
         self.testjob.options = ['-C f1,f3']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_valid_partition_cmd(self):
         self.testjob._sched_partition = 'p2'
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_valid_partition_opt(self):
         self.testjob.options = ['-p p2']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_valid_multiple_partitions(self):
         self.testjob.options = ['--partition=p1,p2']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_valid_constraint_partition(self):
         self.testjob.options = ['-C f1,f2', '--partition=p1,p2']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_not_valid_partition_cmd(self):
         self.testjob._sched_partition = 'invalid'
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_invalid_partition_opt(self):
         self.testjob.options = ['--partition=invalid']
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_invalid_constraint(self):
         self.testjob.options = ['--constraint=invalid']
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_valid_reservation_cmd(self):
@@ -759,7 +762,7 @@ def test_valid_reservation_cmd(self):
         sched = self.testjob.scheduler
         sched._get_reservation_nodes = self.create_reservation_nodes
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_valid_reservation_option(self):
         self.testjob._sched_access = ['--constraint=f2']
@@ -767,7 +770,7 @@ def test_valid_reservation_option(self):
         sched = self.testjob.scheduler
         sched._get_reservation_nodes = self.create_reservation_nodes
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def test_exclude_nodes_cmd(self):
         self.testjob._sched_access = ['--constraint=f1']
@@ -778,7 +781,7 @@ def test_exclude_nodes_cmd(self):
         sched = self.testjob.scheduler
         sched._get_nodes_by_name = self.create_dummy_nodes_by_name
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_exclude_nodes_opt(self):
         self.testjob._sched_access = ['--constraint=f1']
@@ -786,31 +789,31 @@ def test_exclude_nodes_opt(self):
         sched = self.testjob.scheduler
         sched._get_nodes_by_name = self.create_dummy_nodes_by_name
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 8)
+        assert self.testjob.num_tasks == 8
 
     def test_no_num_tasks_per_node(self):
         self.testjob.num_tasks_per_node = None
         self.testjob.options = ['-C f1,f2', '--partition=p1,p2']
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 1)
+        assert self.testjob.num_tasks == 1
 
     def test_not_enough_idle_nodes(self):
         self.testjob._sched_flex_alloc_nodes = 'idle'
         self.testjob.num_tasks = -12
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_not_enough_nodes_constraint_partition(self):
         self.testjob.options = ['-C f1,f2', '--partition=p1,p2']
         self.testjob.num_tasks = -8
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             self.prepare_job()
 
     def test_enough_nodes_constraint_partition(self):
         self.testjob.options = ['-C f1,f2', '--partition=p1,p2']
         self.testjob.num_tasks = -4
         self.prepare_job()
-        self.assertEqual(self.testjob.num_tasks, 4)
+        assert self.testjob.num_tasks == 4
 
     def prepare_job(self):
         self.testjob.prepare(['hostname'])
@@ -924,40 +927,39 @@ def setUp(self):
         self.no_partition_node = _SlurmNode(no_partition_node_description)
 
     def test_no_node_name(self):
-        with self.assertRaises(JobError):
+        with pytest.raises(JobError):
             _SlurmNode(self.no_name_node_description)
 
     def test_states(self):
-        self.assertEqual(self.allocated_node.states, {'ALLOCATED'})
-        self.assertEqual(self.idle_node.states, {'IDLE'})
-        self.assertEqual(self.idle_drained.states, {'IDLE', 'DRAIN'})
+        assert self.allocated_node.states == {'ALLOCATED'}
+        assert self.idle_node.states == {'IDLE'}
+        assert self.idle_drained.states == {'IDLE', 'DRAIN'}
 
     def test_equals(self):
-        self.assertEqual(self.allocated_node, self.allocated_node_copy)
-        self.assertNotEqual(self.allocated_node, self.idle_node)
+        assert self.allocated_node == self.allocated_node_copy
+        assert self.allocated_node != self.idle_node
 
     def test_hash(self):
-        self.assertEqual(hash(self.allocated_node),
-                         hash(self.allocated_node_copy))
+        assert hash(self.allocated_node) == hash(self.allocated_node_copy)
 
     def test_attributes(self):
-        self.assertEqual(self.allocated_node.name, 'nid00001')
-        self.assertEqual(self.allocated_node.partitions, {'p1', 'p2'})
-        self.assertEqual(self.allocated_node.active_features, {'f1', 'f2'})
-        self.assertEqual(self.no_partition_node.name, 'nid00004')
-        self.assertEqual(self.no_partition_node.partitions, set())
-        self.assertEqual(self.no_partition_node.active_features, {'f1', 'f2'})
+        assert self.allocated_node.name == 'nid00001'
+        assert self.allocated_node.partitions == {'p1', 'p2'}
+        assert self.allocated_node.active_features == {'f1', 'f2'}
+        assert self.no_partition_node.name == 'nid00004'
+        assert self.no_partition_node.partitions == set()
+        assert self.no_partition_node.active_features == {'f1', 'f2'}
 
     def test_str(self):
-        self.assertEqual('nid00001', str(self.allocated_node))
+        assert 'nid00001' == str(self.allocated_node)
 
     def test_is_available(self):
-        self.assertFalse(self.allocated_node.is_available())
-        self.assertTrue(self.idle_node.is_available())
-        self.assertFalse(self.idle_drained.is_available())
-        self.assertFalse(self.no_partition_node.is_available())
+        assert not self.allocated_node.is_available()
+        assert self.idle_node.is_available()
+        assert not self.idle_drained.is_available()
+        assert not self.no_partition_node.is_available()
 
     def test_is_down(self):
-        self.assertFalse(self.allocated_node.is_down())
-        self.assertFalse(self.idle_node.is_down())
-        self.assertTrue(self.no_partition_node.is_down())
+        assert not self.allocated_node.is_down()
+        assert not self.idle_node.is_down()
+        assert self.no_partition_node.is_down()
diff --git a/unittests/test_shell.py b/unittests/test_shell.py
index 25a4cf05e6..abac716403 100644
--- a/unittests/test_shell.py
+++ b/unittests/test_shell.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import os
+import pytest
 import stat
 import tempfile
 import time
@@ -48,7 +49,7 @@ def test_generate(self):
 unset v1
 '''
         with open(self.script_file.name) as fp:
-            self.assertEqual(expected_output, fp.read())
+            assert expected_output == fp.read()
 
     def test_generate_login(self):
         with shell.generate_script(self.script_file.name, login=True) as gen:
@@ -58,7 +59,7 @@ def test_generate_login(self):
 echo hello
 '''
         with open(self.script_file.name) as fp:
-            self.assertEqual(expected_output, fp.read())
+            assert expected_output == fp.read()
 
     def test_write_types(self):
         class C:
@@ -77,7 +78,7 @@ def __str__(self):
 echo "C()"
 '''
         with open(self.script_file.name) as fp:
-            self.assertEqual(expected_output, fp.read())
+            assert expected_output == fp.read()
 
     def test_trap_error(self):
         with shell.generate_script(self.script_file.name,
@@ -85,14 +86,13 @@ def test_trap_error(self):
             gen.write('false')
             gen.write('echo hello')
 
-        with self.assertRaises(SpawnedProcessError) as cm:
+        with pytest.raises(SpawnedProcessError) as cm:
             os_ext.run_command(self.script_file.name, check=True)
 
-        exc = cm.exception
-        self.assertNotIn('hello', exc.stdout)
-        self.assertEqual(1, exc.exitcode)
-        self.assertIn("-reframe: command `false' failed (exit code: 1)",
-                      exc.stdout)
+        exc = cm.value
+        assert 'hello' not in exc.stdout
+        assert 1 == exc.exitcode
+        assert "-reframe: command `false' failed (exit code: 1)" in exc.stdout
 
     def test_trap_exit(self):
         with shell.generate_script(self.script_file.name,
@@ -100,10 +100,9 @@ def test_trap_exit(self):
             gen.write('echo hello')
 
         completed = os_ext.run_command(self.script_file.name, check=True)
-        self.assertIn('hello', completed.stdout)
-        self.assertEqual(0, completed.returncode)
-        self.assertIn("-reframe: script exiting with exit code: 0",
-                      completed.stdout)
+        assert 'hello' in completed.stdout
+        assert 0 == completed.returncode
+        assert '-reframe: script exiting with exit code: 0' in completed.stdout
 
     def test_trap_signal(self):
         with shell.generate_script(self.script_file.name,
@@ -126,6 +125,6 @@ def test_trap_signal(self):
         f_stdout.flush()
         f_stdout.seek(0)
         stdout = f_stdout.read()
-        self.assertNotIn('hello', stdout)
-        self.assertEqual(143, proc.returncode)
-        self.assertIn("-reframe: script caught signal: 15", stdout)
+        assert 'hello' not in stdout
+        assert 143 == proc.returncode
+        assert '-reframe: script caught signal: 15' in stdout
diff --git a/unittests/test_typecheck.py b/unittests/test_typecheck.py
index 0d4d29ef44..e89c65eda8 100644
--- a/unittests/test_typecheck.py
+++ b/unittests/test_typecheck.py
@@ -3,127 +3,128 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
+
 import reframe.utility.typecheck as types
 
 
 class TestTypes(unittest.TestCase):
     def _test_type_hierarchy(self, builtin_type, ctype):
-        self.assertTrue(issubclass(builtin_type, ctype))
-        self.assertTrue(issubclass(ctype[int], ctype))
-        self.assertTrue(issubclass(ctype[ctype[int]], ctype))
-        self.assertFalse(issubclass(ctype[int], ctype[float]))
-        self.assertFalse(issubclass(ctype[ctype[int]], ctype[int]))
-        self.assertFalse(issubclass(ctype[int], ctype[ctype[int]]))
+        assert issubclass(builtin_type, ctype)
+        assert issubclass(ctype[int], ctype)
+        assert issubclass(ctype[ctype[int]], ctype)
+        assert not issubclass(ctype[int], ctype[float])
+        assert not issubclass(ctype[ctype[int]], ctype[int])
+        assert not issubclass(ctype[int], ctype[ctype[int]])
 
     def test_list_type(self):
         l = [1, 2]
         ll = [[1, 2], [3, 4]]
-        self.assertIsInstance(l, types.List)
-        self.assertIsInstance(l, types.List[int])
-        self.assertFalse(isinstance(l, types.List[float]))
+        assert isinstance(l, types.List)
+        assert isinstance(l, types.List[int])
+        assert not isinstance(l, types.List[float])
 
-        self.assertIsInstance(ll, types.List)
-        self.assertIsInstance(ll, types.List[types.List[int]])
+        assert isinstance(ll, types.List)
+        assert isinstance(ll, types.List[types.List[int]])
         self._test_type_hierarchy(list, types.List)
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.List[3]
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.List[int, float]
 
     def test_set_type(self):
         s = {1, 2}
         ls = [{1, 2}, {3, 4}]
-        self.assertIsInstance(s, types.Set)
-        self.assertIsInstance(s, types.Set[int])
-        self.assertFalse(isinstance(s, types.Set[float]))
+        assert isinstance(s, types.Set)
+        assert isinstance(s, types.Set[int])
+        assert not isinstance(s, types.Set[float])
 
-        self.assertIsInstance(ls, types.List)
-        self.assertIsInstance(ls, types.List[types.Set[int]])
+        assert isinstance(ls, types.List)
+        assert isinstance(ls, types.List[types.Set[int]])
         self._test_type_hierarchy(set, types.Set)
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Set[3]
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Set[int, float]
 
     def test_uniform_tuple_type(self):
         t = (1, 2)
         tl = ([1, 2], [3, 4])
         lt = [(1, 2), (3, 4)]
-        self.assertIsInstance(t, types.Tuple)
-        self.assertIsInstance(t, types.Tuple[int])
-        self.assertFalse(isinstance(t, types.Tuple[float]))
+        assert isinstance(t, types.Tuple)
+        assert isinstance(t, types.Tuple[int])
+        assert not isinstance(t, types.Tuple[float])
 
-        self.assertIsInstance(tl, types.Tuple)
-        self.assertIsInstance(tl, types.Tuple[types.List[int]])
+        assert isinstance(tl, types.Tuple)
+        assert isinstance(tl, types.Tuple[types.List[int]])
 
-        self.assertIsInstance(lt, types.List)
-        self.assertIsInstance(lt, types.List[types.Tuple[int]])
+        assert isinstance(lt, types.List)
+        assert isinstance(lt, types.List[types.Tuple[int]])
         self._test_type_hierarchy(tuple, types.Tuple)
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Set[3]
 
     def test_non_uniform_tuple_type(self):
         t = (1, 2.3, '4', ['a', 'b'])
-        self.assertIsInstance(t, types.Tuple)
-        self.assertIsInstance(t, types.Tuple[int, float, str, types.List[str]])
-        self.assertFalse(isinstance(t, types.Tuple[float, int, str]))
-        self.assertFalse(isinstance(t, types.Tuple[float, int, str, int]))
+        assert isinstance(t, types.Tuple)
+        assert isinstance(t, types.Tuple[int, float, str, types.List[str]])
+        assert not isinstance(t, types.Tuple[float, int, str])
+        assert not isinstance(t, types.Tuple[float, int, str, int])
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Set[int, 3]
 
     def test_mapping_type(self):
         d = {'one': 1, 'two': 2}
         dl = {'one': [1, 2], 'two': [3, 4]}
         ld = [{'one': 1, 'two': 2}, {'three': 3}]
-        self.assertIsInstance(d, types.Dict)
-        self.assertIsInstance(d, types.Dict[str, int])
-        self.assertFalse(isinstance(d, types.Dict[int, int]))
+        assert isinstance(d, types.Dict)
+        assert isinstance(d, types.Dict[str, int])
+        assert not isinstance(d, types.Dict[int, int])
 
-        self.assertIsInstance(dl, types.Dict)
-        self.assertIsInstance(dl, types.Dict[str, types.List[int]])
-        self.assertIsInstance(ld, types.List[types.Dict[str, int]])
+        assert isinstance(dl, types.Dict)
+        assert isinstance(dl, types.Dict[str, types.List[int]])
+        assert isinstance(ld, types.List[types.Dict[str, int]])
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Dict[int]
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Dict[int, 3]
 
     def test_str_type(self):
         s = '123'
         ls = ['1', '23', '456']
-        self.assertIsInstance(s, types.Str)
-        self.assertIsInstance(s, types.Str[r'\d+'])
-        self.assertIsInstance(ls, types.List[types.Str[r'\d+']])
-        self.assertFalse(isinstance(s, types.Str[r'a.*']))
-        self.assertFalse(isinstance(ls, types.List[types.Str[r'a.*']]))
-        self.assertFalse(isinstance('hello, world', types.Str[r'\S+']))
+        assert isinstance(s, types.Str)
+        assert isinstance(s, types.Str[r'\d+'])
+        assert isinstance(ls, types.List[types.Str[r'\d+']])
+        assert not isinstance(s, types.Str[r'a.*'])
+        assert not isinstance(ls, types.List[types.Str[r'a.*']])
+        assert not isinstance('hello, world', types.Str[r'\S+'])
 
         # Test invalid arguments
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             types.Str[int]
 
     def test_type_names(self):
-        self.assertEqual('List', types.List.__name__)
-        self.assertEqual('List[int]', types.List[int].__name__)
-        self.assertEqual('Dict[str,List[int]]',
-                         types.Dict[str, types.List[int]].__name__)
-        self.assertEqual('Tuple[int,Set[float],str]',
-                         types.Tuple[int, types.Set[float], str].__name__)
-        self.assertEqual(r"List[Str[r'\d+']]",
-                         types.List[types.Str[r'\d+']].__name__)
+        assert 'List' == types.List.__name__
+        assert 'List[int]' == types.List[int].__name__
+        assert ('Dict[str,List[int]]' ==
+                types.Dict[str, types.List[int]].__name__)
+        assert ('Tuple[int,Set[float],str]' ==
+                types.Tuple[int, types.Set[float], str].__name__)
+        assert r"List[Str[r'\d+']]" == types.List[types.Str[r'\d+']].__name__
 
     def test_custom_types(self):
         class C:
@@ -137,7 +138,7 @@ def __hash__(self):
         d = {0: C(0), 1: C(1)}
         cd = {C(0): 0, C(1): 1}
         t = (0, C(0), '1')
-        self.assertIsInstance(l, types.List[C])
-        self.assertIsInstance(d, types.Dict[int, C])
-        self.assertIsInstance(cd, types.Dict[C, int])
-        self.assertIsInstance(t, types.Tuple[int, C, str])
+        assert isinstance(l, types.List[C])
+        assert isinstance(d, types.Dict[int, C])
+        assert isinstance(cd, types.Dict[C, int])
+        assert isinstance(t, types.Tuple[int, C, str])
diff --git a/unittests/test_utility.py b/unittests/test_utility.py
index 60e654188e..099494a218 100644
--- a/unittests/test_utility.py
+++ b/unittests/test_utility.py
@@ -23,22 +23,22 @@
 class TestOSTools(unittest.TestCase):
     def test_command_success(self):
         completed = os_ext.run_command('echo foobar')
-        self.assertEqual(completed.returncode, 0)
-        self.assertEqual(completed.stdout, 'foobar\n')
+        assert completed.returncode == 0
+        assert completed.stdout == 'foobar\n'
 
     def test_command_error(self):
-        self.assertRaises(SpawnedProcessError, os_ext.run_command,
-                          'false', 'check=True')
+        with pytest.raises(SpawnedProcessError):
+            os_ext.run_command('false', check=True)
 
     def test_command_timeout(self):
         try:
             os_ext.run_command('sleep 3', timeout=2)
         except SpawnedProcessTimeout as e:
-            self.assertEqual(e.timeout, 2)
+            assert e.timeout == 2
             # Try to get the string repr. of the exception: see bug #658
             s = str(e)
         else:
-            self.fail('expected timeout')
+            pytest.fail('expected timeout')
 
     def test_command_async(self):
         from datetime import datetime
@@ -52,24 +52,24 @@ def test_command_async(self):
         t_sleep = datetime.now() - t_sleep
 
         # Now check the timings
-        self.assertLess(t_launch.seconds, 1)
-        self.assertGreaterEqual(t_sleep.seconds, 1)
+        assert t_launch.seconds < 1
+        assert t_sleep.seconds >= 1
 
     def test_grep(self):
-        self.assertTrue(os_ext.grep_command_output(cmd='echo hello',
-                                                   pattern='hello'))
-        self.assertFalse(os_ext.grep_command_output(cmd='echo hello',
-                                                    pattern='foo'))
+        assert os_ext.grep_command_output(cmd='echo hello', pattern='hello')
+        assert not os_ext.grep_command_output(cmd='echo hello', pattern='foo')
 
     def test_copytree(self):
         dir_src = tempfile.mkdtemp()
         dir_dst = tempfile.mkdtemp()
 
-        self.assertRaises(OSError, shutil.copytree, dir_src, dir_dst)
+        with pytest.raises(OSError):
+            shutil.copytree(dir_src, dir_dst)
+
         try:
             os_ext.copytree(dir_src, dir_dst)
         except Exception as e:
-            self.fail('custom copytree failed: %s' % e)
+            pytest.fail('custom copytree failed: %s' % e)
 
         shutil.rmtree(dir_src)
         shutil.rmtree(dir_dst)
@@ -78,8 +78,8 @@ def test_copytree_src_parent_of_dst(self):
         dst_path = tempfile.mkdtemp()
         src_path = os.path.abspath(os.path.join(dst_path, '..'))
 
-        self.assertRaises(ValueError, os_ext.copytree,
-                          src_path, dst_path)
+        with pytest.raises(ValueError):
+            os_ext.copytree(src_path, dst_path)
 
         shutil.rmtree(dst_path)
 
@@ -89,7 +89,7 @@ def _test_rmtree(self, *args, **kwargs):
             fp.write('hello\n')
 
         os_ext.rmtree(testdir, *args, **kwargs)
-        self.assertFalse(os.path.exists(testdir))
+        assert not os.path.exists(testdir)
 
     def test_rmtree(self):
         self._test_rmtree()
@@ -101,11 +101,12 @@ def test_rmtree_error(self):
         # Try to remove an inexistent directory
         testdir = tempfile.mkdtemp()
         os.rmdir(testdir)
-        self.assertRaises(OSError, os_ext.rmtree, testdir)
+        with pytest.raises(OSError):
+            os_ext.rmtree(testdir)
 
     def test_inpath(self):
-        self.assertTrue(os_ext.inpath('/foo/bin', '/bin:/foo/bin:/usr/bin'))
-        self.assertFalse(os_ext.inpath('/foo/bin', '/bin:/usr/local/bin'))
+        assert os_ext.inpath('/foo/bin', '/bin:/foo/bin:/usr/bin')
+        assert not os_ext.inpath('/foo/bin', '/bin:/usr/local/bin')
 
     def _make_testdirs(self, prefix):
         # Create a temporary directory structure
@@ -137,10 +138,10 @@ def test_subdirs(self):
                             os.path.join(prefix, 'loo', 'bar')}
 
         returned_subdirs = os_ext.subdirs(prefix)
-        self.assertEqual([prefix], returned_subdirs)
+        assert [prefix] == returned_subdirs
 
         returned_subdirs = os_ext.subdirs(prefix, recurse=True)
-        self.assertEqual(expected_subdirs, set(returned_subdirs))
+        assert expected_subdirs == set(returned_subdirs)
         shutil.rmtree(prefix)
 
     def test_samefile(self):
@@ -159,25 +160,24 @@ def test_samefile(self):
         os.symlink(os.path.join(prefix, 'broken'),
                    os.path.join(prefix, 'broken1'))
 
-        self.assertTrue(os_ext.samefile('/foo', '/foo'))
-        self.assertTrue(os_ext.samefile('/foo', '/foo/'))
-        self.assertTrue(os_ext.samefile('/foo/bar', '/foo//bar/'))
-        self.assertTrue(os_ext.samefile(os.path.join(prefix, 'foo'),
-                                        os.path.join(prefix, 'foolnk')))
-        self.assertTrue(os_ext.samefile(os.path.join(prefix, 'foo'),
-                                        os.path.join(prefix, 'foolnk1')))
-        self.assertFalse(os_ext.samefile('/foo', '/bar'))
-        self.assertTrue(os_ext.samefile(
-            '/foo', os.path.join(prefix, 'broken')))
-        self.assertTrue(os_ext.samefile(os.path.join(prefix, 'broken'),
-                                        os.path.join(prefix, 'broken1')))
+        assert os_ext.samefile('/foo', '/foo')
+        assert os_ext.samefile('/foo', '/foo/')
+        assert os_ext.samefile('/foo/bar', '/foo//bar/')
+        assert os_ext.samefile(os.path.join(prefix, 'foo'),
+                               os.path.join(prefix, 'foolnk'))
+        assert os_ext.samefile(os.path.join(prefix, 'foo'),
+                               os.path.join(prefix, 'foolnk1'))
+        assert not os_ext.samefile('/foo', '/bar')
+        assert os_ext.samefile('/foo', os.path.join(prefix, 'broken'))
+        assert os_ext.samefile(os.path.join(prefix, 'broken'),
+                               os.path.join(prefix, 'broken1'))
         shutil.rmtree(prefix)
 
     def test_is_url(self):
         repo_https = 'https://github.com/eth-cscs/reframe.git'
         repo_ssh = 'git@github.com:eth-cscs/reframe.git'
-        self.assertTrue(os_ext.is_url(repo_https))
-        self.assertFalse(os_ext.is_url(repo_ssh))
+        assert os_ext.is_url(repo_https)
+        assert not os_ext.is_url(repo_ssh)
 
     def test_git_repo_hash(self):
         # A git branch hash consists of 8(short) or 40 characters.
@@ -187,65 +187,65 @@ def test_git_repo_hash(self):
         assert os_ext.git_repo_hash(branch='') is None
 
     def test_git_repo_exists(self):
-        self.assertTrue(os_ext.git_repo_exists(
-            'https://github.com/eth-cscs/reframe.git', timeout=3))
-        self.assertFalse(os_ext.git_repo_exists('reframe.git', timeout=3))
-        self.assertFalse(os_ext.git_repo_exists(
-            'https://github.com/eth-cscs/xxx', timeout=3))
+        assert os_ext.git_repo_exists(
+            'https://github.com/eth-cscs/reframe.git', timeout=3)
+        assert not os_ext.git_repo_exists('reframe.git', timeout=3)
+        assert not os_ext.git_repo_exists(
+            'https://github.com/eth-cscs/xxx', timeout=3)
 
     def test_force_remove_file(self):
         with tempfile.NamedTemporaryFile(delete=False) as fp:
             pass
 
-        self.assertTrue(os.path.exists(fp.name))
+        assert os.path.exists(fp.name)
         os_ext.force_remove_file(fp.name)
-        self.assertFalse(os.path.exists(fp.name))
+        assert not os.path.exists(fp.name)
 
         # Try to remove a non-existent file
         os_ext.force_remove_file(fp.name)
 
     def test_expandvars_dollar(self):
         text = 'Hello, $(echo World)'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
         # Test nested expansion
         text = '$(echo Hello, $(echo World))'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
     def test_expandvars_backticks(self):
         text = 'Hello, `echo World`'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
         # Test nested expansion
         text = '`echo Hello, `echo World``'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
     def test_expandvars_mixed_syntax(self):
         text = '`echo Hello, $(echo World)`'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
         text = '$(echo Hello, `echo World`)'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
     def test_expandvars_error(self):
         text = 'Hello, $(foo)'
-        with self.assertRaises(SpawnedProcessError):
+        with pytest.raises(SpawnedProcessError):
             os_ext.expandvars(text)
 
     def test_strange_syntax(self):
         text = 'Hello, $(foo`'
-        self.assertEqual('Hello, $(foo`', os_ext.expandvars(text))
+        assert 'Hello, $(foo`' == os_ext.expandvars(text)
 
         text = 'Hello, `foo)'
-        self.assertEqual('Hello, `foo)', os_ext.expandvars(text))
+        assert 'Hello, `foo)' == os_ext.expandvars(text)
 
     def test_expandvars_nocmd(self):
         os.environ['FOO'] = 'World'
         text = 'Hello, $FOO'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
 
         text = 'Hello, ${FOO}'
-        self.assertEqual('Hello, World', os_ext.expandvars(text))
+        assert 'Hello, World' == os_ext.expandvars(text)
         del os.environ['FOO']
 
 
@@ -276,23 +276,19 @@ def setUp(self):
 
     def verify_target_directory(self, file_links=[]):
         '''Verify the directory structure'''
-        self.assertTrue(
-            os.path.exists(os.path.join(self.target, 'bar', 'bar.txt')))
-        self.assertTrue(
-            os.path.exists(os.path.join(self.target, 'bar', 'foo.txt')))
-        self.assertTrue(
-            os.path.exists(os.path.join(self.target, 'bar', 'foobar.txt')))
-        self.assertTrue(
-            os.path.exists(os.path.join(self.target, 'foo', 'bar.txt')))
-        self.assertTrue(os.path.exists(os.path.join(self.target, 'bar.txt')))
-        self.assertTrue(os.path.exists(os.path.join(self.target, 'foo.txt')))
+        assert os.path.exists(os.path.join(self.target, 'bar', 'bar.txt'))
+        assert os.path.exists(os.path.join(self.target, 'bar', 'foo.txt'))
+        assert os.path.exists(os.path.join(self.target, 'bar', 'foobar.txt'))
+        assert os.path.exists(os.path.join(self.target, 'foo', 'bar.txt'))
+        assert os.path.exists(os.path.join(self.target, 'bar.txt'))
+        assert os.path.exists(os.path.join(self.target, 'foo.txt'))
 
         # Verify the symlinks
         for lf in file_links:
             target_name = os.path.abspath(os.path.join(self.prefix, lf))
             link_name = os.path.abspath(os.path.join(self.target, lf))
-            self.assertTrue(os.path.islink(link_name))
-            self.assertEqual(target_name, os.readlink(link_name))
+            assert os.path.islink(link_name)
+            assert target_name == os.readlink(link_name)
 
     def test_virtual_copy_nolinks(self):
         os_ext.copytree_virtual(self.prefix, self.target)
@@ -305,28 +301,28 @@ def test_virtual_copy_valid_links(self):
 
     def test_virtual_copy_inexistent_links(self):
         file_links = ['foobar/', 'foo/bar.txt', 'foo.txt']
-        self.assertRaises(ValueError, os_ext.copytree_virtual,
-                          self.prefix, self.target, file_links)
+        with pytest.raises(ValueError):
+            os_ext.copytree_virtual(self.prefix, self.target, file_links)
 
     def test_virtual_copy_absolute_paths(self):
         file_links = [os.path.join(self.prefix, 'bar'),
                       'foo/bar.txt', 'foo.txt']
-        self.assertRaises(ValueError, os_ext.copytree_virtual,
-                          self.prefix, self.target, file_links)
+        with pytest.raises(ValueError):
+            os_ext.copytree_virtual(self.prefix, self.target, file_links)
 
     def test_virtual_copy_irrelevenant_paths(self):
         file_links = ['/bin', 'foo/bar.txt', 'foo.txt']
-        self.assertRaises(ValueError, os_ext.copytree_virtual,
-                          self.prefix, self.target, file_links)
+        with pytest.raises(ValueError):
+            os_ext.copytree_virtual(self.prefix, self.target, file_links)
 
         file_links = [os.path.dirname(self.prefix), 'foo/bar.txt', 'foo.txt']
-        self.assertRaises(ValueError, os_ext.copytree_virtual,
-                          self.prefix, self.target, file_links)
+        with pytest.raises(ValueError):
+            os_ext.copytree_virtual(self.prefix, self.target, file_links)
 
     def test_virtual_copy_linkself(self):
         file_links = ['.']
-        self.assertRaises(OSError, os_ext.copytree_virtual,
-                          self.prefix, self.target, file_links)
+        with pytest.raises(OSError):
+            os_ext.copytree_virtual(self.prefix, self.target, file_links)
 
     def tearDown(self):
         shutil.rmtree(self.prefix)
@@ -336,50 +332,50 @@ def tearDown(self):
 class TestImportFromFile(unittest.TestCase):
     def test_load_relpath(self):
         module = util.import_module_from_file('reframe/__init__.py')
-        self.assertEqual(reframe.VERSION, module.VERSION)
-        self.assertEqual('reframe', module.__name__)
-        self.assertIs(module, sys.modules.get('reframe'))
+        assert reframe.VERSION == module.VERSION
+        assert 'reframe' == module.__name__
+        assert module is sys.modules.get('reframe')
 
     def test_load_directory(self):
         module = util.import_module_from_file('reframe')
-        self.assertEqual(reframe.VERSION, module.VERSION)
-        self.assertEqual('reframe', module.__name__)
-        self.assertIs(module, sys.modules.get('reframe'))
+        assert reframe.VERSION == module.VERSION
+        assert 'reframe' == module.__name__
+        assert module is sys.modules.get('reframe')
 
     def test_load_abspath(self):
         filename = os.path.abspath('reframe/__init__.py')
         module = util.import_module_from_file(filename)
-        self.assertEqual(reframe.VERSION, module.VERSION)
-        self.assertEqual('reframe', module.__name__)
-        self.assertIs(module, sys.modules.get('reframe'))
+        assert reframe.VERSION == module.VERSION
+        assert 'reframe' == module.__name__
+        assert module is sys.modules.get('reframe')
 
     def test_load_unknown_path(self):
         try:
             util.import_module_from_file('/foo')
-            self.fail()
+            pytest.fail()
         except ImportError as e:
-            self.assertEqual('foo', e.name)
-            self.assertEqual('/foo', e.path)
+            assert 'foo' == e.name
+            assert '/foo' == e.path
 
     def test_load_directory_relative(self):
         with os_ext.change_dir('reframe'):
             module = util.import_module_from_file('../reframe')
-            self.assertEqual(reframe.VERSION, module.VERSION)
-            self.assertEqual('reframe', module.__name__)
-            self.assertIs(module, sys.modules.get('reframe'))
+            assert reframe.VERSION == module.VERSION
+            assert 'reframe' == module.__name__
+            assert module is sys.modules.get('reframe')
 
     def test_load_relative(self):
         with os_ext.change_dir('reframe'):
             # Load a module from a directory up
             module = util.import_module_from_file('../reframe/__init__.py')
-            self.assertEqual(reframe.VERSION, module.VERSION)
-            self.assertEqual('reframe', module.__name__)
-            self.assertIs(module, sys.modules.get('reframe'))
+            assert reframe.VERSION == module.VERSION
+            assert 'reframe' == module.__name__
+            assert module is sys.modules.get('reframe')
 
             # Load a module from the current directory
             module = util.import_module_from_file('utility/os_ext.py')
-            self.assertEqual('reframe.utility.os_ext', module.__name__)
-            self.assertIs(module, sys.modules.get('reframe.utility.os_ext'))
+            assert 'reframe.utility.os_ext' == module.__name__
+            assert module is sys.modules.get('reframe.utility.os_ext')
 
     def test_load_outside_pkg(self):
         module = util.import_module_from_file(os.path.__file__)
@@ -387,32 +383,31 @@ def test_load_outside_pkg(self):
         # os imports the OS-specific path libraries under the name `path`. Our
         # importer will import the actual file, thus the module name should be
         # the real one.
-        self.assertTrue(module is sys.modules.get('posixpath') or
-                        module is sys.modules.get('ntpath') or
-                        module is sys.modules.get('macpath'))
+        assert (module is sys.modules.get('posixpath') or
+                module is sys.modules.get('ntpath') or
+                module is sys.modules.get('macpath'))
 
     def test_load_twice(self):
         filename = os.path.abspath('reframe')
         module1 = util.import_module_from_file(filename)
         module2 = util.import_module_from_file(filename)
-        self.assertIs(module1, module2)
+        assert module1 is module2
 
     def test_load_namespace_package(self):
         module = util.import_module_from_file('unittests/resources')
-        self.assertIn('unittests', sys.modules)
-        self.assertIn('unittests.resources', sys.modules)
+        assert 'unittests' in sys.modules
+        assert 'unittests.resources' in sys.modules
 
 
 class TestDebugRepr(unittest.TestCase):
     def test_builtin_types(self):
         # builtin types must use the default repr()
-        self.assertEqual(repr(1), debug.repr(1))
-        self.assertEqual(repr(1.2), debug.repr(1.2))
-        self.assertEqual(repr([1, 2, 3]), debug.repr([1, 2, 3]))
-        self.assertEqual(repr({1, 2, 3}), debug.repr({1, 2, 3}))
-        self.assertEqual(repr({1, 2, 3}), debug.repr({1, 2, 3}))
-        self.assertEqual(repr({'a': 1, 'b': {2, 3}}),
-                         debug.repr({'a': 1, 'b': {2, 3}}))
+        assert repr(1) == debug.repr(1)
+        assert repr(1.2) == debug.repr(1.2)
+        assert repr([1, 2, 3]) == debug.repr([1, 2, 3])
+        assert repr({1, 2, 3}) == debug.repr({1, 2, 3})
+        assert repr({1, 2, 3}) == debug.repr({1, 2, 3})
+        assert repr({'a': 1, 'b': {2, 3}}) == debug.repr({'a': 1, 'b': {2, 3}})
 
     def test_obj_repr(self):
         class C:
@@ -432,10 +427,10 @@ def __repr__(self):
         c.d.b = 3
 
         rep = repr(c)
-        self.assertIn('unittests.test_utility', rep)
-        self.assertIn('_a=%r' % c._a, rep)
-        self.assertIn('b=%r' % c.b, rep)
-        self.assertIn('D(...)', rep)
+        assert 'unittests.test_utility' in rep
+        assert '_a=%r' % c._a in rep
+        assert 'b=%r' % c.b in rep
+        assert 'D(...)' in rep
 
 
 class TestChangeDirCtxManager(unittest.TestCase):
@@ -445,17 +440,18 @@ def setUp(self):
 
     def test_change_dir_working(self):
         with os_ext.change_dir(self.temp_dir):
-            self.assertTrue(os.getcwd(), self.temp_dir)
-        self.assertEqual(os.getcwd(), self.wd_save)
+            assert os.getcwd(), self.temp_dir
+
+        assert os.getcwd() == self.wd_save
 
     def test_exception_propagation(self):
         try:
             with os_ext.change_dir(self.temp_dir):
                 raise RuntimeError
         except RuntimeError:
-            self.assertEqual(os.getcwd(), self.wd_save)
+            assert os.getcwd() == self.wd_save
         else:
-            self.fail('exception not propagated by the ctx manager')
+            pytest.fail('exception not propagated by the ctx manager')
 
     def tearDown(self):
         os.rmdir(self.temp_dir)
@@ -465,33 +461,39 @@ class TestMiscUtilities(unittest.TestCase):
     def test_allx(self):
         l1 = [1, 1, 1]
         l2 = [True, False]
-        self.assertTrue(all(l1), util.allx(l1))
-        self.assertFalse(all(l2), util.allx(l2))
-        self.assertFalse(util.allx([]))
-        self.assertTrue(util.allx(i for i in [1, 1, 1]))
-        self.assertTrue(util.allx(i for i in range(1, 2)))
-        self.assertFalse(util.allx(i for i in range(1)))
-        self.assertFalse(util.allx(i for i in range(0)))
-        with self.assertRaises(TypeError):
+        assert all(l1), util.allx(l1)
+        assert not all(l2), util.allx(l2)
+        assert not util.allx([])
+        assert util.allx(i for i in [1, 1, 1])
+        assert util.allx(i for i in range(1, 2))
+        assert not util.allx(i for i in range(1))
+        assert not util.allx(i for i in range(0))
+        with pytest.raises(TypeError):
             util.allx(None)
 
     def test_decamelize(self):
-        self.assertEqual('', util.decamelize(''))
-        self.assertEqual('my_base_class', util.decamelize('MyBaseClass'))
-        self.assertEqual('my_base_class12', util.decamelize('MyBaseClass12'))
-        self.assertEqual('my_class_a', util.decamelize('MyClass_A'))
-        self.assertEqual('my_class', util.decamelize('my_class'))
-        self.assertRaises(TypeError, util.decamelize, None)
-        self.assertRaises(TypeError, util.decamelize, 12)
+        assert '' == util.decamelize('')
+        assert 'my_base_class' == util.decamelize('MyBaseClass')
+        assert 'my_base_class12' == util.decamelize('MyBaseClass12')
+        assert 'my_class_a' == util.decamelize('MyClass_A')
+        assert 'my_class' == util.decamelize('my_class')
+        with pytest.raises(TypeError):
+            util.decamelize(None)
+
+        with pytest.raises(TypeError):
+            util.decamelize(12)
 
     def test_sanitize(self):
-        self.assertEqual('', util.toalphanum(''))
-        self.assertEqual('ab12', util.toalphanum('ab12'))
-        self.assertEqual('ab1_2', util.toalphanum('ab1_2'))
-        self.assertEqual('ab1__2', util.toalphanum('ab1**2'))
-        self.assertEqual('ab__12_', util.toalphanum('ab (12)'))
-        self.assertRaises(TypeError, util.toalphanum, None)
-        self.assertRaises(TypeError, util.toalphanum, 12)
+        assert '' == util.toalphanum('')
+        assert 'ab12' == util.toalphanum('ab12')
+        assert 'ab1_2' == util.toalphanum('ab1_2')
+        assert 'ab1__2' == util.toalphanum('ab1**2')
+        assert 'ab__12_' == util.toalphanum('ab (12)')
+        with pytest.raises(TypeError):
+            util.toalphanum(None)
+
+        with pytest.raises(TypeError):
+            util.toalphanum(12)
 
 
 class TestScopedDict(unittest.TestCase):
@@ -506,18 +508,22 @@ def test_construction(self):
         # Change local dict and verify that the stored values are not affected
         d['a']['k1'] = 10
         d['b']['k3'] = 10
-        self.assertEqual(3, namespace_dict['a:k1'])
-        self.assertEqual(5, namespace_dict['b:k3'])
+        assert 3 == namespace_dict['a:k1']
+        assert 5 == namespace_dict['b:k3']
         del d['b']
-        self.assertIn('b:k3', namespace_dict)
+        assert 'b:k3' in namespace_dict
 
-        self.assertRaises(TypeError, reframe.utility.ScopedDict, 1)
-        self.assertRaises(TypeError, reframe.utility.ScopedDict,
-                          {'a': 1, 'b': 2})
-        self.assertRaises(TypeError, reframe.utility.ScopedDict,
-                          [('a', 1), ('b', 2)])
-        self.assertRaises(TypeError, reframe.utility.ScopedDict,
-                          {'a': {1: 'k1'}, 'b': {2: 'k2'}})
+        with pytest.raises(TypeError):
+            reframe.utility.ScopedDict(1)
+
+        with pytest.raises(TypeError):
+            reframe.utility.ScopedDict({'a': 1, 'b': 2})
+
+        with pytest.raises(TypeError):
+            reframe.utility.ScopedDict([('a', 1), ('b', 2)])
+
+        with pytest.raises(TypeError):
+            reframe.utility.ScopedDict({'a': {1: 'k1'}, 'b': {2: 'k2'}})
 
     def test_contains(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -528,44 +534,44 @@ def test_contains(self):
         })
 
         # Test simple lookup
-        self.assertIn('a:k1', scoped_dict)
-        self.assertIn('a:k2', scoped_dict)
-        self.assertIn('a:k3', scoped_dict)
-        self.assertIn('a:k4', scoped_dict)
+        assert 'a:k1' in scoped_dict
+        assert 'a:k2' in scoped_dict
+        assert 'a:k3' in scoped_dict
+        assert 'a:k4' in scoped_dict
 
-        self.assertIn('a:b:k1', scoped_dict)
-        self.assertIn('a:b:k2', scoped_dict)
-        self.assertIn('a:b:k3', scoped_dict)
-        self.assertIn('a:b:k4', scoped_dict)
+        assert 'a:b:k1' in scoped_dict
+        assert 'a:b:k2' in scoped_dict
+        assert 'a:b:k3' in scoped_dict
+        assert 'a:b:k4' in scoped_dict
 
-        self.assertIn('a:b:c:k1', scoped_dict)
-        self.assertIn('a:b:c:k1', scoped_dict)
-        self.assertIn('a:b:c:k1', scoped_dict)
-        self.assertIn('a:b:c:k1', scoped_dict)
+        assert 'a:b:c:k1' in scoped_dict
+        assert 'a:b:c:k2' in scoped_dict
+        assert 'a:b:c:k3' in scoped_dict
+        assert 'a:b:c:k4' in scoped_dict
 
         # Test global scope
-        self.assertIn('k1', scoped_dict)
-        self.assertNotIn('k2', scoped_dict)
-        self.assertIn('k3', scoped_dict)
-        self.assertIn('k4', scoped_dict)
+        assert 'k1' in scoped_dict
+        assert 'k2' not in scoped_dict
+        assert 'k3' in scoped_dict
+        assert 'k4' in scoped_dict
 
-        self.assertIn(':k1', scoped_dict)
-        self.assertNotIn(':k2', scoped_dict)
-        self.assertIn(':k3', scoped_dict)
-        self.assertIn(':k4', scoped_dict)
+        assert ':k1' in scoped_dict
+        assert ':k2' not in scoped_dict
+        assert ':k3' in scoped_dict
+        assert ':k4' in scoped_dict
 
-        self.assertIn('*:k1', scoped_dict)
-        self.assertNotIn('*:k2', scoped_dict)
-        self.assertIn('*:k3', scoped_dict)
-        self.assertIn('*:k4', scoped_dict)
+        assert '*:k1' in scoped_dict
+        assert '*:k2' not in scoped_dict
+        assert '*:k3' in scoped_dict
+        assert '*:k4' in scoped_dict
 
         # Try to get full scopes as keys
-        self.assertNotIn('a', scoped_dict)
-        self.assertNotIn('a:b', scoped_dict)
-        self.assertNotIn('a:b:c', scoped_dict)
-        self.assertNotIn('a:b:c:d', scoped_dict)
-        self.assertNotIn('*', scoped_dict)
-        self.assertNotIn('', scoped_dict)
+        assert 'a' not in scoped_dict
+        assert 'a:b' not in scoped_dict
+        assert 'a:b:c' not in scoped_dict
+        assert 'a:b:c:d' not in scoped_dict
+        assert '*' not in scoped_dict
+        assert '' not in scoped_dict
 
     def test_iter_keys(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -581,8 +587,7 @@ def test_iter_keys(self):
             'a:b:c:k2', 'a:b:c:k3',
             '*:k1', '*:k3', '*:k4'
         ]
-        self.assertEqual(sorted(expected_keys),
-                         sorted(k for k in scoped_dict.keys()))
+        assert sorted(expected_keys) == sorted(k for k in scoped_dict.keys())
 
     def test_iter_items(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -598,8 +603,8 @@ def test_iter_items(self):
             ('a:b:c:k2', 5), ('a:b:c:k3', 6),
             ('*:k1', 7), ('*:k3', 9), ('*:k4', 10)
         ]
-        self.assertEqual(sorted(expected_items),
-                         sorted(item for item in scoped_dict.items()))
+        assert (sorted(expected_items) ==
+                sorted(item for item in scoped_dict.items()))
 
     def test_iter_values(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -610,8 +615,7 @@ def test_iter_values(self):
         })
 
         expected_values = [1, 2, 3, 4, 5, 6, 7, 9, 10]
-        self.assertEqual(expected_values,
-                         sorted(v for v in scoped_dict.values()))
+        assert expected_values == sorted(v for v in scoped_dict.values())
 
     def test_key_resolution(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -621,62 +625,61 @@ def test_key_resolution(self):
             '*': {'k1': 7, 'k3': 9, 'k4': 10}
         })
 
-        self.assertEqual(1, scoped_dict['a:k1'])
-        self.assertEqual(2, scoped_dict['a:k2'])
-        self.assertEqual(9, scoped_dict['a:k3'])
-        self.assertEqual(10, scoped_dict['a:k4'])
+        assert 1 == scoped_dict['a:k1']
+        assert 2 == scoped_dict['a:k2']
+        assert 9 == scoped_dict['a:k3']
+        assert 10 == scoped_dict['a:k4']
 
-        self.assertEqual(3, scoped_dict['a:b:k1'])
-        self.assertEqual(2, scoped_dict['a:b:k2'])
-        self.assertEqual(4, scoped_dict['a:b:k3'])
-        self.assertEqual(10, scoped_dict['a:b:k4'])
+        assert 3 == scoped_dict['a:b:k1']
+        assert 2 == scoped_dict['a:b:k2']
+        assert 4 == scoped_dict['a:b:k3']
+        assert 10 == scoped_dict['a:b:k4']
 
-        self.assertEqual(3, scoped_dict['a:b:c:k1'])
-        self.assertEqual(5, scoped_dict['a:b:c:k2'])
-        self.assertEqual(6, scoped_dict['a:b:c:k3'])
-        self.assertEqual(10, scoped_dict['a:b:c:k4'])
+        assert 3 == scoped_dict['a:b:c:k1']
+        assert 5 == scoped_dict['a:b:c:k2']
+        assert 6 == scoped_dict['a:b:c:k3']
+        assert 10 == scoped_dict['a:b:c:k4']
 
         # Test global scope
-        self.assertEqual(7, scoped_dict['k1'])
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['k2']", globals(), locals()
-        )
-        self.assertEqual(9, scoped_dict['k3'])
-        self.assertEqual(10, scoped_dict['k4'])
-
-        self.assertEqual(7, scoped_dict[':k1'])
-        self.assertRaises(
-            KeyError, exec, "scoped_dict[':k2']", globals(), locals()
-        )
-        self.assertEqual(9, scoped_dict[':k3'])
-        self.assertEqual(10, scoped_dict[':k4'])
-
-        self.assertEqual(7, scoped_dict['*:k1'])
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['*:k2']", globals(), locals()
-        )
-        self.assertEqual(9, scoped_dict['*:k3'])
-        self.assertEqual(10, scoped_dict['*:k4'])
+        assert 7 == scoped_dict['k1']
+        with pytest.raises(KeyError):
+            scoped_dict['k2']
+
+        assert 9 == scoped_dict['k3']
+        assert 10 == scoped_dict['k4']
+
+        assert 7 == scoped_dict[':k1']
+        with pytest.raises(KeyError):
+            scoped_dict[':k2']
+
+        assert 9 == scoped_dict[':k3']
+        assert 10 == scoped_dict[':k4']
+
+        assert 7 == scoped_dict['*:k1']
+        with pytest.raises(KeyError):
+            scoped_dict['*:k2']
+
+        assert 9 == scoped_dict['*:k3']
+        assert 10 == scoped_dict['*:k4']
 
         # Try to fool it, by requesting keys with scope names
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['a']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['a:b']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['a:b:c']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['a:b:c:d']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['*']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['']", globals(), locals()
-        )
+        with pytest.raises(KeyError):
+            scoped_dict['a']
+
+        with pytest.raises(KeyError):
+            scoped_dict['a:b']
+
+        with pytest.raises(KeyError):
+            scoped_dict['a:b:c']
+
+        with pytest.raises(KeyError):
+            scoped_dict['a:b:c:d']
+
+        with pytest.raises(KeyError):
+            scoped_dict['*']
+
+        with pytest.raises(KeyError):
+            scoped_dict['']
 
     def test_setitem(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -691,11 +694,11 @@ def test_setitem(self):
         scoped_dict[':k4'] = 40
         scoped_dict['*:k5'] = 50
         scoped_dict['k6'] = 60
-        self.assertEqual(20, scoped_dict['a:k2'])
-        self.assertEqual(30, scoped_dict['c:k2'])
-        self.assertEqual(40, scoped_dict[':k4'])
-        self.assertEqual(50, scoped_dict['k5'])
-        self.assertEqual(60, scoped_dict['k6'])
+        assert 20 == scoped_dict['a:k2']
+        assert 30 == scoped_dict['c:k2']
+        assert 40 == scoped_dict[':k4']
+        assert 50 == scoped_dict['k5']
+        assert 60 == scoped_dict['k6']
 
     def test_delitem(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -707,29 +710,26 @@ def test_delitem(self):
 
         # delete key
         del scoped_dict['a:k1']
-        self.assertEqual(7, scoped_dict['a:k1'])
+        assert 7 == scoped_dict['a:k1']
 
         # delete key from global scope
         del scoped_dict['k1']
-        self.assertEqual(9, scoped_dict['k3'])
-        self.assertEqual(10, scoped_dict['k4'])
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['k1']", globals(), locals()
-        )
+        assert 9 == scoped_dict['k3']
+        assert 10 == scoped_dict['k4']
+        with pytest.raises(KeyError):
+            scoped_dict['k1']
 
         # delete a whole scope
         del scoped_dict['*']
-        self.assertRaises(
-            KeyError, exec, "scoped_dict[':k4']", globals(), locals()
-        )
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['a:k3']", globals(), locals()
-        )
+        with pytest.raises(KeyError):
+            scoped_dict[':k4']
+
+        with pytest.raises(KeyError):
+            scoped_dict['a:k3']
 
         # try to delete a non-existent key
-        self.assertRaises(
-            KeyError, exec, "del scoped_dict['a:k4']", globals(), locals()
-        )
+        with pytest.raises(KeyError):
+            del scoped_dict['a:k4']
 
         # test deletion of parent scope keeping a nested one
         scoped_dict = reframe.utility.ScopedDict()
@@ -737,8 +737,8 @@ def test_delitem(self):
         scoped_dict['s0:s1:k0'] = 2
         scoped_dict['*:k0'] = 3
         del scoped_dict['s0']
-        self.assertEqual(3, scoped_dict['s0:k0'])
-        self.assertEqual(2, scoped_dict['s0:s1:k0'])
+        assert 3 == scoped_dict['s0:k0']
+        assert 2 == scoped_dict['s0:s1:k0']
 
     def test_scope_key_name_pseudoconflict(self):
         scoped_dict = reframe.utility.ScopedDict({
@@ -746,14 +746,13 @@ def test_scope_key_name_pseudoconflict(self):
             's0:s1': {'k0': 2}
         })
 
-        self.assertEqual(1, scoped_dict['s0:s1'])
-        self.assertEqual(2, scoped_dict['s0:s1:k0'])
+        assert 1 == scoped_dict['s0:s1']
+        assert 2 == scoped_dict['s0:s1:k0']
 
         del scoped_dict['s0:s1']
-        self.assertEqual(2, scoped_dict['s0:s1:k0'])
-        self.assertRaises(
-            KeyError, exec, "scoped_dict['s0:s1']", globals(), locals()
-        )
+        assert 2 == scoped_dict['s0:s1:k0']
+        with pytest.raises(KeyError):
+            scoped_dict['s0:s1']
 
     def test_update(self):
         scoped_dict = util.ScopedDict({
@@ -770,106 +769,106 @@ def test_update(self):
             'a:b:c': {'k2': 5, 'k3': 6},
             '*': {'k1': 7, 'k3': 9, 'k4': 10}
         })
-        self.assertEqual(scoped_dict, scoped_dict_alt)
+        assert scoped_dict == scoped_dict_alt
 
 
 class TestReadOnlyViews(unittest.TestCase):
     def test_sequence(self):
         l = util.SequenceView([1, 2, 2])
-        self.assertEqual(1, l[0])
-        self.assertEqual(3, len(l))
-        self.assertIn(2, l)
-        self.assertEqual(l, [1, 2, 2])
-        self.assertEqual(l, util.SequenceView([1, 2, 2]))
-        self.assertEqual(list(reversed(l)), [2, 2, 1])
-        self.assertEqual(1, l.index(2))
-        self.assertEqual(2, l.count(2))
-        self.assertEqual(str(l), str([1, 2, 2]))
+        assert 1 == l[0]
+        assert 3 == len(l)
+        assert 2 in l
+        assert l == [1, 2, 2]
+        assert l == util.SequenceView([1, 2, 2])
+        assert list(reversed(l)) == [2, 2, 1]
+        assert 1 == l.index(2)
+        assert 2 == l.count(2)
+        assert str(l) == str([1, 2, 2])
 
         # Assert immutability
         m = l + [3, 4]
-        self.assertEqual([1, 2, 2, 3, 4], m)
-        self.assertIsInstance(m, util.SequenceView)
+        assert [1, 2, 2, 3, 4] == m
+        assert isinstance(m, util.SequenceView)
 
         m = l
         l += [3, 4]
-        self.assertIsNot(m, l)
-        self.assertEqual([1, 2, 2], m)
-        self.assertEqual([1, 2, 2, 3, 4], l)
-        self.assertIsInstance(l, util.SequenceView)
+        assert m is not l
+        assert [1, 2, 2] == m
+        assert [1, 2, 2, 3, 4] == l
+        assert isinstance(l, util.SequenceView)
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             l[1] = 3
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             l[1:2] = [3]
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             l *= 3
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             del l[:1]
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.append(3)
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.clear()
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             s = l.copy()
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.extend([3, 4])
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.insert(1, 4)
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.pop()
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.remove(2)
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             l.reverse()
 
     def test_mapping(self):
         d = util.MappingView({'a': 1, 'b': 2})
-        self.assertEqual(1, d['a'])
-        self.assertEqual(2, len(d))
-        self.assertEqual({'a': 1, 'b': 2}, dict(d))
-        self.assertIn('b', d)
-        self.assertEqual({'a', 'b'}, set(d.keys()))
-        self.assertEqual({1, 2}, set(d.values()))
-        self.assertEqual({('a', 1), ('b', 2)}, set(d.items()))
-        self.assertEqual(2, d.get('b'))
-        self.assertEqual(3, d.get('c', 3))
-        self.assertEqual({'a': 1, 'b': 2}, d)
-        self.assertEqual(d, util.MappingView({'b': 2, 'a': 1}))
-        self.assertEqual(str(d), str({'a': 1, 'b': 2}))
-        self.assertNotEqual({'a': 1, 'b': 2, 'c': 3}, d)
+        assert 1 == d['a']
+        assert 2 == len(d)
+        assert {'a': 1, 'b': 2} == dict(d)
+        assert 'b' in d
+        assert {'a', 'b'} == set(d.keys())
+        assert {1, 2} == set(d.values())
+        assert {('a', 1), ('b', 2)} == set(d.items())
+        assert 2 == d.get('b')
+        assert 3 == d.get('c', 3)
+        assert {'a': 1, 'b': 2} == d
+        assert d == util.MappingView({'b': 2, 'a': 1})
+        assert str(d) == str({'a': 1, 'b': 2})
+        assert {'a': 1, 'b': 2, 'c': 3} != d
 
         # Assert immutability
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             d['c'] = 3
 
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             del d['b']
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             d.pop('a')
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             d.popitem()
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             d.clear()
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             d.update({'a': 4, 'b': 5})
 
-        with self.assertRaises(AttributeError):
+        with pytest.raises(AttributeError):
             d.setdefault('c', 3)
 
 
diff --git a/unittests/test_versioning.py b/unittests/test_versioning.py
index a4887ccd33..7111358acd 100644
--- a/unittests/test_versioning.py
+++ b/unittests/test_versioning.py
@@ -3,6 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import pytest
 import unittest
 
 from reframe.frontend.loader import RegressionCheckLoader
@@ -16,39 +17,66 @@ def test_version_format(self):
         Version('1.2-dev0')
         Version('1.2-dev5')
         Version('1.2.3-dev2')
-        self.assertRaises(ValueError, Version, None)
-        self.assertRaises(ValueError, Version, '')
-        self.assertRaises(ValueError, Version, '1')
-        self.assertRaises(ValueError, Version, '1.2a')
-        self.assertRaises(ValueError, Version, 'a.b.c')
-        self.assertRaises(ValueError, Version, '1.2.3-dev')
+        with pytest.raises(ValueError):
+            Version(None)
+
+        with pytest.raises(ValueError):
+            Version('')
+
+        with pytest.raises(ValueError):
+            Version('1')
+
+        with pytest.raises(ValueError):
+            Version('1.2a')
+
+        with pytest.raises(ValueError):
+            Version('a.b.c')
+
+        with pytest.raises(ValueError):
+            Version('1.2.3-dev')
 
     def test_comparing_versions(self):
-        self.assertLess(Version('1.2'), Version('1.2.1'))
-        self.assertLess(Version('1.2.1'), Version('1.2.2'))
-        self.assertLess(Version('1.2.2'), Version('1.3-dev0'))
-        self.assertLess(Version('1.3-dev0'), Version('1.3-dev1'))
-        self.assertLess(Version('1.3-dev1'), Version('1.3'))
-        self.assertEqual(Version('1.3'), Version('1.3.0'))
-        self.assertEqual(Version('1.3-dev1'), Version('1.3.0-dev1'))
-        self.assertGreater(Version('1.12.3'), Version('1.2.3'))
-        self.assertGreater(Version('1.2.23'), Version('1.2.3'))
+        assert Version('1.2') < Version('1.2.1')
+        assert Version('1.2.1') < Version('1.2.2')
+        assert Version('1.2.2') < Version('1.3-dev0')
+        assert Version('1.3-dev0') < Version('1.3-dev1')
+        assert Version('1.3-dev1') < Version('1.3')
+        assert Version('1.3') == Version('1.3.0')
+        assert Version('1.3-dev1') == Version('1.3.0-dev1')
+        assert Version('1.12.3') > Version('1.2.3')
+        assert Version('1.2.23') > Version('1.2.3')
 
     def test_version_validation(self):
         conditions = [VersionValidator('<=1.0.0'),
                       VersionValidator('2.0.0..2.5'),
                       VersionValidator('3.0')]
-        self.assertTrue(any(c.validate('0.1') for c in conditions))
-        self.assertTrue(any(c.validate('2.0.0') for c in conditions))
-        self.assertTrue(any(c.validate('2.2') for c in conditions))
-        self.assertTrue(any(c.validate('2.5') for c in conditions))
-        self.assertTrue(any(c.validate('3.0') for c in conditions))
-        self.assertFalse(any(c.validate('3.1') for c in conditions))
-        self.assertRaises(ValueError, VersionValidator, '2.0.0..')
-        self.assertRaises(ValueError, VersionValidator, '..2.0.0')
-        self.assertRaises(ValueError, VersionValidator, '1.0.0..2.0.0..3.0.0')
-        self.assertRaises(ValueError, VersionValidator, '=>2.0.0')
-        self.assertRaises(ValueError, VersionValidator, '2.0.0>')
-        self.assertRaises(ValueError, VersionValidator, '2.0.0>1.0.0')
-        self.assertRaises(ValueError, VersionValidator, '=>')
-        self.assertRaises(ValueError, VersionValidator, '>1')
+
+        assert all([any(c.validate('0.1') for c in conditions),
+                    any(c.validate('2.0.0') for c in conditions),
+                    any(c.validate('2.2') for c in conditions),
+                    any(c.validate('2.5') for c in conditions),
+                    any(c.validate('3.0') for c in conditions),
+                    not any(c.validate('3.1') for c in conditions)])
+        with pytest.raises(ValueError):
+            VersionValidator('2.0.0..')
+
+        with pytest.raises(ValueError):
+            VersionValidator('..2.0.0')
+
+        with pytest.raises(ValueError):
+            VersionValidator('1.0.0..2.0.0..3.0.0')
+
+        with pytest.raises(ValueError):
+            VersionValidator('=>2.0.0')
+
+        with pytest.raises(ValueError):
+            VersionValidator('2.0.0>')
+
+        with pytest.raises(ValueError):
+            VersionValidator('2.0.0>1.0.0')
+
+        with pytest.raises(ValueError):
+            VersionValidator('=>')
+
+        with pytest.raises(ValueError):
+            VersionValidator('>1')