mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-02-13 18:11:02 +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()
|
# 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):
|
# def assert_image_completely_equal(a, b, msg=None):
|
||||||
# if a != b:
|
# if a != b:
|
||||||
# failure(msg or "images different")
|
# 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