refactor: unittest2pytest -w tests

One step of moving to pure pytest tests.

1 files changed, 126 insertions, 129 deletions

diff --git a/tests/test_summary.py b/tests/test_summary.py
index feaa0fe0..f2c75317 100644
--- a/tests/test_summary.py
+++ b/tests/test_summary.py
@@ -19,6 +19,7 @@ from coverage.misc import CoverageException, output_encoding
 from coverage.summary import SummaryReporter
 
 from tests.coveragetest import CoverageTest, TESTS_DIR, UsingModulesMixin
+import pytest
 
 
 class SummaryTest(UsingModulesMixin, CoverageTest):
@@ -44,7 +45,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
     def test_report(self):
         self.make_mycode()
         out = self.run_command("coverage run mycode.py")
-        self.assertEqual(out, 'done\n')
+        assert out == 'done\n'
         report = self.report_from_command("coverage report")
 
         # Name                                           Stmts   Miss  Cover
@@ -55,11 +56,11 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # ------------------------------------------------------------------
         # TOTAL                                              8      0   100%
 
-        self.assertNotIn("/coverage/__init__/", report)
-        self.assertIn("/tests/modules/covmod1.py ", report)
-        self.assertIn("/tests/zipmods.zip/covmodzip1.py ", report)
-        self.assertIn("mycode.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 8 0 100%")
+        assert "/coverage/__init__/" not in report
+        assert "/tests/modules/covmod1.py " in report
+        assert "/tests/zipmods.zip/covmodzip1.py " in report
+        assert "mycode.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 8 0 100%"
 
     def test_report_just_one(self):
         # Try reporting just one module
@@ -73,12 +74,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # -------------------------------
         # TOTAL           4      0   100%
 
-        self.assertEqual(self.line_count(report), 5)
-        self.assertNotIn("/coverage/", report)
-        self.assertNotIn("/tests/modules/covmod1.py ", report)
-        self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
-        self.assertIn("mycode.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 4 0 100%")
+        assert self.line_count(report) == 5
+        assert "/coverage/" not in report
+        assert "/tests/modules/covmod1.py " not in report
+        assert "/tests/zipmods.zip/covmodzip1.py " not in report
+        assert "mycode.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 4 0 100%"
 
     def test_report_wildcard(self):
         # Try reporting using wildcards to get the modules.
@@ -92,12 +93,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # -------------------------------
         # TOTAL           4      0   100%
 
-        self.assertEqual(self.line_count(report), 5)
-        self.assertNotIn("/coverage/", report)
-        self.assertNotIn("/tests/modules/covmod1.py ", report)
-        self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
-        self.assertIn("mycode.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 4 0 100%")
+        assert self.line_count(report) == 5
+        assert "/coverage/" not in report
+        assert "/tests/modules/covmod1.py " not in report
+        assert "/tests/zipmods.zip/covmodzip1.py " not in report
+        assert "mycode.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 4 0 100%"
 
     def test_report_omitting(self):
         # Try reporting while omitting some modules
@@ -112,12 +113,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # -------------------------------
         # TOTAL           4      0   100%
 
-        self.assertEqual(self.line_count(report), 5)
-        self.assertNotIn("/coverage/", report)
-        self.assertNotIn("/tests/modules/covmod1.py ", report)
-        self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
-        self.assertIn("mycode.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 4 0 100%")
+        assert self.line_count(report) == 5
+        assert "/coverage/" not in report
+        assert "/tests/modules/covmod1.py " not in report
+        assert "/tests/zipmods.zip/covmodzip1.py " not in report
+        assert "mycode.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 4 0 100%"
 
     def test_report_including(self):
         # Try reporting while including some modules
@@ -131,12 +132,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # -------------------------------
         # TOTAL           4      0   100%
 
-        self.assertEqual(self.line_count(report), 5)
-        self.assertNotIn("/coverage/", report)
-        self.assertNotIn("/tests/modules/covmod1.py ", report)
-        self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
-        self.assertIn("mycode.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 4 0 100%")
+        assert self.line_count(report) == 5
+        assert "/coverage/" not in report
+        assert "/tests/modules/covmod1.py " not in report
+        assert "/tests/zipmods.zip/covmodzip1.py " not in report
+        assert "mycode.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 4 0 100%"
 
     def test_run_source_vs_report_include(self):
         # https://github.com/nedbat/coveragepy/issues/621
@@ -170,8 +171,8 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         covdata = CoverageData()
         covdata.read()
         files = [os.path.basename(p) for p in covdata.measured_files()]
-        self.assertIn("covmod1.py", files)
-        self.assertNotIn("covmodzip1.py", files)
+        assert "covmod1.py" in files
+        assert "covmodzip1.py" not in files
 
     def test_report_branches(self):
         self.make_file("mybranch.py", """\
@@ -182,7 +183,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             branch(1)
             """)
         out = self.run_command("coverage run --source=. --branch mybranch.py")
-        self.assertEqual(out, 'x\n')
+        assert out == 'x\n'
         report = self.report_from_command("coverage report")
 
         # Name          Stmts   Miss Branch BrPart  Cover
@@ -191,9 +192,9 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # -----------------------------------------------
         # TOTAL             5      0      2      1    86%
 
-        self.assertEqual(self.line_count(report), 5)
-        self.assertIn("mybranch.py ", report)
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 5 0 2 1 86%")
+        assert self.line_count(report) == 5
+        assert "mybranch.py " in report
+        assert self.last_line_squeezed(report) == "TOTAL 5 0 2 1 86%"
 
     def test_report_show_missing(self):
         self.make_file("mymissing.py", """\
@@ -213,7 +214,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             missing(0, 1)
             """)
         out = self.run_command("coverage run --source=. mymissing.py")
-        self.assertEqual(out, 'y\nz\n')
+        assert out == 'y\nz\n'
         report = self.report_from_command("coverage report --show-missing")
 
         # Name           Stmts   Miss  Cover   Missing
@@ -222,10 +223,10 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # --------------------------------------------
         # TOTAL             14      3    79%   3-4, 10
 
-        self.assertEqual(self.line_count(report), 5)
+        assert self.line_count(report) == 5
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "mymissing.py 14 3 79% 3-4, 10")
-        self.assertEqual(squeezed[4], "TOTAL 14 3 79%")
+        assert squeezed[2] == "mymissing.py 14 3 79% 3-4, 10"
+        assert squeezed[4] == "TOTAL 14 3 79%"
 
     def test_report_show_missing_branches(self):
         self.make_file("mybranch.py", """\
@@ -238,7 +239,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.omit_site_packages()
         out = self.run_command("coverage run --branch mybranch.py")
-        self.assertEqual(out, 'x\ny\n')
+        assert out == 'x\ny\n'
         report = self.report_from_command("coverage report --show-missing")
 
         # Name           Stmts   Miss Branch BrPart  Cover   Missing
@@ -247,10 +248,10 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # ----------------------------------------------------------
         # TOTAL              6      0      4      2    80%
 
-        self.assertEqual(self.line_count(report), 5)
+        assert self.line_count(report) == 5
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "mybranch.py 6 0 4 2 80% 2->4, 4->exit")
-        self.assertEqual(squeezed[4], "TOTAL 6 0 4 2 80%")
+        assert squeezed[2] == "mybranch.py 6 0 4 2 80% 2->4, 4->exit"
+        assert squeezed[4] == "TOTAL 6 0 4 2 80%"
 
     def test_report_show_missing_branches_and_lines(self):
         self.make_file("main.py", """\
@@ -270,7 +271,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.omit_site_packages()
         out = self.run_command("coverage run --branch main.py")
-        self.assertEqual(out, 'x\ny\n')
+        assert out == 'x\ny\n'
         report = self.report_from_command("coverage report --show-missing")
         report_lines = report.splitlines()
 
@@ -282,7 +283,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             '---------------------------------------------------------',
             'TOTAL            11      2      8      3    63%',
         ]
-        self.assertEqual(expected, report_lines)
+        assert expected == report_lines
 
     def test_report_skip_covered_no_branches(self):
         self.make_file("main.py", """
@@ -298,7 +299,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.omit_site_packages()
         out = self.run_command("coverage run main.py")
-        self.assertEqual(out, "z\n")
+        assert out == "z\n"
         report = self.report_from_command("coverage report --skip-covered --fail-under=70")
 
         # Name             Stmts   Miss  Cover
@@ -309,12 +310,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 file skipped due to complete coverage.
 
-        self.assertEqual(self.line_count(report), 7, report)
+        assert self.line_count(report) == 7, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "not_covered.py 2 1 50%")
-        self.assertEqual(squeezed[4], "TOTAL 6 1 83%")
-        self.assertEqual(squeezed[6], "1 file skipped due to complete coverage.")
-        self.assertEqual(self.last_command_status, 0)
+        assert squeezed[2] == "not_covered.py 2 1 50%"
+        assert squeezed[4] == "TOTAL 6 1 83%"
+        assert squeezed[6] == "1 file skipped due to complete coverage."
+        assert self.last_command_status == 0
 
     def test_report_skip_covered_branches(self):
         self.make_file("main.py", """
@@ -339,7 +340,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.omit_site_packages()
         out = self.run_command("coverage run --branch main.py")
-        self.assertEqual(out, "n\nz\n")
+        assert out == "n\nz\n"
         report = self.report_from_command("coverage report --skip-covered")
 
         # Name             Stmts   Miss Branch BrPart  Cover
@@ -350,11 +351,11 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 2 files skipped due to complete coverage.
 
-        self.assertEqual(self.line_count(report), 7, report)
+        assert self.line_count(report) == 7, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "not_covered.py 4 0 2 1 83%")
-        self.assertEqual(squeezed[4], "TOTAL 13 0 4 1 94%")
-        self.assertEqual(squeezed[6], "2 files skipped due to complete coverage.")
+        assert squeezed[2] == "not_covered.py 4 0 2 1 83%"
+        assert squeezed[4] == "TOTAL 13 0 4 1 94%"
+        assert squeezed[6] == "2 files skipped due to complete coverage."
 
     def test_report_skip_covered_branches_with_totals(self):
         self.make_file("main.py", """
@@ -379,7 +380,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.omit_site_packages()
         out = self.run_command("coverage run --branch main.py")
-        self.assertEqual(out, "n\nz\n")
+        assert out == "n\nz\n"
         report = self.report_from_command("coverage report --skip-covered")
 
         # Name             Stmts   Miss Branch BrPart  Cover
@@ -391,12 +392,12 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 file skipped due to complete coverage.
 
-        self.assertEqual(self.line_count(report), 8, report)
+        assert self.line_count(report) == 8, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "also_not_run.py 2 1 0 0 50%")
-        self.assertEqual(squeezed[3], "not_covered.py 4 0 2 1 83%")
-        self.assertEqual(squeezed[5], "TOTAL 13 1 4 1 88%")
-        self.assertEqual(squeezed[7], "1 file skipped due to complete coverage.")
+        assert squeezed[2] == "also_not_run.py 2 1 0 0 50%"
+        assert squeezed[3] == "not_covered.py 4 0 2 1 83%"
+        assert squeezed[5] == "TOTAL 13 1 4 1 88%"
+        assert squeezed[7] == "1 file skipped due to complete coverage."
 
     def test_report_skip_covered_all_files_covered(self):
         self.make_file("main.py", """
@@ -405,7 +406,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             foo()
             """)
         out = self.run_command("coverage run --source=. --branch main.py")
-        self.assertEqual(out, "")
+        assert out == ""
         report = self.report_from_command("coverage report --skip-covered")
 
         # Name      Stmts   Miss Branch BrPart  Cover
@@ -415,9 +416,9 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 file skipped due to complete coverage.
 
-        self.assertEqual(self.line_count(report), 6, report)
+        assert self.line_count(report) == 6, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[5], "1 file skipped due to complete coverage.")
+        assert squeezed[5] == "1 file skipped due to complete coverage."
 
     def test_report_skip_covered_longfilename(self):
         self.make_file("long_______________filename.py", """
@@ -426,7 +427,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             foo()
             """)
         out = self.run_command("coverage run --source=. --branch long_______________filename.py")
-        self.assertEqual(out, "")
+        assert out == ""
         report = self.report_from_command("coverage report --skip-covered")
 
         # Name    Stmts   Miss Branch BrPart  Cover
@@ -436,20 +437,20 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 file skipped due to complete coverage.
 
-        self.assertEqual(self.line_count(report), 6, report)
+        assert self.line_count(report) == 6, report
         lines = self.report_lines(report)
-        self.assertEqual(lines[0], "Name    Stmts   Miss Branch BrPart  Cover")
+        assert lines[0] == "Name    Stmts   Miss Branch BrPart  Cover"
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[5], "1 file skipped due to complete coverage.")
+        assert squeezed[5] == "1 file skipped due to complete coverage."
 
     def test_report_skip_covered_no_data(self):
         report = self.report_from_command("coverage report --skip-covered")
 
         # No data to report.
 
-        self.assertEqual(self.line_count(report), 1, report)
+        assert self.line_count(report) == 1, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[0], "No data to report.")
+        assert squeezed[0] == "No data to report."
 
     def test_report_skip_empty(self):
         self.make_file("main.py", """
@@ -462,7 +463,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         self.make_file("submodule/__init__.py", "")
         self.omit_site_packages()
         out = self.run_command("coverage run main.py")
-        self.assertEqual(out, "z\n")
+        assert out == "z\n"
         report = self.report_from_command("coverage report --skip-empty")
 
         # Name             Stmts   Miss  Cover
@@ -473,18 +474,18 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 empty file skipped.
 
-        self.assertEqual(self.line_count(report), 7, report)
+        assert self.line_count(report) == 7, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "main.py 4 0 100%")
-        self.assertEqual(squeezed[4], "TOTAL 4 0 100%")
-        self.assertEqual(squeezed[6], "1 empty file skipped.")
-        self.assertEqual(self.last_command_status, 0)
+        assert squeezed[2] == "main.py 4 0 100%"
+        assert squeezed[4] == "TOTAL 4 0 100%"
+        assert squeezed[6] == "1 empty file skipped."
+        assert self.last_command_status == 0
 
     def test_report_skip_empty_no_data(self):
         self.make_file("__init__.py", "")
         self.omit_site_packages()
         out = self.run_command("coverage run __init__.py")
-        self.assertEqual(out, "")
+        assert out == ""
         report = self.report_from_command("coverage report --skip-empty")
 
         # Name             Stmts   Miss  Cover
@@ -492,10 +493,10 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         #
         # 1 empty file skipped.
 
-        self.assertEqual(self.line_count(report), 6, report)
+        assert self.line_count(report) == 6, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[3], "TOTAL 0 0 100%")
-        self.assertEqual(squeezed[5], "1 empty file skipped.")
+        assert squeezed[3] == "TOTAL 0 0 100%"
+        assert squeezed[5] == "1 empty file skipped."
 
     def test_report_precision(self):
         self.make_file(".coveragerc", """\
@@ -524,7 +525,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             foo()
             """)
         out = self.run_command("coverage run --branch main.py")
-        self.assertEqual(out, "n\nz\n")
+        assert out == "n\nz\n"
         report = self.report_from_command("coverage report")
 
         # Name             Stmts   Miss Branch BrPart      Cover
@@ -535,11 +536,11 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # ------------------------------------------------------
         # TOTAL               13      0      4      1    94.118%
 
-        self.assertEqual(self.line_count(report), 7, report)
+        assert self.line_count(report) == 7, report
         squeezed = self.squeezed_lines(report)
-        self.assertEqual(squeezed[2], "covered.py 3 0 0 0 100.000%")
-        self.assertEqual(squeezed[4], "not_covered.py 4 0 2 1 83.333%")
-        self.assertEqual(squeezed[6], "TOTAL 13 0 4 1 94.118%")
+        assert squeezed[2] == "covered.py 3 0 0 0 100.000%"
+        assert squeezed[4] == "not_covered.py 4 0 2 1 83.333%"
+        assert squeezed[6] == "TOTAL 13 0 4 1 94.118%"
 
     def test_dotpy_not_python(self):
         # We run a .py file, and when reporting, we can't parse it as Python.
@@ -560,10 +561,8 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         errmsg = re.sub(r"parse '.*mycode.py", "parse 'mycode.py", errmsg)
         # The actual error message varies version to version
         errmsg = re.sub(r": '.*' at", ": 'error' at", errmsg)
-        self.assertEqual(
-            "Couldn't parse 'mycode.py' as Python source: 'error' at line 1",
-            errmsg,
-        )
+        assert "Couldn't parse 'mycode.py' as Python source: 'error' at line 1" == \
+            errmsg
 
     def test_accenteddotpy_not_python(self):
         if env.JYTHON:
@@ -590,7 +589,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         expected = u"Couldn't parse 'accented\xe2.py' as Python source: 'error' at line 1"
         if env.PY2:
             expected = expected.encode(output_encoding())
-        self.assertEqual(expected, errmsg)
+        assert expected == errmsg
 
     def test_dotpy_not_python_ignored(self):
         # We run a .py file, and when reporting, we can't parse it as Python,
@@ -606,9 +605,9 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # ----------------------------
         # No data to report.
 
-        self.assertEqual(self.line_count(report), 4)
-        self.assertIn('No data to report.', report)
-        self.assertIn('(couldnt-parse)', report)
+        assert self.line_count(report) == 4
+        assert 'No data to report.' in report
+        assert '(couldnt-parse)' in report
 
     def test_dothtml_not_python(self):
         # We run a .html file, and when reporting, we can't parse it as
@@ -625,8 +624,8 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # ----------------------------
         # No data to report.
 
-        self.assertEqual(self.line_count(report), 3)
-        self.assertIn('No data to report.', report)
+        assert self.line_count(report) == 3
+        assert 'No data to report.' in report
 
     def test_report_no_extension(self):
         self.make_file("xxx", """\
@@ -640,9 +639,9 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             print("xxx: %r %r %r %r" % (a, b, c, d))
             """)
         out = self.run_command("coverage run --source=. xxx")
-        self.assertEqual(out, "xxx: 3 4 0 7\n")
+        assert out == "xxx: 3 4 0 7\n"
         report = self.report_from_command("coverage report")
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 7 1 86%")
+        assert self.last_line_squeezed(report) == "TOTAL 7 1 86%"
 
     def test_report_with_chdir(self):
         self.make_file("chdir.py", """\
@@ -654,9 +653,9 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
             """)
         self.make_file("subdir/something", "hello")
         out = self.run_command("coverage run --source=. chdir.py")
-        self.assertEqual(out, "Line One\nLine Two\nhello\n")
+        assert out == "Line One\nLine Two\nhello\n"
         report = self.report_from_command("coverage report")
-        self.assertEqual(self.last_line_squeezed(report), "TOTAL 5 0 100%")
+        assert self.last_line_squeezed(report) == "TOTAL 5 0 100%"
 
     def get_report(self, cov):
         """Get the report from `cov`, and canonicalize it."""
@@ -683,7 +682,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         import main     # pragma: nested # pylint: disable=unused-import
         cov.stop()      # pragma: nested
         report = self.get_report(cov).splitlines()
-        self.assertIn("mybranch.py 5 5 2 0 0%", report)
+        assert "mybranch.py 5 5 2 0 0%" in report
 
     def run_TheCode_and_report_it(self):
         """A helper for the next few tests."""
@@ -699,16 +698,16 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
 
         report = self.run_TheCode_and_report_it()
 
-        self.assertIn("TheCode", report)
-        self.assertNotIn("thecode", report)
+        assert "TheCode" in report
+        assert "thecode" not in report
 
     def test_bug_203_mixed_case_listed_twice(self):
         self.make_file("TheCode.py", "a = 1\n")
 
         report = self.run_TheCode_and_report_it()
 
-        self.assertIn("TheCode", report)
-        self.assertNotIn("thecode", report)
+        assert "TheCode" in report
+        assert "thecode" not in report
 
     def test_pyw_files(self):
         if not env.WINDOWS:
@@ -728,10 +727,10 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         cov.stop()      # pragma: nested
 
         report = self.get_report(cov)
-        self.assertNotIn("NoSource", report)
+        assert "NoSource" not in report
         report = report.splitlines()
-        self.assertIn("start.pyw 2 0 100%", report)
-        self.assertIn("mod.pyw 1 0 100%", report)
+        assert "start.pyw 2 0 100%" in report
+        assert "mod.pyw 1 0 100%" in report
 
     def test_tracing_pyc_file(self):
         # Create two Python files.
@@ -748,7 +747,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         cov.stop()      # pragma: nested
 
         report = self.get_report(cov).splitlines()
-        self.assertIn("mod.py 1 0 100%", report)
+        assert "mod.py 1 0 100%" in report
 
     def test_missing_py_file_during_run(self):
         # PyPy2 doesn't run bare .pyc files.
@@ -768,7 +767,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # the source location though.
         if env.PY3 and not env.JYTHON:
             pycs = glob.glob("__pycache__/mod.*.pyc")
-            self.assertEqual(len(pycs), 1)
+            assert len(pycs) == 1
             os.rename(pycs[0], "mod.pyc")
 
         # Run the program.
@@ -780,7 +779,7 @@ class SummaryTest(UsingModulesMixin, CoverageTest):
         # Put back the missing Python file.
         self.make_file("mod.py", "a = 1\n")
         report = self.get_report(cov).splitlines()
-        self.assertIn("mod.py 1 0 100%", report)
+        assert "mod.py 1 0 100%" in report
 
 
 class SummaryTest2(UsingModulesMixin, CoverageTest):
@@ -804,8 +803,8 @@ class SummaryTest2(UsingModulesMixin, CoverageTest):
 
         report = repout.getvalue().replace('\\', '/')
         report = re.sub(r"\s+", " ", report)
-        self.assertIn("tests/modules/pkg1/__init__.py 1 0 0 0 100%", report)
-        self.assertIn("tests/modules/pkg2/__init__.py 0 0 0 0 100%", report)
+        assert "tests/modules/pkg1/__init__.py 1 0 0 0 100%" in report
+        assert "tests/modules/pkg2/__init__.py 0 0 0 0 100%" in report
 
 
 class ReportingReturnValueTest(CoverageTest):
@@ -830,17 +829,17 @@ class ReportingReturnValueTest(CoverageTest):
     def test_report(self):
         cov = self.run_coverage()
         val = cov.report(include="*/doit.py")
-        self.assertAlmostEqual(val, 85.7, 1)
+        assert round(abs(val-85.7), 1) == 0
 
     def test_html(self):
         cov = self.run_coverage()
         val = cov.html_report(include="*/doit.py")
-        self.assertAlmostEqual(val, 85.7, 1)
+        assert round(abs(val-85.7), 1) == 0
 
     def test_xml(self):
         cov = self.run_coverage()
         val = cov.xml_report(include="*/doit.py")
-        self.assertAlmostEqual(val, 85.7, 1)
+        assert round(abs(val-85.7), 1) == 0
 
 
 class TestSummaryReporterConfiguration(CoverageTest):
@@ -896,37 +895,35 @@ class TestSummaryReporterConfiguration(CoverageTest):
         # TOTAL        586    386    34%
 
         lines = report.splitlines()[2:-2]
-        self.assertEqual(len(lines), 3)
+        assert len(lines) == 3
         nums = [list(map(int, l.replace('%', '').split()[1:])) for l in lines]
         # [
         #  [339, 155, 54],
         #  [ 13,   3, 77],
         #  [234, 228,  3]
         # ]
-        self.assertTrue(nums[1][0] < nums[2][0] < nums[0][0])
-        self.assertTrue(nums[1][1] < nums[0][1] < nums[2][1])
-        self.assertTrue(nums[2][2] < nums[0][2] < nums[1][2])
+        assert nums[1][0] < nums[2][0] < nums[0][0]
+        assert nums[1][1] < nums[0][1] < nums[2][1]
+        assert nums[2][2] < nums[0][2] < nums[1][2]
 
     def test_defaults(self):
         """Run the report with no configuration options."""
         report = self.get_summary_text()
-        self.assertNotIn('Missing', report)
-        self.assertNotIn('Branch', report)
+        assert 'Missing' not in report
+        assert 'Branch' not in report
 
     def test_print_missing(self):
         """Run the report printing the missing lines."""
         report = self.get_summary_text(('report:show_missing', True))
-        self.assertIn('Missing', report)
-        self.assertNotIn('Branch', report)
+        assert 'Missing' in report
+        assert 'Branch' not in report
 
     def assert_ordering(self, text, *words):
         """Assert that the `words` appear in order in `text`."""
         indexes = list(map(text.find, words))
         assert -1 not in indexes
-        self.assertEqual(
-            indexes, sorted(indexes),
+        assert indexes == sorted(indexes), \
             "The words %r don't appear in order in %r" % (words, text)
-        )
 
     def test_sort_report_by_stmts(self):
         # Sort the text report by the Stmts column.
@@ -946,5 +943,5 @@ class TestSummaryReporterConfiguration(CoverageTest):
     def test_sort_report_by_invalid_option(self):
         # Sort the text report by a nonsense column.
         msg = "Invalid sorting option: 'Xyzzy'"
-        with self.assertRaisesRegex(CoverageException, msg):
+        with pytest.raises(CoverageException, match=msg):
             self.get_summary_text(('report:sort', 'Xyzzy'))