mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-02-03 21:24:31 +03:00
Move more tests
This commit is contained in:
hugovk
parent
2e52f3ab46
commit
c8626c6e93
|
|
@ -1,33 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
from PIL import Image
|
||||
|
||||
im = lena().resize((128, 100))
|
||||
|
||||
def test_toarray():
|
||||
def test(mode):
|
||||
ai = im.convert(mode).__array_interface__
|
||||
return ai["shape"], ai["typestr"], len(ai["data"])
|
||||
# assert_equal(test("1"), ((100, 128), '|b1', 1600))
|
||||
assert_equal(test("L"), ((100, 128), '|u1', 12800))
|
||||
assert_equal(test("I"), ((100, 128), Image._ENDIAN + 'i4', 51200)) # FIXME: wrong?
|
||||
assert_equal(test("F"), ((100, 128), Image._ENDIAN + 'f4', 51200)) # FIXME: wrong?
|
||||
assert_equal(test("RGB"), ((100, 128, 3), '|u1', 38400))
|
||||
assert_equal(test("RGBA"), ((100, 128, 4), '|u1', 51200))
|
||||
assert_equal(test("RGBX"), ((100, 128, 4), '|u1', 51200))
|
||||
|
||||
def test_fromarray():
|
||||
def test(mode):
|
||||
i = im.convert(mode)
|
||||
a = i.__array_interface__
|
||||
a["strides"] = 1 # pretend it's non-contigous
|
||||
i.__array_interface__ = a # patch in new version of attribute
|
||||
out = Image.fromarray(i)
|
||||
return out.mode, out.size, list(i.getdata()) == list(out.getdata())
|
||||
# assert_equal(test("1"), ("1", (128, 100), True))
|
||||
assert_equal(test("L"), ("L", (128, 100), True))
|
||||
assert_equal(test("I"), ("I", (128, 100), True))
|
||||
assert_equal(test("F"), ("F", (128, 100), True))
|
||||
assert_equal(test("RGB"), ("RGB", (128, 100), True))
|
||||
assert_equal(test("RGBA"), ("RGBA", (128, 100), True))
|
||||
assert_equal(test("RGBX"), ("RGBA", (128, 100), True))
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
from PIL import Image
|
||||
|
||||
def test_crop():
|
||||
def crop(mode):
|
||||
out = lena(mode).crop((50, 50, 100, 100))
|
||||
assert_equal(out.mode, mode)
|
||||
assert_equal(out.size, (50, 50))
|
||||
for mode in "1", "P", "L", "RGB", "I", "F":
|
||||
yield_test(crop, mode)
|
||||
|
||||
def test_wide_crop():
|
||||
|
||||
def crop(*bbox):
|
||||
i = im.crop(bbox)
|
||||
h = i.histogram()
|
||||
while h and not h[-1]:
|
||||
del h[-1]
|
||||
return tuple(h)
|
||||
|
||||
im = Image.new("L", (100, 100), 1)
|
||||
|
||||
assert_equal(crop(0, 0, 100, 100), (0, 10000))
|
||||
assert_equal(crop(25, 25, 75, 75), (0, 2500))
|
||||
|
||||
# sides
|
||||
assert_equal(crop(-25, 0, 25, 50), (1250, 1250))
|
||||
assert_equal(crop(0, -25, 50, 25), (1250, 1250))
|
||||
assert_equal(crop(75, 0, 125, 50), (1250, 1250))
|
||||
assert_equal(crop(0, 75, 50, 125), (1250, 1250))
|
||||
|
||||
assert_equal(crop(-25, 25, 125, 75), (2500, 5000))
|
||||
assert_equal(crop(25, -25, 75, 125), (2500, 5000))
|
||||
|
||||
# corners
|
||||
assert_equal(crop(-25, -25, 25, 25), (1875, 625))
|
||||
assert_equal(crop(75, -25, 125, 25), (1875, 625))
|
||||
assert_equal(crop(75, 75, 125, 125), (1875, 625))
|
||||
assert_equal(crop(-25, 75, 25, 125), (1875, 625))
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
def test_negative_crop():
|
||||
# Check negative crop size (@PIL171)
|
||||
|
||||
im = Image.new("L", (512, 512))
|
||||
im = im.crop((400, 400, 200, 200))
|
||||
|
||||
assert_equal(im.size, (0, 0))
|
||||
assert_equal(len(im.getdata()), 0)
|
||||
assert_exception(IndexError, lambda: im.getdata()[0])
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageFilter
|
||||
|
||||
def test_sanity():
|
||||
|
||||
def filter(filter):
|
||||
im = lena("L")
|
||||
out = im.filter(filter)
|
||||
assert_equal(out.mode, im.mode)
|
||||
assert_equal(out.size, im.size)
|
||||
|
||||
filter(ImageFilter.BLUR)
|
||||
filter(ImageFilter.CONTOUR)
|
||||
filter(ImageFilter.DETAIL)
|
||||
filter(ImageFilter.EDGE_ENHANCE)
|
||||
filter(ImageFilter.EDGE_ENHANCE_MORE)
|
||||
filter(ImageFilter.EMBOSS)
|
||||
filter(ImageFilter.FIND_EDGES)
|
||||
filter(ImageFilter.SMOOTH)
|
||||
filter(ImageFilter.SMOOTH_MORE)
|
||||
filter(ImageFilter.SHARPEN)
|
||||
filter(ImageFilter.MaxFilter)
|
||||
filter(ImageFilter.MedianFilter)
|
||||
filter(ImageFilter.MinFilter)
|
||||
filter(ImageFilter.ModeFilter)
|
||||
filter(ImageFilter.Kernel((3, 3), list(range(9))))
|
||||
|
||||
assert_exception(TypeError, lambda: filter("hello"))
|
||||
|
||||
def test_crash():
|
||||
|
||||
# crashes on small images
|
||||
im = Image.new("RGB", (1, 1))
|
||||
assert_no_exception(lambda: im.filter(ImageFilter.SMOOTH))
|
||||
|
||||
im = Image.new("RGB", (2, 2))
|
||||
assert_no_exception(lambda: im.filter(ImageFilter.SMOOTH))
|
||||
|
||||
im = Image.new("RGB", (3, 3))
|
||||
assert_no_exception(lambda: im.filter(ImageFilter.SMOOTH))
|
||||
|
||||
def test_modefilter():
|
||||
|
||||
def modefilter(mode):
|
||||
im = Image.new(mode, (3, 3), None)
|
||||
im.putdata(list(range(9)))
|
||||
# image is:
|
||||
# 0 1 2
|
||||
# 3 4 5
|
||||
# 6 7 8
|
||||
mod = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
|
||||
im.putdata([0, 0, 1, 2, 5, 1, 5, 2, 0]) # mode=0
|
||||
mod2 = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
|
||||
return mod, mod2
|
||||
|
||||
assert_equal(modefilter("1"), (4, 0))
|
||||
assert_equal(modefilter("L"), (4, 0))
|
||||
assert_equal(modefilter("P"), (4, 0))
|
||||
assert_equal(modefilter("RGB"), ((4, 0, 0), (0, 0, 0)))
|
||||
|
||||
def test_rankfilter():
|
||||
|
||||
def rankfilter(mode):
|
||||
im = Image.new(mode, (3, 3), None)
|
||||
im.putdata(list(range(9)))
|
||||
# image is:
|
||||
# 0 1 2
|
||||
# 3 4 5
|
||||
# 6 7 8
|
||||
min = im.filter(ImageFilter.MinFilter).getpixel((1, 1))
|
||||
med = im.filter(ImageFilter.MedianFilter).getpixel((1, 1))
|
||||
max = im.filter(ImageFilter.MaxFilter).getpixel((1, 1))
|
||||
return min, med, max
|
||||
|
||||
assert_equal(rankfilter("1"), (0, 4, 8))
|
||||
assert_equal(rankfilter("L"), (0, 4, 8))
|
||||
assert_exception(ValueError, lambda: rankfilter("P"))
|
||||
assert_equal(rankfilter("RGB"), ((0, 0, 0), (4, 0, 0), (8, 0, 0)))
|
||||
assert_equal(rankfilter("I"), (0, 4, 8))
|
||||
assert_equal(rankfilter("F"), (0.0, 4.0, 8.0))
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
import sys
|
||||
|
||||
from PIL import Image
|
||||
|
||||
def test_sanity():
|
||||
|
||||
im1 = lena()
|
||||
|
||||
data = list(im1.getdata())
|
||||
|
||||
im2 = Image.new(im1.mode, im1.size, 0)
|
||||
im2.putdata(data)
|
||||
|
||||
assert_image_equal(im1, im2)
|
||||
|
||||
# readonly
|
||||
im2 = Image.new(im1.mode, im2.size, 0)
|
||||
im2.readonly = 1
|
||||
im2.putdata(data)
|
||||
|
||||
assert_false(im2.readonly)
|
||||
assert_image_equal(im1, im2)
|
||||
|
||||
|
||||
def test_long_integers():
|
||||
# see bug-200802-systemerror
|
||||
def put(value):
|
||||
im = Image.new("RGBA", (1, 1))
|
||||
im.putdata([value])
|
||||
return im.getpixel((0, 0))
|
||||
assert_equal(put(0xFFFFFFFF), (255, 255, 255, 255))
|
||||
assert_equal(put(0xFFFFFFFF), (255, 255, 255, 255))
|
||||
assert_equal(put(-1), (255, 255, 255, 255))
|
||||
assert_equal(put(-1), (255, 255, 255, 255))
|
||||
if sys.maxsize > 2**32:
|
||||
assert_equal(put(sys.maxsize), (255, 255, 255, 255))
|
||||
else:
|
||||
assert_equal(put(sys.maxsize), (255, 255, 255, 127))
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageFilter
|
||||
|
||||
def test_sanity():
|
||||
# see test_image_filter for more tests
|
||||
|
||||
assert_no_exception(lambda: ImageFilter.MaxFilter)
|
||||
assert_no_exception(lambda: ImageFilter.MedianFilter)
|
||||
assert_no_exception(lambda: ImageFilter.MinFilter)
|
||||
assert_no_exception(lambda: ImageFilter.ModeFilter)
|
||||
assert_no_exception(lambda: ImageFilter.Kernel((3, 3), list(range(9))))
|
||||
assert_no_exception(lambda: ImageFilter.GaussianBlur)
|
||||
assert_no_exception(lambda: ImageFilter.GaussianBlur(5))
|
||||
assert_no_exception(lambda: ImageFilter.UnsharpMask)
|
||||
assert_no_exception(lambda: ImageFilter.UnsharpMask(10))
|
||||
|
||||
assert_no_exception(lambda: ImageFilter.BLUR)
|
||||
assert_no_exception(lambda: ImageFilter.CONTOUR)
|
||||
assert_no_exception(lambda: ImageFilter.DETAIL)
|
||||
assert_no_exception(lambda: ImageFilter.EDGE_ENHANCE)
|
||||
assert_no_exception(lambda: ImageFilter.EDGE_ENHANCE_MORE)
|
||||
assert_no_exception(lambda: ImageFilter.EMBOSS)
|
||||
assert_no_exception(lambda: ImageFilter.FIND_EDGES)
|
||||
assert_no_exception(lambda: ImageFilter.SMOOTH)
|
||||
assert_no_exception(lambda: ImageFilter.SMOOTH_MORE)
|
||||
assert_no_exception(lambda: ImageFilter.SHARPEN)
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
from tester import *
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageStat
|
||||
|
||||
def test_sanity():
|
||||
|
||||
im = lena()
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
st = ImageStat.Stat(im.histogram())
|
||||
st = ImageStat.Stat(im, Image.new("1", im.size, 1))
|
||||
|
||||
assert_no_exception(lambda: st.extrema)
|
||||
assert_no_exception(lambda: st.sum)
|
||||
assert_no_exception(lambda: st.mean)
|
||||
assert_no_exception(lambda: st.median)
|
||||
assert_no_exception(lambda: st.rms)
|
||||
assert_no_exception(lambda: st.sum2)
|
||||
assert_no_exception(lambda: st.var)
|
||||
assert_no_exception(lambda: st.stddev)
|
||||
assert_exception(AttributeError, lambda: st.spam)
|
||||
|
||||
assert_exception(TypeError, lambda: ImageStat.Stat(1))
|
||||
|
||||
def test_lena():
|
||||
|
||||
im = lena()
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
|
||||
# verify a few values
|
||||
assert_equal(st.extrema[0], (61, 255))
|
||||
assert_equal(st.median[0], 197)
|
||||
assert_equal(st.sum[0], 2954416)
|
||||
assert_equal(st.sum[1], 2027250)
|
||||
assert_equal(st.sum[2], 1727331)
|
||||
|
||||
def test_constant():
|
||||
|
||||
im = Image.new("L", (128, 128), 128)
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
|
||||
assert_equal(st.extrema[0], (128, 128))
|
||||
assert_equal(st.sum[0], 128**3)
|
||||
assert_equal(st.sum2[0], 128**4)
|
||||
assert_equal(st.mean[0], 128)
|
||||
assert_equal(st.median[0], 128)
|
||||
assert_equal(st.rms[0], 128)
|
||||
assert_equal(st.var[0], 0)
|
||||
assert_equal(st.stddev[0], 0)
|
||||
46
test/test_image_array.py
Normal file
46
test/test_image_array.py
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
from tester import unittest, PillowTestCase, lena
|
||||
|
||||
from PIL import Image
|
||||
|
||||
im = lena().resize((128, 100))
|
||||
|
||||
|
||||
class TestImageCrop(PillowTestCase):
|
||||
|
||||
def test_toarray(self):
|
||||
def test(mode):
|
||||
ai = im.convert(mode).__array_interface__
|
||||
return ai["shape"], ai["typestr"], len(ai["data"])
|
||||
# self.assertEqual(test("1"), ((100, 128), '|b1', 1600))
|
||||
self.assertEqual(test("L"), ((100, 128), '|u1', 12800))
|
||||
|
||||
# FIXME: wrong?
|
||||
self.assertEqual(test("I"), ((100, 128), Image._ENDIAN + 'i4', 51200))
|
||||
# FIXME: wrong?
|
||||
self.assertEqual(test("F"), ((100, 128), Image._ENDIAN + 'f4', 51200))
|
||||
|
||||
self.assertEqual(test("RGB"), ((100, 128, 3), '|u1', 38400))
|
||||
self.assertEqual(test("RGBA"), ((100, 128, 4), '|u1', 51200))
|
||||
self.assertEqual(test("RGBX"), ((100, 128, 4), '|u1', 51200))
|
||||
|
||||
def test_fromarray(self):
|
||||
def test(mode):
|
||||
i = im.convert(mode)
|
||||
a = i.__array_interface__
|
||||
a["strides"] = 1 # pretend it's non-contigous
|
||||
i.__array_interface__ = a # patch in new version of attribute
|
||||
out = Image.fromarray(i)
|
||||
return out.mode, out.size, list(i.getdata()) == list(out.getdata())
|
||||
# self.assertEqual(test("1"), ("1", (128, 100), True))
|
||||
self.assertEqual(test("L"), ("L", (128, 100), True))
|
||||
self.assertEqual(test("I"), ("I", (128, 100), True))
|
||||
self.assertEqual(test("F"), ("F", (128, 100), True))
|
||||
self.assertEqual(test("RGB"), ("RGB", (128, 100), True))
|
||||
self.assertEqual(test("RGBA"), ("RGBA", (128, 100), True))
|
||||
self.assertEqual(test("RGBX"), ("RGBA", (128, 100), True))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
59
test/test_image_crop.py
Normal file
59
test/test_image_crop.py
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
from tester import unittest, PillowTestCase, lena
|
||||
|
||||
from PIL import Image
|
||||
|
||||
|
||||
class TestImageCrop(PillowTestCase):
|
||||
|
||||
def test_crop(self):
|
||||
def crop(mode):
|
||||
out = lena(mode).crop((50, 50, 100, 100))
|
||||
self.assertEqual(out.mode, mode)
|
||||
self.assertEqual(out.size, (50, 50))
|
||||
for mode in "1", "P", "L", "RGB", "I", "F":
|
||||
crop(mode)
|
||||
|
||||
def test_wide_crop(self):
|
||||
|
||||
def crop(*bbox):
|
||||
i = im.crop(bbox)
|
||||
h = i.histogram()
|
||||
while h and not h[-1]:
|
||||
del h[-1]
|
||||
return tuple(h)
|
||||
|
||||
im = Image.new("L", (100, 100), 1)
|
||||
|
||||
self.assertEqual(crop(0, 0, 100, 100), (0, 10000))
|
||||
self.assertEqual(crop(25, 25, 75, 75), (0, 2500))
|
||||
|
||||
# sides
|
||||
self.assertEqual(crop(-25, 0, 25, 50), (1250, 1250))
|
||||
self.assertEqual(crop(0, -25, 50, 25), (1250, 1250))
|
||||
self.assertEqual(crop(75, 0, 125, 50), (1250, 1250))
|
||||
self.assertEqual(crop(0, 75, 50, 125), (1250, 1250))
|
||||
|
||||
self.assertEqual(crop(-25, 25, 125, 75), (2500, 5000))
|
||||
self.assertEqual(crop(25, -25, 75, 125), (2500, 5000))
|
||||
|
||||
# corners
|
||||
self.assertEqual(crop(-25, -25, 25, 25), (1875, 625))
|
||||
self.assertEqual(crop(75, -25, 125, 25), (1875, 625))
|
||||
self.assertEqual(crop(75, 75, 125, 125), (1875, 625))
|
||||
self.assertEqual(crop(-25, 75, 25, 125), (1875, 625))
|
||||
|
||||
def test_negative_crop(self):
|
||||
# Check negative crop size (@PIL171)
|
||||
|
||||
im = Image.new("L", (512, 512))
|
||||
im = im.crop((400, 400, 200, 200))
|
||||
|
||||
self.assertEqual(im.size, (0, 0))
|
||||
self.assertEqual(len(im.getdata()), 0)
|
||||
self.assertRaises(IndexError, lambda: im.getdata()[0])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
91
test/test_image_filter.py
Normal file
91
test/test_image_filter.py
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
from tester import unittest, PillowTestCase, lena
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageFilter
|
||||
|
||||
|
||||
class TestImageFilter(PillowTestCase):
|
||||
|
||||
def test_sanity(self):
|
||||
|
||||
def filter(filter):
|
||||
im = lena("L")
|
||||
out = im.filter(filter)
|
||||
self.assertEqual(out.mode, im.mode)
|
||||
self.assertEqual(out.size, im.size)
|
||||
|
||||
filter(ImageFilter.BLUR)
|
||||
filter(ImageFilter.CONTOUR)
|
||||
filter(ImageFilter.DETAIL)
|
||||
filter(ImageFilter.EDGE_ENHANCE)
|
||||
filter(ImageFilter.EDGE_ENHANCE_MORE)
|
||||
filter(ImageFilter.EMBOSS)
|
||||
filter(ImageFilter.FIND_EDGES)
|
||||
filter(ImageFilter.SMOOTH)
|
||||
filter(ImageFilter.SMOOTH_MORE)
|
||||
filter(ImageFilter.SHARPEN)
|
||||
filter(ImageFilter.MaxFilter)
|
||||
filter(ImageFilter.MedianFilter)
|
||||
filter(ImageFilter.MinFilter)
|
||||
filter(ImageFilter.ModeFilter)
|
||||
filter(ImageFilter.Kernel((3, 3), list(range(9))))
|
||||
|
||||
self.assertRaises(TypeError, lambda: filter("hello"))
|
||||
|
||||
def test_crash(self):
|
||||
|
||||
# crashes on small images
|
||||
im = Image.new("RGB", (1, 1))
|
||||
im.filter(ImageFilter.SMOOTH)
|
||||
|
||||
im = Image.new("RGB", (2, 2))
|
||||
im.filter(ImageFilter.SMOOTH)
|
||||
|
||||
im = Image.new("RGB", (3, 3))
|
||||
im.filter(ImageFilter.SMOOTH)
|
||||
|
||||
def test_modefilter(self):
|
||||
|
||||
def modefilter(mode):
|
||||
im = Image.new(mode, (3, 3), None)
|
||||
im.putdata(list(range(9)))
|
||||
# image is:
|
||||
# 0 1 2
|
||||
# 3 4 5
|
||||
# 6 7 8
|
||||
mod = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
|
||||
im.putdata([0, 0, 1, 2, 5, 1, 5, 2, 0]) # mode=0
|
||||
mod2 = im.filter(ImageFilter.ModeFilter).getpixel((1, 1))
|
||||
return mod, mod2
|
||||
|
||||
self.assertEqual(modefilter("1"), (4, 0))
|
||||
self.assertEqual(modefilter("L"), (4, 0))
|
||||
self.assertEqual(modefilter("P"), (4, 0))
|
||||
self.assertEqual(modefilter("RGB"), ((4, 0, 0), (0, 0, 0)))
|
||||
|
||||
def test_rankfilter(self):
|
||||
|
||||
def rankfilter(mode):
|
||||
im = Image.new(mode, (3, 3), None)
|
||||
im.putdata(list(range(9)))
|
||||
# image is:
|
||||
# 0 1 2
|
||||
# 3 4 5
|
||||
# 6 7 8
|
||||
min = im.filter(ImageFilter.MinFilter).getpixel((1, 1))
|
||||
med = im.filter(ImageFilter.MedianFilter).getpixel((1, 1))
|
||||
max = im.filter(ImageFilter.MaxFilter).getpixel((1, 1))
|
||||
return min, med, max
|
||||
|
||||
self.assertEqual(rankfilter("1"), (0, 4, 8))
|
||||
self.assertEqual(rankfilter("L"), (0, 4, 8))
|
||||
self.assertRaises(ValueError, lambda: rankfilter("P"))
|
||||
self.assertEqual(rankfilter("RGB"), ((0, 0, 0), (4, 0, 0), (8, 0, 0)))
|
||||
self.assertEqual(rankfilter("I"), (0, 4, 8))
|
||||
self.assertEqual(rankfilter("F"), (0.0, 4.0, 8.0))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
48
test/test_image_putdata.py
Normal file
48
test/test_image_putdata.py
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
from tester import unittest, PillowTestCase, lena
|
||||
|
||||
import sys
|
||||
|
||||
from PIL import Image
|
||||
|
||||
|
||||
class TestImagePutData(PillowTestCase):
|
||||
|
||||
def test_sanity(self):
|
||||
|
||||
im1 = lena()
|
||||
|
||||
data = list(im1.getdata())
|
||||
|
||||
im2 = Image.new(im1.mode, im1.size, 0)
|
||||
im2.putdata(data)
|
||||
|
||||
self.assert_image_equal(im1, im2)
|
||||
|
||||
# readonly
|
||||
im2 = Image.new(im1.mode, im2.size, 0)
|
||||
im2.readonly = 1
|
||||
im2.putdata(data)
|
||||
|
||||
self.assertFalse(im2.readonly)
|
||||
self.assert_image_equal(im1, im2)
|
||||
|
||||
def test_long_integers(self):
|
||||
# see bug-200802-systemerror
|
||||
def put(value):
|
||||
im = Image.new("RGBA", (1, 1))
|
||||
im.putdata([value])
|
||||
return im.getpixel((0, 0))
|
||||
self.assertEqual(put(0xFFFFFFFF), (255, 255, 255, 255))
|
||||
self.assertEqual(put(0xFFFFFFFF), (255, 255, 255, 255))
|
||||
self.assertEqual(put(-1), (255, 255, 255, 255))
|
||||
self.assertEqual(put(-1), (255, 255, 255, 255))
|
||||
if sys.maxsize > 2**32:
|
||||
self.assertEqual(put(sys.maxsize), (255, 255, 255, 255))
|
||||
else:
|
||||
self.assertEqual(put(sys.maxsize), (255, 255, 255, 127))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
37
test/test_imagefilter.py
Normal file
37
test/test_imagefilter.py
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
from tester import unittest, PillowTestCase
|
||||
|
||||
from PIL import ImageFilter
|
||||
|
||||
|
||||
class TestImageFilter(PillowTestCase):
|
||||
|
||||
def test_sanity(self):
|
||||
# see test_image_filter for more tests
|
||||
|
||||
# Check these run. Exceptions cause failures.
|
||||
ImageFilter.MaxFilter
|
||||
ImageFilter.MedianFilter
|
||||
ImageFilter.MinFilter
|
||||
ImageFilter.ModeFilter
|
||||
ImageFilter.Kernel((3, 3), list(range(9)))
|
||||
ImageFilter.GaussianBlur
|
||||
ImageFilter.GaussianBlur(5)
|
||||
ImageFilter.UnsharpMask
|
||||
ImageFilter.UnsharpMask(10)
|
||||
|
||||
ImageFilter.BLUR
|
||||
ImageFilter.CONTOUR
|
||||
ImageFilter.DETAIL
|
||||
ImageFilter.EDGE_ENHANCE
|
||||
ImageFilter.EDGE_ENHANCE_MORE
|
||||
ImageFilter.EMBOSS
|
||||
ImageFilter.FIND_EDGES
|
||||
ImageFilter.SMOOTH
|
||||
ImageFilter.SMOOTH_MORE
|
||||
ImageFilter.SHARPEN
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
63
test/test_imagestat.py
Normal file
63
test/test_imagestat.py
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
from tester import unittest, PillowTestCase, lena
|
||||
|
||||
from PIL import Image
|
||||
from PIL import ImageStat
|
||||
|
||||
|
||||
class TestImageStat(PillowTestCase):
|
||||
|
||||
def test_sanity(self):
|
||||
|
||||
im = lena()
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
st = ImageStat.Stat(im.histogram())
|
||||
st = ImageStat.Stat(im, Image.new("1", im.size, 1))
|
||||
|
||||
# Check these run. Exceptions will cause failures.
|
||||
st.extrema
|
||||
st.sum
|
||||
st.mean
|
||||
st.median
|
||||
st.rms
|
||||
st.sum2
|
||||
st.var
|
||||
st.stddev
|
||||
|
||||
self.assertRaises(AttributeError, lambda: st.spam)
|
||||
|
||||
self.assertRaises(TypeError, lambda: ImageStat.Stat(1))
|
||||
|
||||
def test_lena(self):
|
||||
|
||||
im = lena()
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
|
||||
# verify a few values
|
||||
self.assertEqual(st.extrema[0], (61, 255))
|
||||
self.assertEqual(st.median[0], 197)
|
||||
self.assertEqual(st.sum[0], 2954416)
|
||||
self.assertEqual(st.sum[1], 2027250)
|
||||
self.assertEqual(st.sum[2], 1727331)
|
||||
|
||||
def test_constant(self):
|
||||
|
||||
im = Image.new("L", (128, 128), 128)
|
||||
|
||||
st = ImageStat.Stat(im)
|
||||
|
||||
self.assertEqual(st.extrema[0], (128, 128))
|
||||
self.assertEqual(st.sum[0], 128**3)
|
||||
self.assertEqual(st.sum2[0], 128**4)
|
||||
self.assertEqual(st.mean[0], 128)
|
||||
self.assertEqual(st.median[0], 128)
|
||||
self.assertEqual(st.rms[0], 128)
|
||||
self.assertEqual(st.var[0], 0)
|
||||
self.assertEqual(st.stddev[0], 0)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
|
|
@ -161,17 +161,6 @@ def lena(mode="RGB", cache={}):
|
|||
# success()
|
||||
#
|
||||
#
|
||||
# def assert_image_equal(a, b, msg=None):
|
||||
# if a.mode != b.mode:
|
||||
# failure(msg or "got mode %r, expected %r" % (a.mode, b.mode))
|
||||
# elif a.size != b.size:
|
||||
# failure(msg or "got size %r, expected %r" % (a.size, b.size))
|
||||
# elif a.tobytes() != b.tobytes():
|
||||
# failure(msg or "got different content")
|
||||
# else:
|
||||
# success()
|
||||
#
|
||||
#
|
||||
# def assert_image_completely_equal(a, b, msg=None):
|
||||
# if a != b:
|
||||
# failure(msg or "images different")
|
||||
|
|
|
|||
|
|
@ -1,19 +0,0 @@
|
|||
from tester import unittest
|
||||
|
||||
|
||||
class SomeTests(unittest.TestCase):
|
||||
"""
|
||||
Can we start moving the test suite here?
|
||||
"""
|
||||
|
||||
def test_suite_should_move_here(self):
|
||||
"""
|
||||
Great idea!
|
||||
"""
|
||||
self.assertTrue(True)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
||||
# End of file
|
||||
Loading…
Reference in New Issue
Block a user