Pillow/Tests/test_file_ppm.py

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

390 lines
11 KiB
Python
Raw Normal View History

from __future__ import annotations
2024-01-20 14:23:03 +03:00
2021-08-10 12:56:52 +03:00
import sys
from io import BytesIO
from pathlib import Path
2021-08-10 12:56:52 +03:00
import pytest
2021-02-01 02:47:02 +03:00
from PIL import Image, PpmImagePlugin
from .helper import (
assert_image_equal,
assert_image_equal_tofile,
assert_image_similar,
hopper,
)
# sample ppm stream
2020-02-25 12:57:27 +03:00
TEST_FILE = "Tests/images/hopper.ppm"
def test_sanity() -> None:
2020-02-25 12:57:27 +03:00
with Image.open(TEST_FILE) as im:
assert im.mode == "RGB"
assert im.size == (128, 128)
2022-03-09 14:29:45 +03:00
assert im.format == "PPM"
2020-02-25 12:57:27 +03:00
assert im.get_format_mimetype() == "image/x-portable-pixmap"
2014-04-08 09:22:42 +04:00
2022-03-14 00:07:13 +03:00
@pytest.mark.parametrize(
"data, mode, pixels",
(
(b"P2 3 1 4 0 2 4", "L", (0, 128, 255)),
(b"P2 3 1 257 0 128 257", "I", (0, 32640, 65535)),
# P3 with maxval < 255
(
b"P3 3 1 17 0 1 2 8 9 10 15 16 17",
"RGB",
((0, 15, 30), (120, 135, 150), (225, 240, 255)),
),
# P3 with maxval > 255
# Scale down to 255, since there is no RGB mode with more than 8-bit
(
b"P3 3 1 257 0 1 2 128 129 130 256 257 257",
"RGB",
((0, 1, 2), (127, 128, 129), (254, 255, 255)),
),
2022-03-14 00:07:13 +03:00
(b"P5 3 1 4 \x00\x02\x04", "L", (0, 128, 255)),
(b"P5 3 1 257 \x00\x00\x00\x80\x01\x01", "I", (0, 32640, 65535)),
# P6 with maxval < 255
(
b"P6 3 1 17 \x00\x01\x02\x08\x09\x0A\x0F\x10\x11",
"RGB",
(
(0, 15, 30),
(120, 135, 150),
(225, 240, 255),
),
),
# P6 with maxval > 255
(
b"P6 3 1 257 \x00\x00\x00\x01\x00\x02"
b"\x00\x80\x00\x81\x00\x82\x01\x00\x01\x01\xFF\xFF",
"RGB",
(
(0, 1, 2),
(127, 128, 129),
(254, 255, 255),
),
),
),
)
2024-01-31 13:55:32 +03:00
def test_arbitrary_maxval(
data: bytes, mode: str, pixels: tuple[int | tuple[int, int, int], ...]
) -> None:
2022-03-14 00:07:13 +03:00
fp = BytesIO(data)
2022-03-09 14:29:45 +03:00
with Image.open(fp) as im:
assert im.size == (3, 1)
2022-03-14 00:07:13 +03:00
assert im.mode == mode
2022-03-09 14:29:45 +03:00
px = im.load()
2022-03-14 00:07:13 +03:00
assert tuple(px[x, 0] for x in range(3)) == pixels
2022-03-09 14:29:45 +03:00
def test_16bit_pgm() -> None:
2020-02-25 12:57:27 +03:00
with Image.open("Tests/images/16_bit_binary.pgm") as im:
assert im.mode == "I"
assert im.size == (20, 100)
assert im.get_format_mimetype() == "image/x-portable-graymap"
2014-04-08 09:22:42 +04:00
2024-03-02 07:39:43 +03:00
assert_image_equal_tofile(im, "Tests/images/16_bit_binary_pgm.tiff")
2014-04-08 09:22:42 +04:00
def test_16bit_pgm_write(tmp_path: Path) -> None:
2020-02-25 12:57:27 +03:00
with Image.open("Tests/images/16_bit_binary.pgm") as im:
2024-01-08 19:16:23 +03:00
filename = str(tmp_path / "temp.pgm")
im.save(filename, "PPM")
2024-07-13 06:00:58 +03:00
assert_image_equal_tofile(im, filename)
2019-03-04 07:11:21 +03:00
2024-07-13 06:00:58 +03:00
im.convert("I;16").save(filename, "PPM")
2024-01-08 19:16:23 +03:00
assert_image_equal_tofile(im, filename)
2019-03-04 07:11:21 +03:00
def test_pnm(tmp_path: Path) -> None:
2020-02-25 12:57:27 +03:00
with Image.open("Tests/images/hopper.pnm") as im:
assert_image_similar(im, hopper(), 0.0001)
2015-08-28 19:05:08 +03:00
2024-01-08 19:16:23 +03:00
filename = str(tmp_path / "temp.pnm")
im.save(filename)
2015-08-28 19:05:08 +03:00
2024-01-08 19:16:23 +03:00
assert_image_equal_tofile(im, filename)
2016-12-28 01:54:10 +03:00
def test_pfm(tmp_path: Path) -> None:
with Image.open("Tests/images/hopper.pfm") as im:
assert im.info["scale"] == 1.0
assert_image_equal(im, hopper("F"))
2024-01-08 19:16:23 +03:00
filename = str(tmp_path / "tmp.pfm")
im.save(filename)
2024-01-08 19:16:23 +03:00
assert_image_equal_tofile(im, filename)
def test_pfm_big_endian(tmp_path: Path) -> None:
with Image.open("Tests/images/hopper_be.pfm") as im:
assert im.info["scale"] == 2.5
assert_image_equal(im, hopper("F"))
2024-01-08 19:16:23 +03:00
filename = str(tmp_path / "tmp.pfm")
im.save(filename)
2024-01-08 19:16:23 +03:00
assert_image_equal_tofile(im, filename)
@pytest.mark.parametrize(
"data",
[
b"Pf 1 1 NaN \0\0\0\0",
b"Pf 1 1 inf \0\0\0\0",
b"Pf 1 1 -inf \0\0\0\0",
b"Pf 1 1 0.0 \0\0\0\0",
b"Pf 1 1 -0.0 \0\0\0\0",
],
)
2024-01-31 13:55:32 +03:00
def test_pfm_invalid(data: bytes) -> None:
with pytest.raises(ValueError):
with Image.open(BytesIO(data)):
pass
2022-06-14 14:39:26 +03:00
@pytest.mark.parametrize(
"plain_path, raw_path",
(
(
"Tests/images/hopper_1bit_plain.pbm", # P1
"Tests/images/hopper_1bit.pbm", # P4
),
(
"Tests/images/hopper_8bit_plain.pgm", # P2
"Tests/images/hopper_8bit.pgm", # P5
),
(
"Tests/images/hopper_8bit_plain.ppm", # P3
"Tests/images/hopper_8bit.ppm", # P6
),
),
)
2024-01-31 13:55:32 +03:00
def test_plain(plain_path: str, raw_path: str) -> None:
2022-06-14 14:39:26 +03:00
with Image.open(plain_path) as im:
assert_image_equal_tofile(im, raw_path)
2021-02-01 02:47:02 +03:00
def test_16bit_plain_pgm() -> None:
2022-03-12 09:32:15 +03:00
# P2 with maxval 2 ** 16 - 1
with Image.open("Tests/images/hopper_16bit_plain.pgm") as im:
assert im.mode == "I"
assert im.size == (128, 128)
assert im.get_format_mimetype() == "image/x-portable-graymap"
2021-02-01 02:47:02 +03:00
2022-03-12 09:32:15 +03:00
# P5 with maxval 2 ** 16 - 1
assert_image_equal_tofile(im, "Tests/images/hopper_16bit.pgm")
2021-02-01 02:47:02 +03:00
2022-06-14 14:39:26 +03:00
@pytest.mark.parametrize(
"header, data, comment_count",
(
(b"P1\n2 2", b"1010", 10**6),
(b"P2\n3 1\n4", b"0 2 4", 1),
(b"P3\n2 2\n255", b"0 0 0 001 1 1 2 2 2 255 255 255", 10**6),
),
2022-06-14 14:39:26 +03:00
)
2024-01-31 13:55:32 +03:00
def test_plain_data_with_comment(
tmp_path: Path, header: bytes, data: bytes, comment_count: int
) -> None:
2021-02-01 02:47:02 +03:00
path1 = str(tmp_path / "temp1.ppm")
path2 = str(tmp_path / "temp2.ppm")
comment = b"# comment" * comment_count
2021-02-01 02:47:02 +03:00
with open(path1, "wb") as f1, open(path2, "wb") as f2:
2022-06-14 14:39:26 +03:00
f1.write(header + b"\n\n" + data)
f2.write(header + b"\n" + comment + b"\n" + data + comment)
2021-02-01 02:47:02 +03:00
with Image.open(path1) as im:
assert_image_equal_tofile(im, path2)
2021-02-01 02:47:02 +03:00
2022-06-14 14:39:26 +03:00
@pytest.mark.parametrize("data", (b"P1\n128 128\n", b"P3\n128 128\n255\n"))
2024-01-31 13:55:32 +03:00
def test_plain_truncated_data(tmp_path: Path, data: bytes) -> None:
2021-02-01 02:47:02 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
2022-06-14 14:39:26 +03:00
f.write(data)
2021-02-01 02:47:02 +03:00
2022-03-04 09:08:10 +03:00
with Image.open(path) as im:
with pytest.raises(ValueError):
im.load()
2021-02-01 02:47:02 +03:00
2022-06-14 14:39:26 +03:00
@pytest.mark.parametrize("data", (b"P1\n128 128\n1009", b"P3\n128 128\n255\n100A"))
2024-01-31 13:55:32 +03:00
def test_plain_invalid_data(tmp_path: Path, data: bytes) -> None:
2021-02-01 02:47:02 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
2022-06-14 14:39:26 +03:00
f.write(data)
2021-02-01 02:47:02 +03:00
2022-03-04 09:08:10 +03:00
with Image.open(path) as im:
with pytest.raises(ValueError):
im.load()
2021-02-01 02:47:02 +03:00
2022-06-14 14:39:26 +03:00
@pytest.mark.parametrize(
"data",
(
b"P3\n128 128\n255\n012345678910", # half token too long
b"P3\n128 128\n255\n012345678910 0", # token too long
),
)
2024-01-31 13:55:32 +03:00
def test_plain_ppm_token_too_long(tmp_path: Path, data: bytes) -> None:
2021-02-01 02:47:02 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
2022-06-14 14:39:26 +03:00
f.write(data)
2021-02-01 02:47:02 +03:00
2022-03-04 09:08:10 +03:00
with Image.open(path) as im:
with pytest.raises(ValueError):
im.load()
2021-02-01 02:47:02 +03:00
def test_plain_ppm_value_negative(tmp_path: Path) -> None:
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
f.write(b"P3\n128 128\n255\n-1")
with Image.open(path) as im:
with pytest.raises(ValueError, match="Channel value is negative"):
im.load()
def test_plain_ppm_value_too_large(tmp_path: Path) -> None:
2021-02-01 02:47:02 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
f.write(b"P3\n128 128\n255\n256")
2022-03-04 09:08:10 +03:00
with Image.open(path) as im:
with pytest.raises(ValueError, match="Channel value too large"):
2022-03-04 09:08:10 +03:00
im.load()
2021-02-01 02:47:02 +03:00
def test_magic() -> None:
2021-02-01 02:47:02 +03:00
with pytest.raises(SyntaxError):
PpmImagePlugin.PpmImageFile(fp=BytesIO(b"PyInvalid"))
2019-03-04 10:17:12 +03:00
def test_header_with_comments(tmp_path: Path) -> None:
2020-12-21 07:15:49 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
2022-03-12 09:32:15 +03:00
f.write(b"P6 #comment\n#comment\r12#comment\r8\n128 #comment\n255\n")
2020-12-21 07:15:49 +03:00
with Image.open(path) as im:
assert im.size == (128, 128)
def test_non_integer_token(tmp_path: Path) -> None:
2021-03-21 08:16:39 +03:00
path = str(tmp_path / "temp.ppm")
2020-12-21 07:15:49 +03:00
with open(path, "wb") as f:
2022-03-04 07:22:41 +03:00
f.write(b"P6\nTEST")
2020-12-21 07:15:49 +03:00
2021-01-06 07:15:07 +03:00
with pytest.raises(ValueError):
2021-03-21 06:42:36 +03:00
with Image.open(path):
pass
2020-12-21 07:15:49 +03:00
def test_header_token_too_long(tmp_path: Path) -> None:
2021-03-21 08:16:39 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
2022-03-04 07:22:41 +03:00
f.write(b"P6\n 01234567890")
2022-03-04 07:22:41 +03:00
with pytest.raises(ValueError) as e:
2021-03-21 06:42:36 +03:00
with Image.open(path):
pass
2020-12-21 07:15:49 +03:00
assert str(e.value) == "Token too long in file header: 01234567890"
2022-03-04 07:22:41 +03:00
def test_truncated_file(tmp_path: Path) -> None:
2022-03-09 14:29:45 +03:00
# Test EOF in header
2020-02-25 12:57:27 +03:00
path = str(tmp_path / "temp.pgm")
2022-10-23 07:17:54 +03:00
with open(path, "wb") as f:
f.write(b"P6")
2022-03-04 07:22:41 +03:00
with pytest.raises(ValueError) as e:
2021-03-21 06:42:36 +03:00
with Image.open(path):
pass
2022-03-04 07:22:41 +03:00
assert str(e.value) == "Reached EOF while reading header"
2022-03-09 14:29:45 +03:00
# Test EOF for PyDecoder
fp = BytesIO(b"P5 3 1 4")
with Image.open(fp) as im:
with pytest.raises(ValueError):
im.load()
2022-03-04 07:22:41 +03:00
def test_not_enough_image_data(tmp_path: Path) -> None:
2023-04-01 01:23:57 +03:00
path = str(tmp_path / "temp.ppm")
with open(path, "wb") as f:
f.write(b"P2 1 2 255 255")
with Image.open(path) as im:
with pytest.raises(ValueError):
im.load()
2022-10-23 07:17:54 +03:00
@pytest.mark.parametrize("maxval", (b"0", b"65536"))
2024-01-31 13:55:32 +03:00
def test_invalid_maxval(maxval: bytes, tmp_path: Path) -> None:
2022-04-30 03:37:50 +03:00
path = str(tmp_path / "temp.ppm")
2022-10-23 07:17:54 +03:00
with open(path, "wb") as f:
f.write(b"P6\n3 1 " + maxval)
2019-03-04 10:17:12 +03:00
2022-03-04 07:22:41 +03:00
with pytest.raises(ValueError) as e:
2021-02-11 13:43:54 +03:00
with Image.open(path):
pass
2019-03-04 10:17:12 +03:00
2022-04-30 03:37:50 +03:00
assert str(e.value) == "maxval must be greater than 0 and less than 65536"
2022-03-04 07:22:41 +03:00
2020-02-25 12:57:27 +03:00
def test_neg_ppm() -> None:
2020-02-25 12:57:27 +03:00
# Storage.c accepted negative values for xsize, ysize. the
# internal open_ppm function didn't check for sanity but it
# has been removed. The default opener doesn't accept negative
# sizes.
2021-01-06 07:15:07 +03:00
with pytest.raises(OSError):
2021-02-11 13:43:54 +03:00
with Image.open("Tests/images/negative_size.ppm"):
pass
2020-02-25 12:57:27 +03:00
def test_mimetypes(tmp_path: Path) -> None:
2020-02-25 12:57:27 +03:00
path = str(tmp_path / "temp.pgm")
2022-10-23 07:17:54 +03:00
with open(path, "wb") as f:
f.write(b"P4\n128 128\n255")
2020-02-25 12:57:27 +03:00
with Image.open(path) as im:
assert im.get_format_mimetype() == "image/x-portable-bitmap"
2022-10-23 07:17:54 +03:00
with open(path, "wb") as f:
f.write(b"PyCMYK\n128 128\n255")
2020-02-25 12:57:27 +03:00
with Image.open(path) as im:
assert im.get_format_mimetype() == "image/x-portable-anymap"
2021-08-10 12:56:52 +03:00
@pytest.mark.parametrize("buffer", (True, False))
2024-01-31 13:55:32 +03:00
def test_save_stdout(buffer: bool) -> None:
2021-08-10 12:56:52 +03:00
old_stdout = sys.stdout
2024-06-22 03:09:11 +03:00
class MyStdOut:
buffer = BytesIO()
2021-08-10 12:56:52 +03:00
2024-06-22 03:09:11 +03:00
mystdout: MyStdOut | BytesIO = MyStdOut() if buffer else BytesIO()
2021-08-10 12:56:52 +03:00
2024-07-20 11:59:27 +03:00
sys.stdout = mystdout
2021-08-10 12:56:52 +03:00
with Image.open(TEST_FILE) as im:
im.save(sys.stdout, "PPM")
# Reset stdout
sys.stdout = old_stdout
2024-06-22 03:09:11 +03:00
if isinstance(mystdout, MyStdOut):
2021-08-10 12:56:52 +03:00
mystdout = mystdout.buffer
2021-08-24 16:43:38 +03:00
with Image.open(mystdout) as reloaded:
assert_image_equal_tofile(reloaded, TEST_FILE)