#2722

pending completion

Build # #2722

Build Type

push

github-actions

Committed by

hugovk

Commit Message

Test on new Travis CPUs https://blog.travis-ci.com/2019-11-12-multi-cpu-architecture-ibm-power-ibm-z

Run Details

18 of 18 new or added lines in 5 files covered. (100.0%)

35044 of 40293 relevant lines covered (86.97%)

199285.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.16

/Tests/helper.py

"""
Helper functions.
"""

import logging
import os
import platform
import subprocess
import sys
import tempfile
import unittest
from io import BytesIO

from PIL import Image, ImageMath

logger = logging.getLogger(__name__)


HAS_UPLOADER = False

if os.environ.get("SHOW_ERRORS", None):
    # local img.show for errors.
    HAS_UPLOADER = True

    class test_image_results:
        @staticmethod
        def upload(a, b):
            a.show()
            b.show()


elif "GITHUB_ACTIONS" in os.environ:
    HAS_UPLOADER = True

    class test_image_results:
        @staticmethod
        def upload(a, b):
            dir_errors = os.path.join(os.path.dirname(__file__), "errors")
            os.makedirs(dir_errors, exist_ok=True)
            tmpdir = tempfile.mkdtemp(dir=dir_errors)
            a.save(os.path.join(tmpdir, "a.png"))
            b.save(os.path.join(tmpdir, "b.png"))
            return tmpdir


else:
    try:
        import test_image_results

        HAS_UPLOADER = True
    except ImportError:
        pass


def convert_to_comparable(a, b):
    new_a, new_b = a, b
    if a.mode == "P":
        new_a = Image.new("L", a.size)
        new_b = Image.new("L", b.size)
        new_a.putdata(a.getdata())
        new_b.putdata(b.getdata())
    elif a.mode == "I;16":
        new_a = a.convert("I")
        new_b = b.convert("I")
    return new_a, new_b


class PillowTestCase(unittest.TestCase):
    def delete_tempfile(self, path):
        try:
            os.remove(path)
        except OSError:
            pass  # report?

    def assert_deep_equal(self, a, b, msg=None):
        try:
            self.assertEqual(
                len(a),
                len(b),
                msg or "got length {}, expected {}".format(len(a), len(b)),
            )
            self.assertTrue(
                all(x == y for x, y in zip(a, b)),
                msg or "got {}, expected {}".format(a, b),
            )
        except Exception:
            self.assertEqual(a, b, msg)

    def assert_image(self, im, mode, size, msg=None):
        if mode is not None:
            self.assertEqual(
                im.mode,
                mode,
                msg or "got mode {!r}, expected {!r}".format(im.mode, mode),
            )

        if size is not None:
            self.assertEqual(
                im.size,
                size,
                msg or "got size {!r}, expected {!r}".format(im.size, size),
            )

    def assert_image_equal(self, a, b, msg=None):
        self.assertEqual(
            a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
        )
        self.assertEqual(
            a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
        )
        if a.tobytes() != b.tobytes():
            if HAS_UPLOADER:
                try:
                    url = test_image_results.upload(a, b)
                    logger.error("Url for test images: %s" % url)
                except Exception:
                    pass

            self.fail(msg or "got different content")

    def assert_image_equal_tofile(self, a, filename, msg=None, mode=None):
        with Image.open(filename) as img:
            if mode:
                img = img.convert(mode)
            self.assert_image_equal(a, img, msg)

    def assert_image_similar(self, a, b, epsilon, msg=None):
        epsilon = float(epsilon)
        self.assertEqual(
            a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
        )
        self.assertEqual(
            a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
        )

        a, b = convert_to_comparable(a, b)

        diff = 0
        for ach, bch in zip(a.split(), b.split()):
            chdiff = ImageMath.eval("abs(a - b)", a=ach, b=bch).convert("L")
            diff += sum(i * num for i, num in enumerate(chdiff.histogram()))

        ave_diff = float(diff) / (a.size[0] * a.size[1])
        try:
            self.assertGreaterEqual(
                epsilon,
                ave_diff,
                (msg or "")
                + " average pixel value difference %.4f > epsilon %.4f"
                % (ave_diff, epsilon),
            )
        except Exception as e:
            if HAS_UPLOADER:
                try:
                    url = test_image_results.upload(a, b)
                    logger.error("Url for test images: %s" % url)
                except Exception:
                    pass
            raise e

    def assert_image_similar_tofile(self, a, filename, epsilon, msg=None, mode=None):
        with Image.open(filename) as img:
            if mode:
                img = img.convert(mode)
            self.assert_image_similar(a, img, epsilon, msg)

    def assert_warning(self, warn_class, func, *args, **kwargs):
        import warnings

        with warnings.catch_warnings(record=True) as w:
            # Cause all warnings to always be triggered.
            warnings.simplefilter("always")

            # Hopefully trigger a warning.
            result = func(*args, **kwargs)

            # Verify some things.
            if warn_class is None:
                self.assertEqual(
                    len(w), 0, "Expected no warnings, got %s" % [v.category for v in w]
                )
            else:
                self.assertGreaterEqual(len(w), 1)
                found = False
                for v in w:
                    if issubclass(v.category, warn_class):
                        found = True
                        break
                self.assertTrue(found)
        return result

    def assert_all_same(self, items, msg=None):
        self.assertEqual(items.count(items[0]), len(items), msg)

    def assert_not_all_same(self, items, msg=None):
        self.assertNotEqual(items.count(items[0]), len(items), msg)

    def assert_tuple_approx_equal(self, actuals, targets, threshold, msg):
        """Tests if actuals has values within threshold from targets"""

        value = True
        for i, target in enumerate(targets):
            value *= target - threshold <= actuals[i] <= target + threshold

        self.assertTrue(value, msg + ": " + repr(actuals) + " != " + repr(targets))

    def skipKnownBadTest(self, msg=None):
        # Skip if PILLOW_RUN_KNOWN_BAD is not true in the environment.
        if os.environ.get("PILLOW_RUN_KNOWN_BAD", False):
            print(os.environ.get("PILLOW_RUN_KNOWN_BAD", False))
            return

        self.skipTest(msg or "Known Bad Test")

    def tempfile(self, template):
        assert template[:5] in ("temp.", "temp_")
        fd, path = tempfile.mkstemp(template[4:], template[:4])
        os.close(fd)

        self.addCleanup(self.delete_tempfile, path)
        return path

    def open_withImagemagick(self, f):
        if not imagemagick_available():
            raise OSError()

        outfile = self.tempfile("temp.png")
        if command_succeeds([IMCONVERT, f, outfile]):
            return Image.open(outfile)
        raise OSError()


@unittest.skipIf(sys.platform.startswith("win32"), "requires Unix or macOS")
class PillowLeakTestCase(PillowTestCase):
    # requires unix/macOS
    iterations = 100  # count
    mem_limit = 512  # k

    def _get_mem_usage(self):
        """
        Gets the RUSAGE memory usage, returns in K. Encapsulates the difference
        between macOS and Linux rss reporting

        :returns: memory usage in kilobytes
        """

        from resource import getrusage, RUSAGE_SELF

        mem = getrusage(RUSAGE_SELF).ru_maxrss
        if sys.platform == "darwin":
            # man 2 getrusage:
            #     ru_maxrss
            # This is the maximum resident set size utilized (in bytes).
            return mem / 1024  # Kb
        else:
            # linux
            # man 2 getrusage
            #        ru_maxrss (since Linux 2.6.32)
            #  This is the maximum resident set size used (in kilobytes).
            return mem  # Kb

    def _test_leak(self, core):
        start_mem = self._get_mem_usage()
        for cycle in range(self.iterations):
            core()
            mem = self._get_mem_usage() - start_mem
            msg = "memory usage limit exceeded in iteration %d" % cycle
            self.assertLess(mem, self.mem_limit, msg)


# helpers


def fromstring(data):
    return Image.open(BytesIO(data))


def tostring(im, string_format, **options):
    out = BytesIO()
    im.save(out, string_format, **options)
    return out.getvalue()


def hopper(mode=None, cache={}):
    if mode is None:
        # Always return fresh not-yet-loaded version of image.
        # Operations on not-yet-loaded images is separate class of errors
        # what we should catch.
        return Image.open("Tests/images/hopper.ppm")
    # Use caching to reduce reading from disk but so an original copy is
    # returned each time and the cached image isn't modified by tests
    # (for fast, isolated, repeatable tests).
    im = cache.get(mode)
    if im is None:
        if mode == "F":
            im = hopper("L").convert(mode)
        elif mode[:4] == "I;16":
            im = hopper("I").convert(mode)
        else:
            im = hopper().convert(mode)
        cache[mode] = im
    return im.copy()


def command_succeeds(cmd):
    """
    Runs the command, which must be a list of strings. Returns True if the
    command succeeds, or False if an OSError was raised by subprocess.Popen.
    """
    try:
        subprocess.call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
    except OSError:
        return False
    return True


def djpeg_available():
    return command_succeeds(["djpeg", "-version"])


def cjpeg_available():
    return command_succeeds(["cjpeg", "-version"])


def netpbm_available():
    return command_succeeds(["ppmquant", "--version"]) and command_succeeds(
        ["ppmtogif", "--version"]
    )


def imagemagick_available():
    return IMCONVERT and command_succeeds([IMCONVERT, "-version"])


def on_appveyor():
    return "APPVEYOR" in os.environ


def on_github_actions():
    return "GITHUB_ACTIONS" in os.environ


def on_ci():
    # Travis and AppVeyor have "CI"
    # Azure Pipelines has "TF_BUILD"
    # GitHub Actions has "GITHUB_ACTIONS"
    return (
        "CI" in os.environ or "TF_BUILD" in os.environ or "GITHUB_ACTIONS" in os.environ
    )


def is_big_endian():
    return platform.processor() == "s390x"


def is_win32():
    return sys.platform.startswith("win32")


def is_pypy():
    return hasattr(sys, "pypy_translation_info")


if sys.platform == "win32":
    IMCONVERT = os.environ.get("MAGICK_HOME", "")
    if IMCONVERT:
        IMCONVERT = os.path.join(IMCONVERT, "convert.exe")
else:
    IMCONVERT = "convert"


def distro():
    if os.path.exists("/etc/os-release"):
        with open("/etc/os-release", "r") as f:
            for line in f:
                if "ID=" in line:
                    return line.strip().split("=")[1]


class cached_property:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, cls=None):
        result = instance.__dict__[self.func.__name__] = self.func(instance)
        return result

1	"""
2	Helper functions.
3	"""
4
5	import logging	1✔
6	import os	1✔
7	import platform	1✔
8	import subprocess	1✔
9	import sys	1✔
10	import tempfile	1✔
11	import unittest	1✔
12	from io import BytesIO	1✔
13
14	from PIL import Image, ImageMath	1✔
15
16	logger = logging.getLogger(__name__)	1✔
17
18
19	HAS_UPLOADER = False	1✔
20
21	if os.environ.get("SHOW_ERRORS", None):	1✔
22	# local img.show for errors.
23	HAS_UPLOADER = True	×
24
25	class test_image_results:	×
26	@staticmethod	×
27	def upload(a, b):
28	a.show()	×
29	b.show()	×
30
31
32	elif "GITHUB_ACTIONS" in os.environ:	1✔
33	HAS_UPLOADER = True	1✔
34
35	class test_image_results:	1✔
36	@staticmethod	1✔
37	def upload(a, b):
38	dir_errors = os.path.join(os.path.dirname(__file__), "errors")	1✔
39	os.makedirs(dir_errors, exist_ok=True)	1✔
40	tmpdir = tempfile.mkdtemp(dir=dir_errors)	1✔
41	a.save(os.path.join(tmpdir, "a.png"))	1✔
42	b.save(os.path.join(tmpdir, "b.png"))	1✔
43	return tmpdir	1✔
44
45
46	else:
47	try:	×
48	import test_image_results	×
49
50	HAS_UPLOADER = True	×
51	except ImportError:	×
52	pass	×
53
54
55	def convert_to_comparable(a, b):	1✔
56	new_a, new_b = a, b	1✔
57	if a.mode == "P":	1✔
58	new_a = Image.new("L", a.size)	1✔
59	new_b = Image.new("L", b.size)	1✔
60	new_a.putdata(a.getdata())	1✔
61	new_b.putdata(b.getdata())	1✔
62	elif a.mode == "I;16":	1✔
63	new_a = a.convert("I")	1✔
64	new_b = b.convert("I")	1✔
65	return new_a, new_b	1✔
66
67
68	class PillowTestCase(unittest.TestCase):	1✔
69	def delete_tempfile(self, path):	1✔
70	try:	1✔
71	os.remove(path)	1✔
72	except OSError:	1✔
73	pass # report?	1✔
74
75	def assert_deep_equal(self, a, b, msg=None):	1✔
76	try:	1✔
77	self.assertEqual(	1✔
78	len(a),
79	len(b),
80	msg or "got length {}, expected {}".format(len(a), len(b)),
81	)
82	self.assertTrue(	1✔
83	all(x == y for x, y in zip(a, b)),
84	msg or "got {}, expected {}".format(a, b),
85	)
86	except Exception:	1✔
87	self.assertEqual(a, b, msg)	1✔
88
89	def assert_image(self, im, mode, size, msg=None):	1✔
90	if mode is not None:	1✔
91	self.assertEqual(	1✔
92	im.mode,
93	mode,
94	msg or "got mode {!r}, expected {!r}".format(im.mode, mode),
95	)
96
97	if size is not None:	1✔
98	self.assertEqual(	1✔
99	im.size,
100	size,
101	msg or "got size {!r}, expected {!r}".format(im.size, size),
102	)
103
104	def assert_image_equal(self, a, b, msg=None):	1✔
105	self.assertEqual(	1✔
106	a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
107	)
108	self.assertEqual(	1✔
109	a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
110	)
111	if a.tobytes() != b.tobytes():	1✔
112	if HAS_UPLOADER:	1✔
113	try:	1✔
114	url = test_image_results.upload(a, b)	1✔
115	logger.error("Url for test images: %s" % url)	1✔
116	except Exception:	×
117	pass	×
118
119	self.fail(msg or "got different content")	1✔
120
121	def assert_image_equal_tofile(self, a, filename, msg=None, mode=None):	1✔
122	with Image.open(filename) as img:	1✔
123	if mode:	1✔
124	img = img.convert(mode)	1✔
125	self.assert_image_equal(a, img, msg)	1✔
126
127	def assert_image_similar(self, a, b, epsilon, msg=None):	1✔
128	epsilon = float(epsilon)	1✔
129	self.assertEqual(	1✔
130	a.mode, b.mode, msg or "got mode {!r}, expected {!r}".format(a.mode, b.mode)
131	)
132	self.assertEqual(	1✔
133	a.size, b.size, msg or "got size {!r}, expected {!r}".format(a.size, b.size)
134	)
135
136	a, b = convert_to_comparable(a, b)	1✔
137
138	diff = 0	1✔
139	for ach, bch in zip(a.split(), b.split()):	1✔
140	chdiff = ImageMath.eval("abs(a - b)", a=ach, b=bch).convert("L")	1✔
141	diff += sum(i * num for i, num in enumerate(chdiff.histogram()))	1✔
142
143	ave_diff = float(diff) / (a.size[0] * a.size[1])	1✔
144	try:	1✔
145	self.assertGreaterEqual(	1✔
146	epsilon,
147	ave_diff,
148	(msg or "")
149	+ " average pixel value difference %.4f > epsilon %.4f"
150	% (ave_diff, epsilon),
151	)
152	except Exception as e:	1✔
153	if HAS_UPLOADER:	1✔
154	try:	1✔
155	url = test_image_results.upload(a, b)	1✔
156	logger.error("Url for test images: %s" % url)	1✔
157	except Exception:	×
158	pass	×
159	raise e	1✔
160
161	def assert_image_similar_tofile(self, a, filename, epsilon, msg=None, mode=None):	1✔
162	with Image.open(filename) as img:	1✔
163	if mode:	1✔
164	img = img.convert(mode)	×
165	self.assert_image_similar(a, img, epsilon, msg)	1✔
166
167	def assert_warning(self, warn_class, func, args, *kwargs):	1✔
168	import warnings	1✔
169
170	with warnings.catch_warnings(record=True) as w:	1✔
171	# Cause all warnings to always be triggered.
172	warnings.simplefilter("always")	1✔
173
174	# Hopefully trigger a warning.
175	result = func(args, *kwargs)	1✔
176
177	# Verify some things.
178	if warn_class is None:	1✔
179	self.assertEqual(	1✔
180	len(w), 0, "Expected no warnings, got %s" % [v.category for v in w]
181	)
182	else:
183	self.assertGreaterEqual(len(w), 1)	1✔
184	found = False	1✔
185	for v in w:	1✔
186	if issubclass(v.category, warn_class):	1✔
187	found = True	1✔
188	break	1✔
189	self.assertTrue(found)	1✔
190	return result	1✔
191
192	def assert_all_same(self, items, msg=None):	1✔
193	self.assertEqual(items.count(items[0]), len(items), msg)	×
194
195	def assert_not_all_same(self, items, msg=None):	1✔
196	self.assertNotEqual(items.count(items[0]), len(items), msg)	1✔
197
198	def assert_tuple_approx_equal(self, actuals, targets, threshold, msg):	1✔
199	"""Tests if actuals has values within threshold from targets"""
200
201	value = True	1✔
202	for i, target in enumerate(targets):	1✔
203	value *= target - threshold <= actuals[i] <= target + threshold	1✔
204
205	self.assertTrue(value, msg + ": " + repr(actuals) + " != " + repr(targets))	1✔
206
207	def skipKnownBadTest(self, msg=None):	1✔
208	# Skip if PILLOW_RUN_KNOWN_BAD is not true in the environment.
209	if os.environ.get("PILLOW_RUN_KNOWN_BAD", False):	1✔
210	print(os.environ.get("PILLOW_RUN_KNOWN_BAD", False))	×
211	return	×
212
213	self.skipTest(msg or "Known Bad Test")	1✔
214
215	def tempfile(self, template):	1✔
216	assert template[:5] in ("temp.", "temp_")	1✔
217	fd, path = tempfile.mkstemp(template[4:], template[:4])	1✔
218	os.close(fd)	1✔
219
220	self.addCleanup(self.delete_tempfile, path)	1✔
221	return path	1✔
222
223	def open_withImagemagick(self, f):	1✔
224	if not imagemagick_available():	×
225	raise OSError()	×
226
227	outfile = self.tempfile("temp.png")	×
228	if command_succeeds([IMCONVERT, f, outfile]):	×
229	return Image.open(outfile)	×
230	raise OSError()	×
231
232
233	@unittest.skipIf(sys.platform.startswith("win32"), "requires Unix or macOS")	1✔
234	class PillowLeakTestCase(PillowTestCase):	1✔
235	# requires unix/macOS
236	iterations = 100 # count	1✔
237	mem_limit = 512 # k	1✔
238
239	def _get_mem_usage(self):	1✔
240	"""
241	Gets the RUSAGE memory usage, returns in K. Encapsulates the difference
242	between macOS and Linux rss reporting
243
244	:returns: memory usage in kilobytes
245	"""
246
247	from resource import getrusage, RUSAGE_SELF	1✔
248
249	mem = getrusage(RUSAGE_SELF).ru_maxrss	1✔
250	if sys.platform == "darwin":	1✔
251	# man 2 getrusage:
252	# ru_maxrss
253	# This is the maximum resident set size utilized (in bytes).
254	return mem / 1024 # Kb	1✔
255	else:
256	# linux
257	# man 2 getrusage
258	# ru_maxrss (since Linux 2.6.32)
259	# This is the maximum resident set size used (in kilobytes).
260	return mem # Kb	×
261
262	def _test_leak(self, core):	1✔
263	start_mem = self._get_mem_usage()	1✔
264	for cycle in range(self.iterations):	1✔
265	core()	1✔
266	mem = self._get_mem_usage() - start_mem	1✔
267	msg = "memory usage limit exceeded in iteration %d" % cycle	1✔
268	self.assertLess(mem, self.mem_limit, msg)	1✔
269
270
271	# helpers
272
273
274	def fromstring(data):	1✔
275	return Image.open(BytesIO(data))	1✔
276
277
278	def tostring(im, string_format, **options):	1✔
279	out = BytesIO()	1✔
280	im.save(out, string_format, **options)	1✔
281	return out.getvalue()	1✔
282
283
284	def hopper(mode=None, cache={}):	1✔
285	if mode is None:	1✔
286	# Always return fresh not-yet-loaded version of image.
287	# Operations on not-yet-loaded images is separate class of errors
288	# what we should catch.
289	return Image.open("Tests/images/hopper.ppm")	1✔
290	# Use caching to reduce reading from disk but so an original copy is
291	# returned each time and the cached image isn't modified by tests
292	# (for fast, isolated, repeatable tests).
293	im = cache.get(mode)	1✔
294	if im is None:	1✔
295	if mode == "F":	1✔
296	im = hopper("L").convert(mode)	1✔
297	elif mode[:4] == "I;16":	1✔
298	im = hopper("I").convert(mode)	1✔
299	else:
300	im = hopper().convert(mode)	1✔
301	cache[mode] = im	1✔
302	return im.copy()	1✔
303
304
305	def command_succeeds(cmd):	1✔
306	"""
307	Runs the command, which must be a list of strings. Returns True if the
308	command succeeds, or False if an OSError was raised by subprocess.Popen.
309	"""
310	try:	1✔
311	subprocess.call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)	1✔
312	except OSError:	1✔
313	return False	1✔
314	return True	1✔
315
316
317	def djpeg_available():	1✔
318	return command_succeeds(["djpeg", "-version"])	1✔
319
320
321	def cjpeg_available():	1✔
322	return command_succeeds(["cjpeg", "-version"])	1✔
323
324
325	def netpbm_available():	1✔
326	return command_succeeds(["ppmquant", "--version"]) and command_succeeds(	1✔
327	["ppmtogif", "--version"]
328	)
329
330
331	def imagemagick_available():	1✔
332	return IMCONVERT and command_succeeds([IMCONVERT, "-version"])	1✔
333
334
335	def on_appveyor():	1✔
336	return "APPVEYOR" in os.environ	×
337
338
339	def on_github_actions():	1✔
340	return "GITHUB_ACTIONS" in os.environ	×
341
342
343	def on_ci():	1✔
344	# Travis and AppVeyor have "CI"
345	# Azure Pipelines has "TF_BUILD"
346	# GitHub Actions has "GITHUB_ACTIONS"
347	return (	1✔
348	"CI" in os.environ or "TF_BUILD" in os.environ or "GITHUB_ACTIONS" in os.environ
349	)
350
351
352	def is_big_endian():	1✔
353	return platform.processor() == "s390x"	1✔
354
355
356	def is_win32():	1✔
357	return sys.platform.startswith("win32")	1✔
358
359
360	def is_pypy():	1✔
361	return hasattr(sys, "pypy_translation_info")	1✔
362
363
364	if sys.platform == "win32":	1✔
365	IMCONVERT = os.environ.get("MAGICK_HOME", "")	×
366	if IMCONVERT:	×
367	IMCONVERT = os.path.join(IMCONVERT, "convert.exe")	×
368	else:
369	IMCONVERT = "convert"	1✔
370
371
372	def distro():	1✔
373	if os.path.exists("/etc/os-release"):	×
374	with open("/etc/os-release", "r") as f:	×
375	for line in f:	×
376	if "ID=" in line:	×
377	return line.strip().split("=")[1]	×
378
379
380	class cached_property:	1✔
381	def __init__(self, func):	1✔
382	self.func = func	1✔
383
384	def __get__(self, instance, cls=None):	1✔
385	result = instance.__dict__[self.func.__name__] = self.func(instance)	1✔
386	return result	1✔

hugovk / Pillow / #2722

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous