Misc cleanups in core/tests
This commit is contained in:
parent
b4fa1d68f0
commit
0189c29f47
GPG Key ID:
C63300DCE48AB2F1
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
#
|
||||
|
|
|
|||
|
|
@ -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(""))
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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]))
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue