arsenetar/dupeguru
1
0
Fork 0
mirror of https://github.com/arsenetar/dupeguru.git synced 2025-07-03 22:13:20 +00:00
Code Releases Wiki Activity

Modernized core_pe tests and added skipping when the modules haven't been compiled (rather than a hard crash).

Browse Source
This commit is contained in:
Virgil Dupras 2011-01-01 17:17:27 +01:00
parent 800a879927
commit b5b27b141c
2 changed files with 111 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
core_pe/tests/block_test.py
View File

@ -7,9 +7,13 @@
# http://www.hardcoded.net/licenses/bsd_license # http://www.hardcoded.net/licenses/bsd_license
# The commented out tests are tests for function that have been converted to pure C for speed # The commented out tests are tests for function that have been converted to pure C for speed
import unittest from pytest import raises, skip
from hsutil.testutil import eq_
try:
from ..block import * from ..block import *
except ImportError:
skip("Can't import the block module, probably hasn't been compiled.")
def my_avgdiff(first, second, limit=768, min_iter=3): # this is so I don't have to re-write every call def my_avgdiff(first, second, limit=768, min_iter=3): # this is so I don't have to re-write every call
return avgdiff(first, second, limit, min_iter) return avgdiff(first, second, limit, min_iter)
@ -19,7 +23,7 @@ RED = (0xff,0,0)
GREEN = (0,0xff,0) GREEN = (0,0xff,0)
BLUE = (0,0,0xff) BLUE = (0,0,0xff)
class FakeImage(object): class FakeImage:
def __init__(self, size, data): def __init__(self, size, data):
self.size = size self.size = size
self.data = data self.data = data
@ -45,15 +49,15 @@ def four_pixels():
pixels = [RED,(0,0x80,0xff),(0x80,0,0),(0,0x40,0x80)] pixels = [RED,(0,0x80,0xff),(0x80,0,0),(0,0x40,0x80)]
return FakeImage((2, 2), pixels) return FakeImage((2, 2), pixels)
class TCgetblock(unittest.TestCase): class TestCasegetblock:
def test_single_pixel(self): def test_single_pixel(self):
im = single_pixel() im = single_pixel()
[b] = getblocks2(im, 1) [b] = getblocks2(im, 1)
self.assertEqual(RED,b) eq_(RED,b)
def test_no_pixel(self): def test_no_pixel(self):
im = empty() im = empty()
self.assertEqual([], getblocks2(im, 1)) eq_([], getblocks2(im, 1))
def test_four_pixels(self): def test_four_pixels(self):
im = four_pixels() im = four_pixels()
@ -61,46 +65,46 @@ class TCgetblock(unittest.TestCase):
meanred = (0xff + 0x80) // 4 meanred = (0xff + 0x80) // 4
meangreen = (0x80 + 0x40) // 4 meangreen = (0x80 + 0x40) // 4
meanblue = (0xff + 0x80) // 4 meanblue = (0xff + 0x80) // 4
self.assertEqual((meanred,meangreen,meanblue),b) eq_((meanred,meangreen,meanblue),b)
# class TCdiff(unittest.TestCase): # class TCdiff(unittest.TestCase):
# def test_diff(self): # def test_diff(self):
# b1 = (10, 20, 30) # b1 = (10, 20, 30)
# b2 = (1, 2, 3) # b2 = (1, 2, 3)
# self.assertEqual(9 + 18 + 27,diff(b1,b2)) # eq_(9 + 18 + 27,diff(b1,b2))
# #
# def test_diff_negative(self): # def test_diff_negative(self):
# b1 = (10, 20, 30) # b1 = (10, 20, 30)
# b2 = (1, 2, 3) # b2 = (1, 2, 3)
# self.assertEqual(9 + 18 + 27,diff(b2,b1)) # eq_(9 + 18 + 27,diff(b2,b1))
# #
# def test_diff_mixed_positive_and_negative(self): # def test_diff_mixed_positive_and_negative(self):
# b1 = (1, 5, 10) # b1 = (1, 5, 10)
# b2 = (10, 1, 15) # b2 = (10, 1, 15)
# self.assertEqual(9 + 4 + 5,diff(b1,b2)) # eq_(9 + 4 + 5,diff(b1,b2))
# #
# class TCgetblocks(unittest.TestCase): # class TCgetblocks(unittest.TestCase):
# def test_empty_image(self): # def test_empty_image(self):
# im = empty() # im = empty()
# blocks = getblocks(im,1) # blocks = getblocks(im,1)
# self.assertEqual(0,len(blocks)) # eq_(0,len(blocks))
# #
# def test_one_block_image(self): # def test_one_block_image(self):
# im = four_pixels() # im = four_pixels()
# blocks = getblocks2(im, 1) # blocks = getblocks2(im, 1)
# self.assertEqual(1,len(blocks)) # eq_(1,len(blocks))
# block = blocks[0] # block = blocks[0]
# meanred = (0xff + 0x80) // 4 # meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4 # meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4 # meanblue = (0xff + 0x80) // 4
# self.assertEqual((meanred,meangreen,meanblue),block) # eq_((meanred,meangreen,meanblue),block)
# #
# def test_not_enough_height_to_fit_a_block(self): # def test_not_enough_height_to_fit_a_block(self):
# im = FakeImage((2,1), [BLACK, BLACK]) # im = FakeImage((2,1), [BLACK, BLACK])
# blocks = getblocks(im,2) # blocks = getblocks(im,2)
# self.assertEqual(0,len(blocks)) # eq_(0,len(blocks))
# #
# def xtest_dont_include_leftovers(self): # def xtest_dont_include_leftovers(self):
# # this test is disabled because getblocks is not used and getblock in cdeffed # # this test is disabled because getblocks is not used and getblock in cdeffed
@ -116,7 +120,7 @@ class TCgetblock(unittest.TestCase):
# meanred = (0xff + 0x80) // 4 # meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4 # meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4 # meanblue = (0xff + 0x80) // 4
# self.assertEqual((meanred,meangreen,meanblue),block) # eq_((meanred,meangreen,meanblue),block)
# #
# def xtest_two_blocks(self): # def xtest_two_blocks(self):
# # this test is disabled because getblocks is not used and getblock in cdeffed # # this test is disabled because getblocks is not used and getblock in cdeffed
@ -127,14 +131,14 @@ class TCgetblock(unittest.TestCase):
# pixels[5] = (0,0x40,0x80) # pixels[5] = (0,0x40,0x80)
# im = FakeImage((4, 2), pixels) # im = FakeImage((4, 2), pixels)
# blocks = getblocks(im,2) # blocks = getblocks(im,2)
# self.assertEqual(2,len(blocks)) # eq_(2,len(blocks))
# block = blocks[0] # block = blocks[0]
# #Because the block is smaller than the image, only blocksize must be considered. # #Because the block is smaller than the image, only blocksize must be considered.
# meanred = (0xff + 0x80) // 4 # meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4 # meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4 # meanblue = (0xff + 0x80) // 4
# self.assertEqual((meanred,meangreen,meanblue),block) # eq_((meanred,meangreen,meanblue),block)
# self.assertEqual(BLACK,blocks[1]) # eq_(BLACK,blocks[1])
# #
# def test_four_blocks(self): # def test_four_blocks(self):
# pixels = [BLACK for i in xrange(4 * 4)] # pixels = [BLACK for i in xrange(4 * 4)]
@ -144,65 +148,66 @@ class TCgetblock(unittest.TestCase):
# pixels[5] = (0,0x40,0x80) # pixels[5] = (0,0x40,0x80)
# im = FakeImage((4, 4), pixels) # im = FakeImage((4, 4), pixels)
# blocks = getblocks2(im, 2) # blocks = getblocks2(im, 2)
# self.assertEqual(4,len(blocks)) # eq_(4,len(blocks))
# block = blocks[0] # block = blocks[0]
# #Because the block is smaller than the image, only blocksize must be considered. # #Because the block is smaller than the image, only blocksize must be considered.
# meanred = (0xff + 0x80) // 4 # meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4 # meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4 # meanblue = (0xff + 0x80) // 4
# self.assertEqual((meanred,meangreen,meanblue),block) # eq_((meanred,meangreen,meanblue),block)
# self.assertEqual(BLACK,blocks[1]) # eq_(BLACK,blocks[1])
# self.assertEqual(BLACK,blocks[2]) # eq_(BLACK,blocks[2])
# self.assertEqual(BLACK,blocks[3]) # eq_(BLACK,blocks[3])
# #
class TCgetblocks2(unittest.TestCase): class TestCasegetblocks2:
def test_empty_image(self): def test_empty_image(self):
im = empty() im = empty()
blocks = getblocks2(im,1) blocks = getblocks2(im,1)
self.assertEqual(0,len(blocks)) eq_(0,len(blocks))
def test_one_block_image(self): def test_one_block_image(self):
im = four_pixels() im = four_pixels()
blocks = getblocks2(im,1) blocks = getblocks2(im,1)
self.assertEqual(1,len(blocks)) eq_(1,len(blocks))
block = blocks[0] block = blocks[0]
meanred = (0xff + 0x80) // 4 meanred = (0xff + 0x80) // 4
meangreen = (0x80 + 0x40) // 4 meangreen = (0x80 + 0x40) // 4
meanblue = (0xff + 0x80) // 4 meanblue = (0xff + 0x80) // 4
self.assertEqual((meanred,meangreen,meanblue),block) eq_((meanred,meangreen,meanblue),block)
def test_four_blocks_all_black(self): def test_four_blocks_all_black(self):
im = FakeImage((2, 2), [BLACK, BLACK, BLACK, BLACK]) im = FakeImage((2, 2), [BLACK, BLACK, BLACK, BLACK])
blocks = getblocks2(im,2) blocks = getblocks2(im,2)
self.assertEqual(4,len(blocks)) eq_(4,len(blocks))
for block in blocks: for block in blocks:
self.assertEqual(BLACK,block) eq_(BLACK,block)
def test_two_pixels_image_horizontal(self): def test_two_pixels_image_horizontal(self):
pixels = [RED,BLUE] pixels = [RED,BLUE]
im = FakeImage((2, 1), pixels) im = FakeImage((2, 1), pixels)
blocks = getblocks2(im,2) blocks = getblocks2(im,2)
self.assertEqual(4,len(blocks)) eq_(4,len(blocks))
self.assertEqual(RED,blocks[0]) eq_(RED,blocks[0])
self.assertEqual(BLUE,blocks[1]) eq_(BLUE,blocks[1])
self.assertEqual(RED,blocks[2]) eq_(RED,blocks[2])
self.assertEqual(BLUE,blocks[3]) eq_(BLUE,blocks[3])
def test_two_pixels_image_vertical(self): def test_two_pixels_image_vertical(self):
pixels = [RED,BLUE] pixels = [RED,BLUE]
im = FakeImage((1, 2), pixels) im = FakeImage((1, 2), pixels)
blocks = getblocks2(im,2) blocks = getblocks2(im,2)
self.assertEqual(4,len(blocks)) eq_(4,len(blocks))
self.assertEqual(RED,blocks[0]) eq_(RED,blocks[0])
self.assertEqual(RED,blocks[1]) eq_(RED,blocks[1])
self.assertEqual(BLUE,blocks[2]) eq_(BLUE,blocks[2])
self.assertEqual(BLUE,blocks[3]) eq_(BLUE,blocks[3])
class TCavgdiff(unittest.TestCase): class TestCaseavgdiff:
def test_empty(self): def test_empty(self):
self.assertRaises(NoBlocksError, my_avgdiff, [], []) with raises(NoBlocksError):
my_avgdiff([], [])
def test_two_blocks(self): def test_two_blocks(self):
im = empty() im = empty()
@ -215,16 +220,18 @@ class TCavgdiff(unittest.TestCase):
expected1 = 5 + 10 + 15 expected1 = 5 + 10 + 15
expected2 = 0 + 250 + 10 expected2 = 0 + 250 + 10
expected = (expected1 + expected2) // 2 expected = (expected1 + expected2) // 2
self.assertEqual(expected, my_avgdiff(blocks1, blocks2)) eq_(expected, my_avgdiff(blocks1, blocks2))
def test_blocks_not_the_same_size(self): def test_blocks_not_the_same_size(self):
b = (0,0,0) b = (0,0,0)
self.assertRaises(DifferentBlockCountError,my_avgdiff,[b,b],[b]) with raises(DifferentBlockCountError):
my_avgdiff([b,b],[b])
def test_first_arg_is_empty_but_not_second(self): def test_first_arg_is_empty_but_not_second(self):
#Don't return 0 (as when the 2 lists are empty), raise! #Don't return 0 (as when the 2 lists are empty), raise!
b = (0,0,0) b = (0,0,0)
self.assertRaises(DifferentBlockCountError,my_avgdiff,[],[b]) with raises(DifferentBlockCountError):
my_avgdiff([],[b])
def test_limit(self): def test_limit(self):
ref = (0,0,0) ref = (0,0,0)
@ -233,7 +240,7 @@ class TCavgdiff(unittest.TestCase):
b3 = (30,30,30) #avg 60 b3 = (30,30,30) #avg 60
blocks1 = [ref,ref,ref] blocks1 = [ref,ref,ref]
blocks2 = [b1,b2,b3] blocks2 = [b1,b2,b3]
self.assertEqual(45,my_avgdiff(blocks1,blocks2,44)) eq_(45,my_avgdiff(blocks1,blocks2,44))
def test_min_iterations(self): def test_min_iterations(self):
ref = (0,0,0) ref = (0,0,0)
@ -242,7 +249,7 @@ class TCavgdiff(unittest.TestCase):
b3 = (10,10,10) #avg 40 b3 = (10,10,10) #avg 40
blocks1 = [ref,ref,ref] blocks1 = [ref,ref,ref]
blocks2 = [b1,b2,b3] blocks2 = [b1,b2,b3]
self.assertEqual(40,my_avgdiff(blocks1,blocks2,45 - 1,3)) eq_(40,my_avgdiff(blocks1,blocks2,45 - 1,3))
# Bah, I don't know why this test fails, but I don't think it matters very much # Bah, I don't know why this test fails, but I don't think it matters very much
# def test_just_over_the_limit(self): # def test_just_over_the_limit(self):
@ -253,7 +260,7 @@ class TCavgdiff(unittest.TestCase):
# b2 = (11,0,0) # b2 = (11,0,0)
# blocks1 = [ref,ref] # blocks1 = [ref,ref]
# blocks2 = [b1,b2] # blocks2 = [b1,b2]
# self.assertEqual(11,my_avgdiff(blocks1,blocks2,10)) # eq_(11,my_avgdiff(blocks1,blocks2,10))
# #
def test_return_at_least_1_at_the_slightest_difference(self): def test_return_at_least_1_at_the_slightest_difference(self):
ref = (0,0,0) ref = (0,0,0)
@ -261,13 +268,13 @@ class TCavgdiff(unittest.TestCase):
blocks1 = [ref for i in range(250)] blocks1 = [ref for i in range(250)]
blocks2 = [ref for i in range(250)] blocks2 = [ref for i in range(250)]
blocks2[0] = b1 blocks2[0] = b1
self.assertEqual(1,my_avgdiff(blocks1,blocks2)) eq_(1,my_avgdiff(blocks1,blocks2))
def test_return_0_if_there_is_no_difference(self): def test_return_0_if_there_is_no_difference(self):
ref = (0,0,0) ref = (0,0,0)
blocks1 = [ref,ref] blocks1 = [ref,ref]
blocks2 = [ref,ref] blocks2 = [ref,ref]
self.assertEqual(0,my_avgdiff(blocks1,blocks2)) eq_(0,my_avgdiff(blocks1,blocks2))
# class TCmaxdiff(unittest.TestCase): # class TCmaxdiff(unittest.TestCase):
@ -284,7 +291,7 @@ class TCavgdiff(unittest.TestCase):
# expected1 = 5 + 10 + 15 # expected1 = 5 + 10 + 15
# expected2 = 0 + 250 + 10 # expected2 = 0 + 250 + 10
# expected = max(expected1,expected2) # expected = max(expected1,expected2)
# self.assertEqual(expected,maxdiff(blocks1,blocks2)) # eq_(expected,maxdiff(blocks1,blocks2))
# #
# def test_blocks_not_the_same_size(self): # def test_blocks_not_the_same_size(self):
# b = (0,0,0) # b = (0,0,0)
@ -304,5 +311,5 @@ class TCavgdiff(unittest.TestCase):
# blocks2 = [b3,b4] # blocks2 = [b3,b4]
# expected1 = 5 + 10 + 15 # expected1 = 5 + 10 + 15
# expected2 = 0 + 250 + 10 # expected2 = 0 + 250 + 10
# self.assertEqual(expected1,maxdiff(blocks1,blocks2,expected1 - 1)) # eq_(expected1,maxdiff(blocks1,blocks2,expected1 - 1))
# #

98
core_pe/tests/cache_test.py
View File

@ -6,71 +6,74 @@
# which should be included with this package. The terms are also available at # which should be included with this package. The terms are also available at
# http://www.hardcoded.net/licenses/bsd_license # http://www.hardcoded.net/licenses/bsd_license
import os.path as op import logging
import os
from hsutil.testcase import TestCase from pytest import raises, skip
from hsutil.testutil import eq_
from ..cache import * try:
from ..cache import Cache, colors_to_string, string_to_colors
except ImportError:
skip("Can't import the cache module, probably hasn't been compiled.")
class TCcolors_to_string(TestCase): class TestCasecolors_to_string:
def test_no_color(self): def test_no_color(self):
self.assertEqual('',colors_to_string([])) eq_('',colors_to_string([]))
def test_single_color(self): def test_single_color(self):
self.assertEqual('000000',colors_to_string([(0,0,0)])) eq_('000000',colors_to_string([(0,0,0)]))
self.assertEqual('010101',colors_to_string([(1,1,1)])) eq_('010101',colors_to_string([(1,1,1)]))
self.assertEqual('0a141e',colors_to_string([(10,20,30)])) eq_('0a141e',colors_to_string([(10,20,30)]))
def test_two_colors(self): def test_two_colors(self):
self.assertEqual('000102030405',colors_to_string([(0,1,2),(3,4,5)])) eq_('000102030405',colors_to_string([(0,1,2),(3,4,5)]))
class TCstring_to_colors(TestCase): class TestCasestring_to_colors:
def test_empty(self): def test_empty(self):
self.assertEqual([],string_to_colors('')) eq_([],string_to_colors(''))
def test_single_color(self): def test_single_color(self):
self.assertEqual([(0,0,0)],string_to_colors('000000')) eq_([(0,0,0)],string_to_colors('000000'))
self.assertEqual([(2,3,4)],string_to_colors('020304')) eq_([(2,3,4)],string_to_colors('020304'))
self.assertEqual([(10,20,30)],string_to_colors('0a141e')) eq_([(10,20,30)],string_to_colors('0a141e'))
def test_two_colors(self): def test_two_colors(self):
self.assertEqual([(10,20,30),(40,50,60)],string_to_colors('0a141e28323c')) eq_([(10,20,30),(40,50,60)],string_to_colors('0a141e28323c'))
def test_incomplete_color(self): def test_incomplete_color(self):
# don't return anything if it's not a complete color # don't return anything if it's not a complete color
self.assertEqual([],string_to_colors('102')) eq_([],string_to_colors('102'))
class TCCache(TestCase): class TestCaseCache:
def test_empty(self): def test_empty(self):
c = Cache() c = Cache()
self.assertEqual(0,len(c)) eq_(0,len(c))
self.assertRaises(KeyError,c.__getitem__,'foo') with raises(KeyError):
c['foo']
def test_set_then_retrieve_blocks(self): def test_set_then_retrieve_blocks(self):
c = Cache() c = Cache()
b = [(0,0,0),(1,2,3)] b = [(0,0,0),(1,2,3)]
c['foo'] = b c['foo'] = b
self.assertEqual(b,c['foo']) eq_(b,c['foo'])
def test_delitem(self): def test_delitem(self):
c = Cache() c = Cache()
c['foo'] = '' c['foo'] = ''
del c['foo'] del c['foo']
self.assert_('foo' not in c) assert 'foo' not in c
self.assertRaises(KeyError,c.__delitem__,'foo') with raises(KeyError):
del c['foo']
def test_persistance(self): def test_persistance(self, tmpdir):
DBNAME = op.join(self.tmpdir(), 'hstest.db') DBNAME = tmpdir.join('hstest.db')
c = Cache(DBNAME) c = Cache(str(DBNAME))
c['foo'] = [(1,2,3)] c['foo'] = [(1,2,3)]
del c del c
c = Cache(DBNAME) c = Cache(str(DBNAME))
self.assertEqual([(1,2,3)],c['foo']) eq_([(1,2,3)],c['foo'])
del c
os.remove(DBNAME)
def test_filter(self): def test_filter(self):
c = Cache() c = Cache()
@ -78,10 +81,10 @@ class TCCache(TestCase):
c['bar'] = '' c['bar'] = ''
c['baz'] = '' c['baz'] = ''
c.filter(lambda p:p != 'bar') #only 'bar' is removed c.filter(lambda p:p != 'bar') #only 'bar' is removed
self.assertEqual(2,len(c)) eq_(2,len(c))
self.assert_('foo' in c) assert 'foo' in c
self.assert_('baz' in c) assert 'baz' in c
self.assert_('bar' not in c) assert 'bar' not in c
def test_clear(self): def test_clear(self):
c = Cache() c = Cache()
@ -89,13 +92,17 @@ class TCCache(TestCase):
c['bar'] = '' c['bar'] = ''
c['baz'] = '' c['baz'] = ''
c.clear() c.clear()
self.assertEqual(0,len(c)) eq_(0,len(c))
self.assert_('foo' not in c) assert 'foo' not in c
self.assert_('baz' not in c) assert 'baz' not in c
self.assert_('bar' not in c) assert 'bar' not in c
def test_corrupted_db(self): def test_corrupted_db(self, tmpdir, monkeypatch):
dbname = op.join(self.tmpdir(), 'foo.db') # If we don't do this monkeypatching, we get a weird exception about trying to flush a
# closed file. I've tried setting logging level and stuff, but nothing worked. So, there we
# go, a dirty monkeypatch.
monkeypatch.setattr(logging, 'warning', lambda *args, **kw: None)
dbname = str(tmpdir.join('foo.db'))
fp = open(dbname, 'w') fp = open(dbname, 'w')
fp.write('invalid sqlite content') fp.write('invalid sqlite content')
fp.close() fp.close()
@ -103,7 +110,7 @@ class TCCache(TestCase):
c['foo'] = [(1, 2, 3)] c['foo'] = [(1, 2, 3)]
del c del c
c = Cache(dbname) c = Cache(dbname)
self.assertEqual(c['foo'], [(1, 2, 3)]) eq_(c['foo'], [(1, 2, 3)])
def test_by_id(self): def test_by_id(self):
# it's possible to use the cache by referring to the files by their row_id # it's possible to use the cache by referring to the files by their row_id
@ -111,17 +118,18 @@ class TCCache(TestCase):
b = [(0,0,0),(1,2,3)] b = [(0,0,0),(1,2,3)]
c['foo'] = b c['foo'] = b
foo_id = c.get_id('foo') foo_id = c.get_id('foo')
self.assertEqual(c[foo_id], b) eq_(c[foo_id], b)
class TCCacheSQLEscape(TestCase): class TestCaseCacheSQLEscape:
def test_contains(self): def test_contains(self):
c = Cache() c = Cache()
self.assert_("foo'bar" not in c) assert "foo'bar" not in c
def test_getitem(self): def test_getitem(self):
c = Cache() c = Cache()
self.assertRaises(KeyError, c.__getitem__, "foo'bar") with raises(KeyError):
c["foo'bar"]
def test_setitem(self): def test_setitem(self):
c = Cache() c = Cache()