Merge pull request #1330 from radarhere/tests

Added various tests

Tests/check_imaging_leaks.py

@@ -3,7 +3,7 @@
 from __future__ import division
 from helper import unittest, PillowTestCase
 import sys
-from PIL import Image, ImageFilter
+from PIL import Image
 
 min_iterations = 100
 max_iterations = 10000
@@ -31,7 +31,8 @@ class TestImagingLeaks(PillowTestCase):
 
     def test_leak_putdata(self):
         im = Image.new('RGB', (25, 25))
-        self._test_leak(min_iterations, max_iterations, im.putdata, im.getdata())
+        self._test_leak(min_iterations, max_iterations,
+                        im.putdata, im.getdata())
 
     def test_leak_getlist(self):
         im = Image.new('P', (25, 25))

Tests/check_png_dos.py

@@ -42,7 +42,8 @@ class TestPngDos(PillowTestCase):
         total_len = 0
         for txt in im2.text.values():
             total_len += len(txt)
-        self.assertLess(total_len, 64*1024*1024, "Total text chunks greater than 64M")
+        self.assertLess(total_len, 64*1024*1024,
+                        "Total text chunks greater than 64M")
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_cffi.py

@@ -61,6 +61,10 @@ class TestCffi(PillowTestCase):
             for y in range(0, h, 10):
                 self.assertEqual(access[(x, y)], caccess[(x, y)])
 
+        # Access an out-of-range pixel
+        self.assertRaises(ValueError,
+                          lambda: access[(access.xsize+1, access.ysize+1)])
+
     def test_get_vs_c(self):
         rgb = hopper('RGB')
         rgb.load()
@@ -70,7 +74,7 @@ class TestCffi(PillowTestCase):
         self._test_get_access(hopper('LA'))
         self._test_get_access(hopper('1'))
         self._test_get_access(hopper('P'))
-        # self._test_get_access(hopper('PA')) # PA   -- how do I make a PA image?
+        # self._test_get_access(hopper('PA')) # PA -- how do I make a PA image?
         self._test_get_access(hopper('F'))
 
         im = Image.new('I;16', (10, 10), 40000)
@@ -103,6 +107,14 @@ class TestCffi(PillowTestCase):
                 access[(x, y)] = color
                 self.assertEqual(color, caccess[(x, y)])
 
+        # Attempt to set the value on a read-only image
+        access = PyAccess.new(im, True)
+        try:
+            access[(0, 0)] = color
+        except ValueError:
+            return
+        self.fail("Putpixel did not fail on a read-only image")
+
     def test_set_vs_c(self):
         rgb = hopper('RGB')
         rgb.load()

Tests/test_file_bmp.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase, hopper
 
-from PIL import Image
+from PIL import Image, BmpImagePlugin
 import io
 
 
@@ -25,6 +25,11 @@ class TestFileBmp(PillowTestCase):
         self.roundtrip(hopper("P"))
         self.roundtrip(hopper("RGB"))
 
+    def test_invalid_file(self):
+        with open("Tests/images/flower.jpg", "rb") as fp:
+            self.assertRaises(SyntaxError,
+                              lambda: BmpImagePlugin.BmpImageFile(fp))
+
     def test_save_to_bytes(self):
         output = io.BytesIO()
         im = hopper()

Tests/test_file_bufrstub.py

@@ -0,0 +1,19 @@
+from helper import unittest, PillowTestCase
+
+from PIL import BufrStubImagePlugin
+
+
+class TestFileBufrStub(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          BufrStubImagePlugin.BufrStubImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_cur.py

@@ -20,6 +20,12 @@ class TestFileCur(PillowTestCase):
         self.assertEqual(im.getpixel((11, 1)), (253, 254, 254, 1))
         self.assertEqual(im.getpixel((16, 16)), (84, 87, 86, 255))
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: CurImagePlugin.CurImageFile(invalid_file))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_dcx.py

@@ -20,6 +20,11 @@ class TestFileDcx(PillowTestCase):
         orig = hopper()
         self.assert_image_equal(im, orig)
 
+    def test_invalid_file(self):
+        with open("Tests/images/flower.jpg", "rb") as fp:
+            self.assertRaises(SyntaxError,
+                              lambda: DcxImagePlugin.DcxImageFile(fp))
+
     def test_tell(self):
         # Arrange
         im = Image.open(TEST_FILE)

Tests/test_file_eps.py

@@ -51,6 +51,12 @@ class TestFileEps(PillowTestCase):
         self.assertEqual(image2_scale2.size, (720, 504))
         self.assertEqual(image2_scale2.format, "EPS")
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: EpsImagePlugin.EpsImageFile(invalid_file))
+
     def test_file_object(self):
         # issue 479
         image1 = Image.open(file1)
@@ -149,7 +155,9 @@ class TestFileEps(PillowTestCase):
         Image.open(file3)
 
     def _test_readline(self, t, ending):
-        ending = "Failure with line ending: %s" % ("".join("%s" % ord(s) for s in ending))
+        ending = "Failure with line ending: %s" % ("".join(
+                                                   "%s" % ord(s)
+                                                   for s in ending))
         self.assertEqual(t.readline().strip('\r\n'), 'something', ending)
         self.assertEqual(t.readline().strip('\r\n'), 'else', ending)
         self.assertEqual(t.readline().strip('\r\n'), 'baz', ending)

Tests/test_file_fitsstub.py

@@ -0,0 +1,19 @@
+from helper import unittest, PillowTestCase
+
+from PIL import FitsStubImagePlugin
+
+
+class TestFileFitsStub(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          FitsStubImagePlugin.FITSStubImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_fli.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase
 
-from PIL import Image
+from PIL import Image, FliImagePlugin
 
 # sample ppm stream
 # created as an export of a palette image from Gimp2.6
@@ -18,6 +18,12 @@ class TestFileFli(PillowTestCase):
         self.assertEqual(im.size, (128, 128))
         self.assertEqual(im.format, "FLI")
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: FliImagePlugin.FliImageFile(invalid_file))
+
     def test_n_frames(self):
         im = Image.open(test_file)
         self.assertEqual(im.n_frames, 1)

Tests/test_file_fpx.py

@@ -0,0 +1,18 @@
+from helper import unittest, PillowTestCase
+
+from PIL import FpxImagePlugin
+
+
+class TestFileFpx(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: FpxImagePlugin.FpxImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_gbr.py

@@ -0,0 +1,18 @@
+from helper import unittest, PillowTestCase
+
+from PIL import GbrImagePlugin
+
+
+class TestFileGbr(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: GbrImagePlugin.GbrImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_gif.py

@@ -25,6 +25,12 @@ class TestFileGif(PillowTestCase):
         self.assertEqual(im.size, (128, 128))
         self.assertEqual(im.format, "GIF")
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: GifImagePlugin.GifImageFile(invalid_file))
+
     def test_optimize(self):
         from io import BytesIO
 

Tests/test_file_gribstub.py

@@ -0,0 +1,19 @@
+from helper import unittest, PillowTestCase
+
+from PIL import GribStubImagePlugin
+
+
+class TestFileGribStub(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          GribStubImagePlugin.GribStubImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_hdf5stub.py

@@ -0,0 +1,19 @@
+from helper import unittest, PillowTestCase
+
+from PIL import Hdf5StubImagePlugin
+
+
+class TestFileHdf5Stub(PillowTestCase):
+
+    def test_invalid_file(self):
+        test_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          Hdf5StubImagePlugin.HDF5StubImageFile(test_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_ico.py

@@ -1,7 +1,7 @@
 from helper import unittest, PillowTestCase, hopper
 
 import io
-from PIL import Image
+from PIL import Image, IcoImagePlugin
 
 # sample ppm stream
 TEST_ICO_FILE = "Tests/images/hopper.ico"
@@ -17,6 +17,11 @@ class TestFileIco(PillowTestCase):
         self.assertEqual(im.size, (16, 16))
         self.assertEqual(im.format, "ICO")
 
+    def test_invalid_file(self):
+        with open("Tests/images/flower.jpg", "rb") as fp:
+            self.assertRaises(SyntaxError,
+                              lambda: IcoImagePlugin.IcoImageFile(fp))
+
     def test_save_to_bytes(self):
         output = io.BytesIO()
         im = hopper()
@@ -30,7 +35,8 @@ class TestFileIco(PillowTestCase):
         self.assertEqual(im.mode, reloaded.mode)
         self.assertEqual((64, 64), reloaded.size)
         self.assertEqual(reloaded.format, "ICO")
-        self.assert_image_equal(reloaded, hopper().resize((64, 64), Image.LANCZOS))
+        self.assert_image_equal(reloaded,
+                                hopper().resize((64, 64), Image.LANCZOS))
 
         # the other one
         output.seek(0)
@@ -40,7 +46,8 @@ class TestFileIco(PillowTestCase):
         self.assertEqual(im.mode, reloaded.mode)
         self.assertEqual((32, 32), reloaded.size)
         self.assertEqual(reloaded.format, "ICO")
-        self.assert_image_equal(reloaded, hopper().resize((32, 32), Image.LANCZOS))
+        self.assert_image_equal(reloaded,
+                                hopper().resize((32, 32), Image.LANCZOS))
 
 
 if __name__ == '__main__':

Tests/test_file_im.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase, hopper
 
-from PIL import Image
+from PIL import Image, ImImagePlugin
 
 # sample im
 TEST_IM = "Tests/images/hopper.im"
@@ -40,6 +40,13 @@ class TestFileIm(PillowTestCase):
 
         self.assert_image_equal(reread, im)
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: ImImagePlugin.ImImageFile(invalid_file))
+
+
 if __name__ == '__main__':
     unittest.main()
 

Tests/test_file_jpeg.py

@@ -291,22 +291,24 @@ class TestFileJpeg(PillowTestCase):
 
         # dict of qtable lists
         self.assert_image_similar(im,
-                                  self.roundtrip(im,
-                                                 qtables={0: standard_l_qtable,
-                                                          1: standard_chrominance_qtable}),
-                                  30)
+                                  self.roundtrip(im, qtables={
+                                    0: standard_l_qtable,
+                                    1: standard_chrominance_qtable
+                                  }), 30)
 
         # not a sequence
         self.assertRaises(Exception, lambda: self.roundtrip(im, qtables='a'))
         # sequence wrong length
         self.assertRaises(Exception, lambda: self.roundtrip(im, qtables=[]))
         # sequence wrong length
-        self.assertRaises(Exception, lambda: self.roundtrip(im, qtables=[1, 2, 3, 4, 5]))
+        self.assertRaises(Exception,
+                          lambda: self.roundtrip(im, qtables=[1, 2, 3, 4, 5]))
 
         # qtable entry not a sequence
         self.assertRaises(Exception, lambda: self.roundtrip(im, qtables=[1]))
         # qtable entry has wrong number of items
-        self.assertRaises(Exception, lambda: self.roundtrip(im, qtables=[[1, 2, 3, 4]]))
+        self.assertRaises(Exception,
+                          lambda: self.roundtrip(im, qtables=[[1, 2, 3, 4]]))
 
     @unittest.skipUnless(djpeg_available(), "djpeg not available")
     def test_load_djpeg(self):
@@ -337,7 +339,8 @@ class TestFileJpeg(PillowTestCase):
             """ Generates a very hard to compress file
             :param size: tuple
             """
-            return Image.frombytes('RGB', size, os.urandom(size[0]*size[1] * 3))
+            return Image.frombytes('RGB',
+                                   size, os.urandom(size[0]*size[1] * 3))
 
         im = gen_random_image((512, 512))
         f = self.tempfile("temp.jpeg")

Tests/test_file_jpeg2k.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase
 
-from PIL import Image
+from PIL import Image, Jpeg2KImagePlugin
 from io import BytesIO
 
 codecs = dir(Image.core)
@@ -39,6 +39,13 @@ class TestFileJpeg2k(PillowTestCase):
         self.assertEqual(im.size, (640, 480))
         self.assertEqual(im.format, 'JPEG2000')
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          Jpeg2KImagePlugin.Jpeg2KImageFile(invalid_file))
+
     def test_bytesio(self):
         with open('Tests/images/test-card-lossless.jp2', 'rb') as f:
             data = BytesIO(f.read())

Tests/test_file_mcidas.py

@@ -0,0 +1,19 @@
+from helper import unittest, PillowTestCase
+
+from PIL import McIdasImagePlugin
+
+
+class TestFileMcIdas(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda:
+                          McIdasImagePlugin.McIdasImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_mic.py

@@ -0,0 +1,18 @@
+from helper import unittest, PillowTestCase
+
+from PIL import MicImagePlugin
+
+
+class TestFileMic(PillowTestCase):
+
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: MicImagePlugin.MicImageFile(invalid_file))
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+# End of file

Tests/test_file_msp.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase, hopper
 
-from PIL import Image
+from PIL import Image, MspImagePlugin
 
 TEST_FILE = "Tests/images/hopper.msp"
 
@@ -18,6 +18,12 @@ class TestFileMsp(PillowTestCase):
         self.assertEqual(im.size, (128, 128))
         self.assertEqual(im.format, "MSP")
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: MspImagePlugin.MspImageFile(invalid_file))
+
     def test_open(self):
         # Arrange
         # Act

Tests/test_file_pcx.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase, hopper
 
-from PIL import Image
+from PIL import Image, PcxImagePlugin
 
 
 class TestFilePcx(PillowTestCase):
@@ -19,6 +19,12 @@ class TestFilePcx(PillowTestCase):
         for mode in ('1', 'L', 'P', 'RGB'):
             self._roundtrip(hopper(mode))
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: PcxImagePlugin.PcxImageFile(invalid_file))
+
     def test_odd(self):
         # see issue #523, odd sized images should have a stride that's even.
         # not that imagemagick or gimp write pcx that way.

Tests/test_file_pdf.py

@@ -52,6 +52,12 @@ class TestFilePdf(PillowTestCase):
         # Act / Assert
         self.helper_save_as_pdf(mode)
 
+    def test_unsupported_mode(self):
+        im = hopper("LA")
+        outfile = self.tempfile("temp_LA.pdf")
+
+        self.assertRaises(ValueError, lambda: im.save(outfile))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_png.py

@@ -81,6 +81,12 @@ class TestFilePng(PillowTestCase):
         hopper("I").save(test_file)
         im = Image.open(test_file)
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: PngImagePlugin.PngImageFile(invalid_file))
+
     def test_broken(self):
         # Check reading of totally broken files.  In this case, the test
         # file was checked into Subversion as a text file.

Tests/test_file_psd.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase
 
-from PIL import Image
+from PIL import Image, PsdImagePlugin
 
 # sample ppm stream
 test_file = "Tests/images/hopper.psd"
@@ -16,6 +16,12 @@ class TestImagePsd(PillowTestCase):
         self.assertEqual(im.size, (128, 128))
         self.assertEqual(im.format, "PSD")
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: PsdImagePlugin.PsdImageFile(invalid_file))
+
     def test_n_frames(self):
         im = Image.open("Tests/images/hopper_merged.psd")
         self.assertEqual(im.n_frames, 1)

Tests/test_file_sgi.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase
 
-from PIL import Image
+from PIL import Image, SgiImagePlugin
 
 
 class TestFileSgi(PillowTestCase):
@@ -32,6 +32,13 @@ class TestFileSgi(PillowTestCase):
         # Act / Assert
         self.assertRaises(ValueError, lambda: Image.open(test_file))
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(ValueError,
+                          lambda:
+                          SgiImagePlugin.SgiImageFile(invalid_file))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_sun.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase
 
-from PIL import Image
+from PIL import Image, SunImagePlugin
 
 
 class TestFileSun(PillowTestCase):
@@ -16,6 +16,10 @@ class TestFileSun(PillowTestCase):
         # Assert
         self.assertEqual(im.size, (128, 128))
 
+        invalid_file = "Tests/images/flower.jpg"
+        self.assertRaises(SyntaxError,
+                          lambda: SunImagePlugin.SunImageFile(invalid_file))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_tga.py

@@ -15,6 +15,25 @@ class TestFileTga(PillowTestCase):
         # Assert
         self.assertEqual(im.size, (100, 100))
 
+    def test_save(self):
+        test_file = "Tests/images/tga_id_field.tga"
+        im = Image.open(test_file)
+
+        test_file = self.tempfile("temp.tga")
+
+        # Save
+        im.save(test_file)
+        test_im = Image.open(test_file)
+        self.assertEqual(test_im.size, (100, 100))
+
+        # RGBA save
+        im.convert("RGBA").save(test_file)
+        test_im = Image.open(test_file)
+        self.assertEqual(test_im.size, (100, 100))
+
+        # Unsupported mode save
+        self.assertRaises(IOError, lambda: im.convert("LA").save(test_file))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_tiff.py

@@ -86,7 +86,8 @@ class TestFileTiff(PillowTestCase):
         try:
             Image.open('Tests/images/hopper_bad_exif.jpg')._getexif()
         except struct.error:
-            self.fail("Bad EXIF data should not pass incorrect values to _binary unpack")
+            self.fail(
+                 "Bad EXIF data passed incorrect values to _binary unpack")
 
     def test_little_endian(self):
         im = Image.open('Tests/images/16bit.cropped.tif')

Tests/test_file_webp.py

@@ -72,6 +72,11 @@ class TestFileWebp(PillowTestCase):
         target = hopper("RGB")
         self.assert_image_similar(image, target, 12)
 
+    def test_write_unsupported_mode(self):
+        temp_file = self.tempfile("temp.webp")
+
+        self.assertRaises(IOError, lambda: hopper("L").save(temp_file))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_file_webp_alpha.py

@@ -83,7 +83,8 @@ class TestFileWebpAlpha(PillowTestCase):
         image.load()
         image.getdata()
 
-        # early versions of webp are known to produce higher deviations: deal with it
+        # early versions of webp are known to produce higher deviations:
+        # deal with it
         if _webp.WebPDecoderVersion(self) <= 0x201:
             self.assert_image_similar(image, pil_image, 3.0)
         else:

Tests/test_file_xpm.py

@@ -1,6 +1,6 @@
 from helper import unittest, PillowTestCase, hopper
 
-from PIL import Image
+from PIL import Image, XpmImagePlugin
 
 # sample ppm stream
 TEST_FILE = "Tests/images/hopper.xpm"
@@ -18,6 +18,12 @@ class TestFileXpm(PillowTestCase):
         # large error due to quantization->44 colors.
         self.assert_image_similar(im.convert('RGB'), hopper('RGB'), 60)
 
+    def test_invalid_file(self):
+        invalid_file = "Tests/images/flower.jpg"
+
+        self.assertRaises(SyntaxError,
+                          lambda: XpmImagePlugin.XpmImageFile(invalid_file))
+
     def test_load_read(self):
         # Arrange
         im = Image.open(TEST_FILE)

Tests/test_font_bdf.py

@@ -15,6 +15,10 @@ class TestFontBdf(PillowTestCase):
         self.assertIsInstance(font, FontFile.FontFile)
         self.assertEqual(len([_f for _f in font.glyph if _f]), 190)
 
+    def test_invalid_file(self):
+        with open("Tests/images/flower.jpg", "rb") as fp:
+            self.assertRaises(SyntaxError, lambda: BdfFontFile.BdfFontFile(fp))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_font_pcf.py

@@ -30,6 +30,10 @@ class TestFontPcf(PillowTestCase):
     def test_sanity(self):
         self.save_font()
 
+    def test_invalid_file(self):
+        with open("Tests/images/flower.jpg", "rb") as fp:
+            self.assertRaises(SyntaxError, lambda: PcfFontFile.PcfFontFile(fp))
+
     def xtest_draw(self):
 
         tempname = self.save_font()

Tests/test_image_filter.py

@@ -88,6 +88,12 @@ class TestImageFilter(PillowTestCase):
         self.assertEqual(rankfilter("I"), (0, 4, 8))
         self.assertEqual(rankfilter("F"), (0.0, 4.0, 8.0))
 
+    def test_rankfilter_properties(self):
+        rankfilter = ImageFilter.RankFilter(1, 2)
+
+        self.assertEqual(rankfilter.size, 1)
+        self.assertEqual(rankfilter.rank, 2)
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_image_mode.py

@@ -21,12 +21,14 @@ class TestImageMode(PillowTestCase):
 
         m = ImageMode.getmode("1")
         self.assertEqual(m.mode, "1")
+        self.assertEqual(str(m), "1")
         self.assertEqual(m.bands, ("1",))
         self.assertEqual(m.basemode, "L")
         self.assertEqual(m.basetype, "L")
 
         m = ImageMode.getmode("RGB")
         self.assertEqual(m.mode, "RGB")
+        self.assertEqual(str(m), "RGB")
         self.assertEqual(m.bands, ("R", "G", "B"))
         self.assertEqual(m.basemode, "RGB")
         self.assertEqual(m.basetype, "L")

Tests/test_imagecolor.py

@@ -18,6 +18,9 @@ class TestImageColor(PillowTestCase):
             (255, 0, 0, 0), ImageColor.getrgb("rgba(255, 0, 0, 0)"))
         self.assertEqual((255, 0, 0), ImageColor.getrgb("red"))
 
+        self.assertRaises(ValueError,
+                          lambda: ImageColor.getrgb("invalid color"))
+
     # look for rounding errors (based on code by Tim Hatch)
     def test_rounding_errors(self):
 
@@ -43,8 +46,8 @@ class TestImageColor(PillowTestCase):
 
         self.assertEqual(0, ImageColor.getcolor("black", "L"))
         self.assertEqual(255, ImageColor.getcolor("white", "L"))
-        self.assertEqual(
-            162, ImageColor.getcolor("rgba(0, 255, 115, 33)", "L"))
+        self.assertEqual(162,
+                         ImageColor.getcolor("rgba(0, 255, 115, 33)", "L"))
         Image.new("L", (1, 1), "white")
 
         self.assertEqual(0, ImageColor.getcolor("black", "1"))

Tests/test_imagedraw.py

@@ -52,6 +52,12 @@ class TestImageDraw(PillowTestCase):
         self.assert_warning(DeprecationWarning, lambda: draw.setink(0))
         self.assert_warning(DeprecationWarning, lambda: draw.setfill(0))
 
+    def test_mode_mismatch(self):
+        im = hopper("RGB").copy()
+
+        self.assertRaises(ValueError,
+                          lambda: ImageDraw.ImageDraw(im, mode="L"))
+
     def helper_arc(self, bbox):
         # Arrange
         im = Image.new("RGB", (W, H))

Tests/test_imagefile.py

@@ -93,6 +93,9 @@ class TestImageFile(PillowTestCase):
 
         self.assert_image_equal(im1, im2)
 
+    def test_raise_ioerror(self):
+        self.assertRaises(IOError, lambda: ImageFile.raise_ioerror(1))
+
 
 if __name__ == '__main__':
     unittest.main()

Tests/test_imagefont_bitmap.py

@@ -5,16 +5,19 @@ from PIL import Image, ImageFont, ImageDraw
 class TestImageFontBitmap(PillowTestCase):
     def test_similar(self):
         text = 'EmbeddedBitmap'
-        font_outline = ImageFont.truetype(font='Tests/fonts/DejaVuSans.ttf', size=24)
-        font_bitmap = ImageFont.truetype(font='Tests/fonts/DejaVuSans-bitmap.ttf', size=24)
+        font_outline = ImageFont.truetype(
+                       font='Tests/fonts/DejaVuSans.ttf', size=24)
+        font_bitmap = ImageFont.truetype(
+                      font='Tests/fonts/DejaVuSans-bitmap.ttf', size=24)
         size_outline, size_bitmap = font_outline.getsize(text), font_bitmap.getsize(text)
         size_final = max(size_outline[0], size_bitmap[0]), max(size_outline[1], size_bitmap[1])
         im_bitmap = Image.new('RGB', size_final, (255, 255, 255))
         im_outline = im_bitmap.copy()
         draw_bitmap, draw_outline = ImageDraw.Draw(im_bitmap), ImageDraw.Draw(im_outline)
 
-        # Metrics are different on the bitmap and ttf fonts, more so on some platforms
-        # and versions of freetype than others. Mac has a 1px difference, linux doesn't.
+        # Metrics are different on the bitmap and ttf fonts,
+        # more so on some platforms and versions of freetype than others.
+        # Mac has a 1px difference, linux doesn't.
         draw_bitmap.text((0, size_final[1] - size_bitmap[1]),
                          text, fill=(0, 0, 0), font=font_bitmap)
         draw_outline.text((0, size_final[1] - size_outline[1]),

Tests/test_imageops_usm.py

@@ -75,7 +75,9 @@ class TestImageOpsUsm(PillowTestCase):
                         (4, 3, 2), (4, 2, 2)]:
             self.assertGreaterEqual(i.im.getpixel((x, y))[c], 250)
         # Fuzzy match.
-        gp = lambda x, y: i.im.getpixel((x, y))
+
+        def gp(x, y):
+            return i.im.getpixel((x, y))
         self.assertTrue(236 <= gp(7, 4)[0] <= 239)
         self.assertTrue(236 <= gp(7, 5)[2] <= 239)
         self.assertTrue(236 <= gp(7, 6)[2] <= 239)

Tests/test_imagesequence.py

@@ -22,6 +22,8 @@ class TestImageSequence(PillowTestCase):
 
         self.assertEqual(index, 1)
 
+        self.assertRaises(AttributeError, lambda: ImageSequence.Iterator(0))
+
     def _test_multipage_tiff(self, dbg=False):
         im = Image.open('Tests/images/multipage.tiff')
         for index, frame in enumerate(ImageSequence.Iterator(im)):

Tests/test_imagewin.py

@@ -115,7 +115,8 @@ class TestImageWinDib(PillowTestCase):
 
         # Act/Assert
         self.assert_warning(DeprecationWarning, dib.tostring)
-        self.assert_warning(DeprecationWarning, lambda: dib.fromstring(test_buffer))
+        self.assert_warning(DeprecationWarning,
+                            lambda: dib.fromstring(test_buffer))
 
 
 if __name__ == '__main__':

Tests/test_olefileio.py

@@ -7,25 +7,20 @@ import PIL.OleFileIO as OleFileIO
 
 class TestOleFileIo(PillowTestCase):
 
-    def test_isOleFile_false(self):
-        # Arrange
-        non_ole_file = "Tests/images/flower.jpg"
-
-        # Act
-        is_ole = OleFileIO.isOleFile(non_ole_file)
-
-        # Assert
-        self.assertFalse(is_ole)
-
-    def test_isOleFile_true(self):
-        # Arrange
+    def test_isOleFile(self):
         ole_file = "Tests/images/test-ole-file.doc"
 
-        # Act
-        is_ole = OleFileIO.isOleFile(ole_file)
+        self.assertTrue(OleFileIO.isOleFile(ole_file))
+        with open(ole_file, 'rb') as fp:
+            self.assertTrue(OleFileIO.isOleFile(fp))
+            self.assertTrue(OleFileIO.isOleFile(fp.read()))
 
-        # Assert
-        self.assertTrue(is_ole)
+        non_ole_file = "Tests/images/flower.jpg"
+
+        self.assertFalse(OleFileIO.isOleFile(non_ole_file))
+        with open(non_ole_file, 'rb') as fp:
+            self.assertFalse(OleFileIO.isOleFile(fp))
+            self.assertFalse(OleFileIO.isOleFile(fp.read()))
 
     def test_exists_worddocument(self):
         # Arrange

Tests/test_scipy.py

@@ -30,10 +30,10 @@ class Test_scipy_resize(PillowTestCase):
     def test_imresize4(self):
         im = np.array([[1, 2],
                        [3, 4]])
-        res = np.array([[1. ,  1.25,  1.75,  2. ],
+        res = np.array([[1.,   1.25,  1.75,  2.],
                         [1.5,  1.75,  2.25,  2.5],
                         [2.5,  2.75,  3.25,  3.5],
-                        [3. ,  3.25,  3.75,  4. ]], dtype=np.float32)
+                        [3.,   3.25,  3.75,  4.]], dtype=np.float32)
         # Check that resizing by target size, float and int are the same
         im2 = misc.imresize(im, (4, 4), mode='F')  # output size
         im3 = misc.imresize(im, 2., mode='F')  # fraction