Pillow/Tests/test_features.py

from __future__ import unicode_literals

import io

from .helper import unittest, PillowTestCase

from PIL import features

try:
    from PIL import _webp
    HAVE_WEBP = True
except ImportError:
    HAVE_WEBP = False


class TestFeatures(PillowTestCase):

    def test_check(self):
        # Check the correctness of the convenience function
        for module in features.modules:
            self.assertEqual(features.check_module(module),
                             features.check(module))
        for codec in features.codecs:
            self.assertEqual(features.check_codec(codec),
                             features.check(codec))
        for feature in features.features:
            self.assertEqual(features.check_feature(feature),
                             features.check(feature))

    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
    def test_webp_transparency(self):
        self.assertEqual(features.check('transp_webp'),
                         not _webp.WebPDecoderBuggyAlpha())
        self.assertEqual(features.check('transp_webp'),
                         _webp.HAVE_TRANSPARENCY)

    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
    def test_webp_mux(self):
        self.assertEqual(features.check('webp_mux'),
                         _webp.HAVE_WEBPMUX)

    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
    def test_webp_anim(self):
        self.assertEqual(features.check('webp_anim'),
                         _webp.HAVE_WEBPANIM)

    def test_check_modules(self):
        for feature in features.modules:
            self.assertIn(features.check_module(feature), [True, False])
        for feature in features.codecs:
            self.assertIn(features.check_codec(feature), [True, False])

    def test_supported_modules(self):
        self.assertIsInstance(features.get_supported_modules(), list)
        self.assertIsInstance(features.get_supported_codecs(), list)
        self.assertIsInstance(features.get_supported_features(), list)
        self.assertIsInstance(features.get_supported(), list)

    def test_unsupported_codec(self):
        # Arrange
        codec = "unsupported_codec"
        # Act / Assert
        self.assertRaises(ValueError, features.check_codec, codec)

    def test_unsupported_module(self):
        # Arrange
        module = "unsupported_module"
        # Act / Assert
        self.assertRaises(ValueError, features.check_module, module)

    def test_pilinfo(self):
        buf = io.StringIO()
        features.pilinfo(buf)
        out = buf.getvalue()
        lines = out.splitlines()
        self.assertEqual(lines[0], "-" * 68)
        self.assertTrue(lines[1].startswith("Pillow "))
        self.assertEqual(lines[2], "-" * 68)
        self.assertTrue(lines[3].startswith("Python modules loaded from "))
        self.assertTrue(lines[4].startswith("Binary modules loaded from "))
        self.assertEqual(lines[5], "-" * 68)
        self.assertTrue(lines[6].startswith("Python "))
        jpeg = (
            "\n" +
            "-" * 68 + "\n" +
            "JPEG image/jpeg\n" +
            "Extensions: .jfif, .jpe, .jpeg, .jpg\n" +
            "Features: open, save\n" +
            "-" * 68 + "\n"
        )
        self.assertIn(jpeg, out)