diff --git a/core/tests/app_test.py b/core/tests/app_test.py
index a339d4bc..80fc0854 100644
--- a/core/tests/app_test.py
+++ b/core/tests/app_test.py
@@ -23,7 +23,7 @@ from ..scanner import ScanType
 
 def add_fake_files_to_directories(directories, files):
     directories.get_files = lambda j=None: iter(files)
-    directories._dirs.append("this is just so Scan() doesnt return 3")
+    directories._dirs.append("this is just so Scan() doesn't return 3")
 
 
 class TestCaseDupeGuru:
@@ -43,7 +43,7 @@ class TestCaseDupeGuru:
         dgapp.apply_filter("()[]\\.|+?^abc")
         call = dgapp.results.apply_filter.calls[1]
         eq_("\\(\\)\\[\\]\\\\\\.\\|\\+\\?\\^abc", call["filter_str"])
-        dgapp.apply_filter("(*)")  # In "simple mode", we want the * to behave as a wilcard
+        dgapp.apply_filter("(*)")  # In "simple mode", we want the * to behave as a wildcard
         call = dgapp.results.apply_filter.calls[3]
         eq_(r"\(.*\)", call["filter_str"])
         dgapp.options["escape_filter_regexp"] = False
@@ -88,14 +88,14 @@ class TestCaseDupeGuru:
         eq_(1, len(calls))
         eq_(sourcepath, calls[0]["path"])
 
-    def test_Scan_with_objects_evaluating_to_false(self):
+    def test_scan_with_objects_evaluating_to_false(self):
         class FakeFile(fs.File):
             def __bool__(self):
                 return False
 
         # At some point, any() was used in a wrong way that made Scan() wrongly return 1
         app = TestApp().app
-        f1, f2 = [FakeFile("foo") for i in range(2)]
+        f1, f2 = [FakeFile("foo") for _ in range(2)]
         f1.is_ref, f2.is_ref = (False, False)
         assert not (bool(f1) and bool(f2))
         add_fake_files_to_directories(app.directories, [f1, f2])
@@ -124,7 +124,7 @@ class TestCaseDupeGuru:
         assert not dgapp.result_table.rename_selected("foo")  # no crash
 
 
-class TestCaseDupeGuru_clean_empty_dirs:
+class TestCaseDupeGuruCleanEmptyDirs:
     @pytest.fixture
     def do_setup(self, request):
         monkeypatch = request.getfixturevalue("monkeypatch")
@@ -184,7 +184,7 @@ class TestCaseDupeGuruWithResults:
         tmppath["bar"].mkdir()
         self.app.directories.add_path(tmppath)
 
-    def test_GetObjects(self, do_setup):
+    def test_get_objects(self, do_setup):
         objects = self.objects
         groups = self.groups
         r = self.rtable[0]
@@ -197,7 +197,7 @@ class TestCaseDupeGuruWithResults:
         assert r._group is groups[1]
         assert r._dupe is objects[4]
 
-    def test_GetObjects_after_sort(self, do_setup):
+    def test_get_objects_after_sort(self, do_setup):
         objects = self.objects
         groups = self.groups[:]  # we need an un-sorted reference
         self.rtable.sort("name", False)
@@ -212,7 +212,7 @@ class TestCaseDupeGuruWithResults:
         # The first 2 dupes have been removed. The 3rd one is a ref. it stays there, in first pos.
         eq_(self.rtable.selected_indexes, [1])  # no exception
 
-    def test_selectResultNodePaths(self, do_setup):
+    def test_select_result_node_paths(self, do_setup):
         app = self.app
         objects = self.objects
         self.rtable.select([1, 2])
@@ -220,7 +220,7 @@ class TestCaseDupeGuruWithResults:
         assert app.selected_dupes[0] is objects[1]
         assert app.selected_dupes[1] is objects[2]
 
-    def test_selectResultNodePaths_with_ref(self, do_setup):
+    def test_select_result_node_paths_with_ref(self, do_setup):
         app = self.app
         objects = self.objects
         self.rtable.select([1, 2, 3])
@@ -229,7 +229,7 @@ class TestCaseDupeGuruWithResults:
         assert app.selected_dupes[1] is objects[2]
         assert app.selected_dupes[2] is self.groups[1].ref
 
-    def test_selectResultNodePaths_after_sort(self, do_setup):
+    def test_select_result_node_paths_after_sort(self, do_setup):
         app = self.app
         objects = self.objects
         groups = self.groups[:]  # To keep the old order in memory
@@ -256,7 +256,7 @@ class TestCaseDupeGuruWithResults:
         app.remove_selected()
         eq_(self.rtable.selected_indexes, [])  # no exception
 
-    def test_selectPowerMarkerRows_after_sort(self, do_setup):
+    def test_select_powermarker_rows_after_sort(self, do_setup):
         app = self.app
         objects = self.objects
         self.rtable.power_marker = True
@@ -295,7 +295,7 @@ class TestCaseDupeGuruWithResults:
         app.toggle_selected_mark_state()
         eq_(app.results.mark_count, 0)
 
-    def test_refreshDetailsWithSelected(self, do_setup):
+    def test_refresh_details_with_selected(self, do_setup):
         self.rtable.select([1, 4])
         eq_(self.dpanel.row(0), ("Filename", "bar bleh", "foo bar"))
         self.dpanel.view.check_gui_calls(["refresh"])
@@ -303,7 +303,7 @@ class TestCaseDupeGuruWithResults:
         eq_(self.dpanel.row(0), ("Filename", "---", "---"))
         self.dpanel.view.check_gui_calls(["refresh"])
 
-    def test_makeSelectedReference(self, do_setup):
+    def test_make_selected_reference(self, do_setup):
         app = self.app
         objects = self.objects
         groups = self.groups
@@ -312,7 +312,7 @@ class TestCaseDupeGuruWithResults:
         assert groups[0].ref is objects[1]
         assert groups[1].ref is objects[4]
 
-    def test_makeSelectedReference_by_selecting_two_dupes_in_the_same_group(self, do_setup):
+    def test_make_selected_reference_by_selecting_two_dupes_in_the_same_group(self, do_setup):
         app = self.app
         objects = self.objects
         groups = self.groups
@@ -322,7 +322,7 @@ class TestCaseDupeGuruWithResults:
         assert groups[0].ref is objects[1]
         assert groups[1].ref is objects[4]
 
-    def test_removeSelected(self, do_setup):
+    def test_remove_selected(self, do_setup):
         app = self.app
         self.rtable.select([1, 4])
         app.remove_selected()
@@ -330,7 +330,7 @@ class TestCaseDupeGuruWithResults:
         app.remove_selected()
         eq_(len(app.results.dupes), 0)
 
-    def test_addDirectory_simple(self, do_setup):
+    def test_add_directory_simple(self, do_setup):
         # There's already a directory in self.app, so adding another once makes 2 of em
         app = self.app
         # any other path that isn't a parent or child of the already added path
@@ -338,7 +338,7 @@ class TestCaseDupeGuruWithResults:
         app.add_directory(otherpath)
         eq_(len(app.directories), 2)
 
-    def test_addDirectory_already_there(self, do_setup):
+    def test_add_directory_already_there(self, do_setup):
         app = self.app
         otherpath = Path(op.dirname(__file__))
         app.add_directory(otherpath)
@@ -346,7 +346,7 @@ class TestCaseDupeGuruWithResults:
         eq_(len(app.view.messages), 1)
         assert "already" in app.view.messages[0]
 
-    def test_addDirectory_does_not_exist(self, do_setup):
+    def test_add_directory_does_not_exist(self, do_setup):
         app = self.app
         app.add_directory("/does_not_exist")
         eq_(len(app.view.messages), 1)
@@ -362,7 +362,7 @@ class TestCaseDupeGuruWithResults:
         # BOTH the ref and the other dupe should have been added
         eq_(len(app.ignore_list), 3)
 
-    def test_purgeIgnoreList(self, do_setup, tmpdir):
+    def test_purge_ignorelist(self, do_setup, tmpdir):
         app = self.app
         p1 = str(tmpdir.join("file1"))
         p2 = str(tmpdir.join("file2"))
@@ -378,14 +378,14 @@ class TestCaseDupeGuruWithResults:
         assert not app.ignore_list.AreIgnored(dne, p1)
 
     def test_only_unicode_is_added_to_ignore_list(self, do_setup):
-        def FakeIgnore(first, second):
+        def fake_ignore(first, second):
             if not isinstance(first, str):
                 self.fail()
             if not isinstance(second, str):
                 self.fail()
 
         app = self.app
-        app.ignore_list.Ignore = FakeIgnore
+        app.ignore_list.Ignore = fake_ignore
         self.rtable.select([4])
         app.add_selected_to_ignore_list()
 
@@ -419,7 +419,7 @@ class TestCaseDupeGuruWithResults:
         # don't crash
 
 
-class TestCaseDupeGuru_renameSelected:
+class TestCaseDupeGuruRenameSelected:
     @pytest.fixture
     def do_setup(self, request):
         tmpdir = request.getfixturevalue("tmpdir")
@@ -502,7 +502,6 @@ class TestAppWithDirectoriesInTree:
         # refreshed.
         node = self.dtree[0]
         eq_(len(node), 3)  # a len() call is required for subnodes to be loaded
-        subnode = node[0]
         node.state = 1  # the state property is a state index
         node = self.dtree[0]
         eq_(len(node), 3)
diff --git a/core/tests/block_test.py b/core/tests/block_test.py
index 39226664..1c617638 100644
--- a/core/tests/block_test.py
+++ b/core/tests/block_test.py
@@ -73,99 +73,6 @@ class TestCasegetblock:
         eq_((meanred, meangreen, meanblue), b)
 
 
-# class TCdiff(unittest.TestCase):
-#     def test_diff(self):
-#         b1 = (10, 20, 30)
-#         b2 = (1, 2, 3)
-#         eq_(9 + 18 + 27, diff(b1, b2))
-#
-#     def test_diff_negative(self):
-#         b1 = (10, 20, 30)
-#         b2 = (1, 2, 3)
-#         eq_(9 + 18 + 27, diff(b2, b1))
-#
-#     def test_diff_mixed_positive_and_negative(self):
-#         b1 = (1, 5, 10)
-#         b2 = (10, 1, 15)
-#         eq_(9 + 4 + 5, diff(b1, b2))
-#
-
-# class TCgetblocks(unittest.TestCase):
-#     def test_empty_image(self):
-#         im = empty()
-#         blocks = getblocks(im, 1)
-#         eq_(0, len(blocks))
-#
-#     def test_one_block_image(self):
-#         im = four_pixels()
-#         blocks = getblocks2(im, 1)
-#         eq_(1, len(blocks))
-#         block = blocks[0]
-#         meanred = (0xff + 0x80) // 4
-#         meangreen = (0x80 + 0x40) // 4
-#         meanblue = (0xff + 0x80) // 4
-#         eq_((meanred, meangreen, meanblue), block)
-#
-#     def test_not_enough_height_to_fit_a_block(self):
-#         im = FakeImage((2, 1), [BLACK, BLACK])
-#         blocks = getblocks(im, 2)
-#         eq_(0, len(blocks))
-#
-#     def xtest_dont_include_leftovers(self):
-#         # this test is disabled because getblocks is not used and getblock in cdeffed
-#         pixels = [
-#             RED,(0, 0x80, 0xff), BLACK,
-#             (0x80, 0, 0),(0, 0x40, 0x80), BLACK,
-#             BLACK, BLACK, BLACK
-#         ]
-#         im = FakeImage((3, 3), pixels)
-#         blocks = getblocks(im, 2)
-#         block = blocks[0]
-#         #Because the block is smaller than the image, only blocksize must be considered.
-#         meanred = (0xff + 0x80) // 4
-#         meangreen = (0x80 + 0x40) // 4
-#         meanblue = (0xff + 0x80) // 4
-#         eq_((meanred, meangreen, meanblue), block)
-#
-#     def xtest_two_blocks(self):
-#         # this test is disabled because getblocks is not used and getblock in cdeffed
-#         pixels = [BLACK for i in xrange(4 * 2)]
-#         pixels[0] = RED
-#         pixels[1] = (0, 0x80, 0xff)
-#         pixels[4] = (0x80, 0, 0)
-#         pixels[5] = (0, 0x40, 0x80)
-#         im = FakeImage((4, 2), pixels)
-#         blocks = getblocks(im, 2)
-#         eq_(2, len(blocks))
-#         block = blocks[0]
-#         #Because the block is smaller than the image, only blocksize must be considered.
-#         meanred = (0xff + 0x80) // 4
-#         meangreen = (0x80 + 0x40) // 4
-#         meanblue = (0xff + 0x80) // 4
-#         eq_((meanred, meangreen, meanblue), block)
-#         eq_(BLACK, blocks[1])
-#
-#     def test_four_blocks(self):
-#         pixels = [BLACK for i in xrange(4 * 4)]
-#         pixels[0] = RED
-#         pixels[1] = (0, 0x80, 0xff)
-#         pixels[4] = (0x80, 0, 0)
-#         pixels[5] = (0, 0x40, 0x80)
-#         im = FakeImage((4, 4), pixels)
-#         blocks = getblocks2(im, 2)
-#         eq_(4, len(blocks))
-#         block = blocks[0]
-#         #Because the block is smaller than the image, only blocksize must be considered.
-#         meanred = (0xff + 0x80) // 4
-#         meangreen = (0x80 + 0x40) // 4
-#         meanblue = (0xff + 0x80) // 4
-#         eq_((meanred, meangreen, meanblue), block)
-#         eq_(BLACK, blocks[1])
-#         eq_(BLACK, blocks[2])
-#         eq_(BLACK, blocks[3])
-#
-
-
 class TestCasegetblocks2:
     def test_empty_image(self):
         im = empty()
@@ -270,8 +177,8 @@ class TestCaseavgdiff:
     def test_return_at_least_1_at_the_slightest_difference(self):
         ref = (0, 0, 0)
         b1 = (1, 0, 0)
-        blocks1 = [ref for i in range(250)]
-        blocks2 = [ref for i in range(250)]
+        blocks1 = [ref for _ in range(250)]
+        blocks2 = [ref for _ in range(250)]
         blocks2[0] = b1
         eq_(1, my_avgdiff(blocks1, blocks2))
 
@@ -280,41 +187,3 @@ class TestCaseavgdiff:
         blocks1 = [ref, ref]
         blocks2 = [ref, ref]
         eq_(0, my_avgdiff(blocks1, blocks2))
-
-
-# class TCmaxdiff(unittest.TestCase):
-#     def test_empty(self):
-#         self.assertRaises(NoBlocksError, maxdiff,[],[])
-#
-#     def test_two_blocks(self):
-#         b1 = (5, 10, 15)
-#         b2 = (255, 250, 245)
-#         b3 = (0, 0, 0)
-#         b4 = (255, 0, 255)
-#         blocks1 = [b1, b2]
-#         blocks2 = [b3, b4]
-#         expected1 = 5 + 10 + 15
-#         expected2 = 0 + 250 + 10
-#         expected = max(expected1, expected2)
-#         eq_(expected, maxdiff(blocks1, blocks2))
-#
-#     def test_blocks_not_the_same_size(self):
-#         b = (0, 0, 0)
-#         self.assertRaises(DifferentBlockCountError, maxdiff,[b, b],[b])
-#
-#     def test_first_arg_is_empty_but_not_second(self):
-#         #Don't return 0 (as when the 2 lists are empty), raise!
-#         b = (0, 0, 0)
-#         self.assertRaises(DifferentBlockCountError, maxdiff,[],[b])
-#
-#     def test_limit(self):
-#         b1 = (5, 10, 15)
-#         b2 = (255, 250, 245)
-#         b3 = (0, 0, 0)
-#         b4 = (255, 0, 255)
-#         blocks1 = [b1, b2]
-#         blocks2 = [b3, b4]
-#         expected1 = 5 + 10 + 15
-#         expected2 = 0 + 250 + 10
-#         eq_(expected1, maxdiff(blocks1, blocks2, expected1 - 1))
-#
diff --git a/core/tests/cache_test.py b/core/tests/cache_test.py
index 9cfdb765..594b61ca 100644
--- a/core/tests/cache_test.py
+++ b/core/tests/cache_test.py
@@ -17,7 +17,7 @@ except ImportError:
     skip("Can't import the cache module, probably hasn't been compiled.")
 
 
-class TestCasecolors_to_string:
+class TestCaseColorsToString:
     def test_no_color(self):
         eq_("", colors_to_string([]))
 
@@ -30,7 +30,7 @@ class TestCasecolors_to_string:
         eq_("000102030405", colors_to_string([(0, 1, 2), (3, 4, 5)]))
 
 
-class TestCasestring_to_colors:
+class TestCaseStringToColors:
     def test_empty(self):
         eq_([], string_to_colors(""))
 
diff --git a/core/tests/directories_test.py b/core/tests/directories_test.py
index 01fd92d5..fa3c1a48 100644
--- a/core/tests/directories_test.py
+++ b/core/tests/directories_test.py
@@ -92,7 +92,7 @@ def test_add_path():
     assert p in d
 
 
-def test_AddPath_when_path_is_already_there():
+def test_add_path_when_path_is_already_there():
     d = Directories()
     p = testpath["onefile"]
     d.add_path(p)
@@ -112,7 +112,7 @@ def test_add_path_containing_paths_already_there():
     eq_(d[0], testpath)
 
 
-def test_AddPath_non_latin(tmpdir):
+def test_add_path_non_latin(tmpdir):
     p = Path(str(tmpdir))
     to_add = p["unicode\u201a"]
     os.mkdir(str(to_add))
@@ -376,7 +376,7 @@ files: {self.d._exclude_list.compiled_files} all: {self.d._exclude_list.compiled
         p1["$Recycle.Bin"]["subdir"].mkdir()
         self.d.add_path(p1)
         eq_(self.d.get_state(p1["$Recycle.Bin"]), DirectoryState.Excluded)
-        # By default, subdirs should be excluded too, but this can be overriden separately
+        # By default, subdirs should be excluded too, but this can be overridden separately
         eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Excluded)
         self.d.set_state(p1["$Recycle.Bin"]["subdir"], DirectoryState.Normal)
         eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Normal)
diff --git a/core/tests/engine_test.py b/core/tests/engine_test.py
index 068fa5ee..1d809513 100644
--- a/core/tests/engine_test.py
+++ b/core/tests/engine_test.py
@@ -103,10 +103,9 @@ class TestCasegetfields:
         expected = [["a", "bc", "def"]]
         actual = getfields(" - a bc def")
         eq_(expected, actual)
-        expected = [["bc", "def"]]
 
 
-class TestCaseunpack_fields:
+class TestCaseUnpackFields:
     def test_with_fields(self):
         expected = ["a", "b", "c", "d", "e", "f"]
         actual = unpack_fields([["a"], ["b", "c"], ["d", "e", "f"]])
@@ -218,24 +217,24 @@ class TestCaseWordCompareWithFields:
         eq_([["c", "d", "f"], ["a", "b"]], second)
 
 
-class TestCasebuild_word_dict:
+class TestCaseBuildWordDict:
     def test_with_standard_words(self):
-        itemList = [NamedObject("foo bar", True)]
-        itemList.append(NamedObject("bar baz", True))
-        itemList.append(NamedObject("baz bleh foo", True))
-        d = build_word_dict(itemList)
+        item_list = [NamedObject("foo bar", True)]
+        item_list.append(NamedObject("bar baz", True))
+        item_list.append(NamedObject("baz bleh foo", True))
+        d = build_word_dict(item_list)
         eq_(4, len(d))
         eq_(2, len(d["foo"]))
-        assert itemList[0] in d["foo"]
-        assert itemList[2] in d["foo"]
+        assert item_list[0] in d["foo"]
+        assert item_list[2] in d["foo"]
         eq_(2, len(d["bar"]))
-        assert itemList[0] in d["bar"]
-        assert itemList[1] in d["bar"]
+        assert item_list[0] in d["bar"]
+        assert item_list[1] in d["bar"]
         eq_(2, len(d["baz"]))
-        assert itemList[1] in d["baz"]
-        assert itemList[2] in d["baz"]
+        assert item_list[1] in d["baz"]
+        assert item_list[2] in d["baz"]
         eq_(1, len(d["bleh"]))
-        assert itemList[2] in d["bleh"]
+        assert item_list[2] in d["bleh"]
 
     def test_unpack_fields(self):
         o = NamedObject("")
@@ -269,7 +268,7 @@ class TestCasebuild_word_dict:
         eq_(100, self.log[1])
 
 
-class TestCasemerge_similar_words:
+class TestCaseMergeSimilarWords:
     def test_some_similar_words(self):
         d = {
             "foobar": set([1]),
@@ -281,11 +280,11 @@ class TestCasemerge_similar_words:
         eq_(3, len(d["foobar"]))
 
 
-class TestCasereduce_common_words:
+class TestCaseReduceCommonWords:
     def test_typical(self):
         d = {
-            "foo": set([NamedObject("foo bar", True) for i in range(50)]),
-            "bar": set([NamedObject("foo bar", True) for i in range(49)]),
+            "foo": set([NamedObject("foo bar", True) for _ in range(50)]),
+            "bar": set([NamedObject("foo bar", True) for _ in range(49)]),
         }
         reduce_common_words(d, 50)
         assert "foo" not in d
@@ -293,7 +292,7 @@ class TestCasereduce_common_words:
 
     def test_dont_remove_objects_with_only_common_words(self):
         d = {
-            "common": set([NamedObject("common uncommon", True) for i in range(50)] + [NamedObject("common", True)]),
+            "common": set([NamedObject("common uncommon", True) for _ in range(50)] + [NamedObject("common", True)]),
             "uncommon": set([NamedObject("common uncommon", True)]),
         }
         reduce_common_words(d, 50)
@@ -302,20 +301,20 @@ class TestCasereduce_common_words:
 
     def test_values_still_are_set_instances(self):
         d = {
-            "common": set([NamedObject("common uncommon", True) for i in range(50)] + [NamedObject("common", True)]),
+            "common": set([NamedObject("common uncommon", True) for _ in range(50)] + [NamedObject("common", True)]),
             "uncommon": set([NamedObject("common uncommon", True)]),
         }
         reduce_common_words(d, 50)
         assert isinstance(d["common"], set)
         assert isinstance(d["uncommon"], set)
 
-    def test_dont_raise_KeyError_when_a_word_has_been_removed(self):
+    def test_dont_raise_keyerror_when_a_word_has_been_removed(self):
         # If a word has been removed by the reduce, an object in a subsequent common word that
         # contains the word that has been removed would cause a KeyError.
         d = {
-            "foo": set([NamedObject("foo bar baz", True) for i in range(50)]),
-            "bar": set([NamedObject("foo bar baz", True) for i in range(50)]),
-            "baz": set([NamedObject("foo bar baz", True) for i in range(49)]),
+            "foo": set([NamedObject("foo bar baz", True) for _ in range(50)]),
+            "bar": set([NamedObject("foo bar baz", True) for _ in range(50)]),
+            "baz": set([NamedObject("foo bar baz", True) for _ in range(49)]),
         }
         try:
             reduce_common_words(d, 50)
@@ -329,7 +328,7 @@ class TestCasereduce_common_words:
             o.words = [["foo", "bar"], ["baz"]]
             return o
 
-        d = {"foo": set([create_it() for i in range(50)])}
+        d = {"foo": set([create_it() for _ in range(50)])}
         try:
             reduce_common_words(d, 50)
         except TypeError:
@@ -342,9 +341,9 @@ class TestCasereduce_common_words:
         # would not stay in 'bar' because 'foo' is not a common word anymore.
         only_common = NamedObject("foo bar", True)
         d = {
-            "foo": set([NamedObject("foo bar baz", True) for i in range(49)] + [only_common]),
-            "bar": set([NamedObject("foo bar baz", True) for i in range(49)] + [only_common]),
-            "baz": set([NamedObject("foo bar baz", True) for i in range(49)]),
+            "foo": set([NamedObject("foo bar baz", True) for _ in range(49)] + [only_common]),
+            "bar": set([NamedObject("foo bar baz", True) for _ in range(49)] + [only_common]),
+            "baz": set([NamedObject("foo bar baz", True) for _ in range(49)]),
         }
         reduce_common_words(d, 50)
         eq_(1, len(d["foo"]))
@@ -352,7 +351,7 @@ class TestCasereduce_common_words:
         eq_(49, len(d["baz"]))
 
 
-class TestCaseget_match:
+class TestCaseGetMatch:
     def test_simple(self):
         o1 = NamedObject("foo bar", True)
         o2 = NamedObject("bar bleh", True)
@@ -381,12 +380,12 @@ class TestCaseGetMatches:
         eq_(getmatches([]), [])
 
     def test_simple(self):
-        itemList = [
+        item_list = [
             NamedObject("foo bar"),
             NamedObject("bar bleh"),
             NamedObject("a b c foo"),
         ]
-        r = getmatches(itemList)
+        r = getmatches(item_list)
         eq_(2, len(r))
         m = first(m for m in r if m.percentage == 50)  # "foo bar" and "bar bleh"
         assert_match(m, "foo bar", "bar bleh")
@@ -394,40 +393,40 @@ class TestCaseGetMatches:
         assert_match(m, "foo bar", "a b c foo")
 
     def test_null_and_unrelated_objects(self):
-        itemList = [
+        item_list = [
             NamedObject("foo bar"),
             NamedObject("bar bleh"),
             NamedObject(""),
             NamedObject("unrelated object"),
         ]
-        r = getmatches(itemList)
+        r = getmatches(item_list)
         eq_(len(r), 1)
         m = r[0]
         eq_(m.percentage, 50)
         assert_match(m, "foo bar", "bar bleh")
 
     def test_twice_the_same_word(self):
-        itemList = [NamedObject("foo foo bar"), NamedObject("bar bleh")]
-        r = getmatches(itemList)
+        item_list = [NamedObject("foo foo bar"), NamedObject("bar bleh")]
+        r = getmatches(item_list)
         eq_(1, len(r))
 
     def test_twice_the_same_word_when_preworded(self):
-        itemList = [NamedObject("foo foo bar", True), NamedObject("bar bleh", True)]
-        r = getmatches(itemList)
+        item_list = [NamedObject("foo foo bar", True), NamedObject("bar bleh", True)]
+        r = getmatches(item_list)
         eq_(1, len(r))
 
     def test_two_words_match(self):
-        itemList = [NamedObject("foo bar"), NamedObject("foo bar bleh")]
-        r = getmatches(itemList)
+        item_list = [NamedObject("foo bar"), NamedObject("foo bar bleh")]
+        r = getmatches(item_list)
         eq_(1, len(r))
 
     def test_match_files_with_only_common_words(self):
         # If a word occurs more than 50 times, it is excluded from the matching process
         # The problem with the common_word_threshold is that the files containing only common
         # words will never be matched together. We *should* match them.
-        # This test assumes that the common word threashold const is 50
-        itemList = [NamedObject("foo") for i in range(50)]
-        r = getmatches(itemList)
+        # This test assumes that the common word threshold const is 50
+        item_list = [NamedObject("foo") for _ in range(50)]
+        r = getmatches(item_list)
         eq_(1225, len(r))
 
     def test_use_words_already_there_if_there(self):
@@ -450,28 +449,28 @@ class TestCaseGetMatches:
         eq_(100, self.log[-1])
 
     def test_weight_words(self):
-        itemList = [NamedObject("foo bar"), NamedObject("bar bleh")]
-        m = getmatches(itemList, weight_words=True)[0]
+        item_list = [NamedObject("foo bar"), NamedObject("bar bleh")]
+        m = getmatches(item_list, weight_words=True)[0]
         eq_(int((6.0 / 13.0) * 100), m.percentage)
 
     def test_similar_word(self):
-        itemList = [NamedObject("foobar"), NamedObject("foobars")]
-        eq_(len(getmatches(itemList, match_similar_words=True)), 1)
-        eq_(getmatches(itemList, match_similar_words=True)[0].percentage, 100)
-        itemList = [NamedObject("foobar"), NamedObject("foo")]
-        eq_(len(getmatches(itemList, match_similar_words=True)), 0)  # too far
-        itemList = [NamedObject("bizkit"), NamedObject("bizket")]
-        eq_(len(getmatches(itemList, match_similar_words=True)), 1)
-        itemList = [NamedObject("foobar"), NamedObject("foosbar")]
-        eq_(len(getmatches(itemList, match_similar_words=True)), 1)
+        item_list = [NamedObject("foobar"), NamedObject("foobars")]
+        eq_(len(getmatches(item_list, match_similar_words=True)), 1)
+        eq_(getmatches(item_list, match_similar_words=True)[0].percentage, 100)
+        item_list = [NamedObject("foobar"), NamedObject("foo")]
+        eq_(len(getmatches(item_list, match_similar_words=True)), 0)  # too far
+        item_list = [NamedObject("bizkit"), NamedObject("bizket")]
+        eq_(len(getmatches(item_list, match_similar_words=True)), 1)
+        item_list = [NamedObject("foobar"), NamedObject("foosbar")]
+        eq_(len(getmatches(item_list, match_similar_words=True)), 1)
 
     def test_single_object_with_similar_words(self):
-        itemList = [NamedObject("foo foos")]
-        eq_(len(getmatches(itemList, match_similar_words=True)), 0)
+        item_list = [NamedObject("foo foos")]
+        eq_(len(getmatches(item_list, match_similar_words=True)), 0)
 
     def test_double_words_get_counted_only_once(self):
-        itemList = [NamedObject("foo bar foo bleh"), NamedObject("foo bar bleh bar")]
-        m = getmatches(itemList)[0]
+        item_list = [NamedObject("foo bar foo bleh"), NamedObject("foo bar bleh bar")]
+        m = getmatches(item_list)[0]
         eq_(75, m.percentage)
 
     def test_with_fields(self):
@@ -491,13 +490,13 @@ class TestCaseGetMatches:
         eq_(m.percentage, 50)
 
     def test_only_match_similar_when_the_option_is_set(self):
-        itemList = [NamedObject("foobar"), NamedObject("foobars")]
-        eq_(len(getmatches(itemList, match_similar_words=False)), 0)
+        item_list = [NamedObject("foobar"), NamedObject("foobars")]
+        eq_(len(getmatches(item_list, match_similar_words=False)), 0)
 
     def test_dont_recurse_do_match(self):
         # with nosetests, the stack is increased. The number has to be high enough not to be failing falsely
         sys.setrecursionlimit(200)
-        files = [NamedObject("foo bar") for i in range(201)]
+        files = [NamedObject("foo bar") for _ in range(201)]
         try:
             getmatches(files)
         except RuntimeError:
@@ -506,27 +505,27 @@ class TestCaseGetMatches:
             sys.setrecursionlimit(1000)
 
     def test_min_match_percentage(self):
-        itemList = [
+        item_list = [
             NamedObject("foo bar"),
             NamedObject("bar bleh"),
             NamedObject("a b c foo"),
         ]
-        r = getmatches(itemList, min_match_percentage=50)
+        r = getmatches(item_list, min_match_percentage=50)
         eq_(1, len(r))  # Only "foo bar" / "bar bleh" should match
 
-    def test_MemoryError(self, monkeypatch):
+    def test_memory_error(self, monkeypatch):
         @log_calls
         def mocked_match(first, second, flags):
             if len(mocked_match.calls) > 42:
                 raise MemoryError()
             return Match(first, second, 0)
 
-        objects = [NamedObject() for i in range(10)]  # results in 45 matches
+        objects = [NamedObject() for _ in range(10)]  # results in 45 matches
         monkeypatch.setattr(engine, "get_match", mocked_match)
         try:
             r = getmatches(objects)
         except MemoryError:
-            self.fail("MemorryError must be handled")
+            self.fail("MemoryError must be handled")
         eq_(42, len(r))
 
 
@@ -563,7 +562,7 @@ class TestCaseGetMatchesByContents:
 
 
 class TestCaseGroup:
-    def test_empy(self):
+    def test_empty(self):
         g = Group()
         eq_(None, g.ref)
         eq_([], g.dupes)
@@ -802,14 +801,14 @@ class TestCaseGroup:
         eq_(0, len(g.candidates))
 
 
-class TestCaseget_groups:
+class TestCaseGetGroups:
     def test_empty(self):
         r = get_groups([])
         eq_([], r)
 
     def test_simple(self):
-        itemList = [NamedObject("foo bar"), NamedObject("bar bleh")]
-        matches = getmatches(itemList)
+        item_list = [NamedObject("foo bar"), NamedObject("bar bleh")]
+        matches = getmatches(item_list)
         m = matches[0]
         r = get_groups(matches)
         eq_(1, len(r))
@@ -819,15 +818,15 @@ class TestCaseget_groups:
 
     def test_group_with_multiple_matches(self):
         # This results in 3 matches
-        itemList = [NamedObject("foo"), NamedObject("foo"), NamedObject("foo")]
-        matches = getmatches(itemList)
+        item_list = [NamedObject("foo"), NamedObject("foo"), NamedObject("foo")]
+        matches = getmatches(item_list)
         r = get_groups(matches)
         eq_(1, len(r))
         g = r[0]
         eq_(3, len(g))
 
     def test_must_choose_a_group(self):
-        itemList = [
+        item_list = [
             NamedObject("a b"),
             NamedObject("a b"),
             NamedObject("b c"),
@@ -836,13 +835,13 @@ class TestCaseget_groups:
         ]
         # There will be 2 groups here: group "a b" and group "c d"
         # "b c" can go either of them, but not both.
-        matches = getmatches(itemList)
+        matches = getmatches(item_list)
         r = get_groups(matches)
         eq_(2, len(r))
         eq_(5, len(r[0]) + len(r[1]))
 
     def test_should_all_go_in_the_same_group(self):
-        itemList = [
+        item_list = [
             NamedObject("a b"),
             NamedObject("a b"),
             NamedObject("a b"),
@@ -850,7 +849,7 @@ class TestCaseget_groups:
         ]
         # There will be 2 groups here: group "a b" and group "c d"
         # "b c" can fit in both, but it must be in only one of them
-        matches = getmatches(itemList)
+        matches = getmatches(item_list)
         r = get_groups(matches)
         eq_(1, len(r))
 
@@ -869,8 +868,8 @@ class TestCaseget_groups:
         assert o3 in g
 
     def test_four_sized_group(self):
-        itemList = [NamedObject("foobar") for i in range(4)]
-        m = getmatches(itemList)
+        item_list = [NamedObject("foobar") for _ in range(4)]
+        m = getmatches(item_list)
         r = get_groups(m)
         eq_(1, len(r))
         eq_(4, len(r[0]))
diff --git a/core/tests/exclude_test.py b/core/tests/exclude_test.py
index 38568e49..af812211 100644
--- a/core/tests/exclude_test.py
+++ b/core/tests/exclude_test.py
@@ -5,12 +5,8 @@
 # http://www.gnu.org/licenses/gpl-3.0.html
 
 import io
-
-# import os.path as op
-
 from xml.etree import ElementTree as ET
 
-# from pytest import raises
 from hscommon.testutil import eq_
 from hscommon.plat import ISWINDOWS
 
@@ -144,11 +140,7 @@ class TestCaseListEmpty:
     def test_force_add_not_compilable(self):
         """Used when loading from XML for example"""
         regex = r"one))"
-        try:
-            self.exclude_list.add(regex, forced=True)
-        except Exception as e:
-            # Should not get an exception here unless it's a duplicate regex
-            raise e
+        self.exclude_list.add(regex, forced=True)
         marked = self.exclude_list.mark(regex)
         eq_(marked, False)  # can't be marked since not compilable
         eq_(len(self.exclude_list), 1)
@@ -232,7 +224,6 @@ class TestCaseListEmpty:
                     found = True
             if not found:
                 raise (Exception(f"Default RE {re} not found in compiled list."))
-            continue
         eq_(len(default_regexes), len(self.exclude_list.compiled))
 
 
diff --git a/core/tests/ignore_test.py b/core/tests/ignore_test.py
index 073b027a..9021b653 100644
--- a/core/tests/ignore_test.py
+++ b/core/tests/ignore_test.py
@@ -77,7 +77,7 @@ def test_save_to_xml():
     eq_(len(subchildren), 3)
 
 
-def test_SaveThenLoad():
+def test_save_then_load():
     il = IgnoreList()
     il.Ignore("foo", "bar")
     il.Ignore("foo", "bleh")
@@ -92,7 +92,7 @@ def test_SaveThenLoad():
     assert il.AreIgnored("\u00e9", "bar")
 
 
-def test_LoadXML_with_empty_file_tags():
+def test_load_xml_with_empty_file_tags():
     f = io.BytesIO()
     f.write(b'<?xml version="1.0" encoding="utf-8"?><ignore_list><file><file/></file></ignore_list>')
     f.seek(0)
@@ -101,7 +101,7 @@ def test_LoadXML_with_empty_file_tags():
     eq_(0, len(il))
 
 
-def test_AreIgnore_works_when_a_child_is_a_key_somewhere_else():
+def test_are_ignore_works_when_a_child_is_a_key_somewhere_else():
     il = IgnoreList()
     il.Ignore("foo", "bar")
     il.Ignore("bar", "baz")
diff --git a/core/tests/results_test.py b/core/tests/results_test.py
index 9c43a256..30674633 100644
--- a/core/tests/results_test.py
+++ b/core/tests/results_test.py
@@ -402,7 +402,7 @@ class TestCaseResultsMarkings:
         self.results.make_ref(d)
         eq_("0 / 3 (0.00 B / 3.00 B) duplicates marked.", self.results.stat_line)
 
-    def test_SaveXML(self):
+    def test_save_xml(self):
         self.results.mark(self.objects[1])
         self.results.mark_invert()
         f = io.BytesIO()
@@ -419,7 +419,7 @@ class TestCaseResultsMarkings:
         eq_("n", d1.get("marked"))
         eq_("y", d2.get("marked"))
 
-    def test_LoadXML(self):
+    def test_load_xml(self):
         def get_file(path):
             return [f for f in self.objects if str(f.path) == path][0]
 
@@ -485,7 +485,7 @@ class TestCaseResultsXML:
         eq_("ibabtu", d1.get("words"))
         eq_("ibabtu", d2.get("words"))
 
-    def test_LoadXML(self):
+    def test_load_xml(self):
         def get_file(path):
             return [f for f in self.objects if str(f.path) == path][0]
 
@@ -517,7 +517,7 @@ class TestCaseResultsXML:
         eq_(["ibabtu"], g2[0].words)
         eq_(["ibabtu"], g2[1].words)
 
-    def test_LoadXML_with_filename(self, tmpdir):
+    def test_load_xml_with_filename(self, tmpdir):
         def get_file(path):
             return [f for f in self.objects if str(f.path) == path][0]
 
@@ -529,7 +529,7 @@ class TestCaseResultsXML:
         r.load_from_xml(filename, get_file)
         eq_(2, len(r.groups))
 
-    def test_LoadXML_with_some_files_that_dont_exist_anymore(self):
+    def test_load_xml_with_some_files_that_dont_exist_anymore(self):
         def get_file(path):
             if path.endswith("ibabtu 2"):
                 return None
@@ -545,7 +545,7 @@ class TestCaseResultsXML:
         eq_(1, len(r.groups))
         eq_(3, len(r.groups[0]))
 
-    def test_LoadXML_missing_attributes_and_bogus_elements(self):
+    def test_load_xml_missing_attributes_and_bogus_elements(self):
         def get_file(path):
             return [f for f in self.objects if str(f.path) == path][0]
 
diff --git a/core/tests/scanner_test.py b/core/tests/scanner_test.py
index c715d23d..6016b294 100644
--- a/core/tests/scanner_test.py
+++ b/core/tests/scanner_test.py
@@ -98,7 +98,7 @@ def test_trim_all_ref_groups(fake_fileexists):
     eq_(s.discarded_file_count, 0)
 
 
-def test_priorize(fake_fileexists):
+def test_prioritize(fake_fileexists):
     s = Scanner()
     f = [
         no("foo", path="p1"),
@@ -133,7 +133,7 @@ def test_content_scan(fake_fileexists):
 def test_content_scan_compare_sizes_first(fake_fileexists):
     class MyFile(no):
         @property
-        def md5(file):
+        def md5(self):
             raise AssertionError()
 
     s = Scanner()
@@ -587,8 +587,8 @@ def test_dont_count_ref_files_as_discarded(fake_fileexists):
     eq_(s.discarded_file_count, 0)
 
 
-def test_priorize_me(fake_fileexists):
-    # in ScannerME, bitrate goes first (right after is_ref) in priorization
+def test_prioritize_me(fake_fileexists):
+    # in ScannerME, bitrate goes first (right after is_ref) in prioritization
     s = ScannerME()
     o1, o2 = no("foo", path="p1"), no("foo", path="p2")
     o1.bitrate = 1