Pillow

1
from __future__ import annotations
2

3
import sys
4

5
import pytest
6

7
from PIL import Image
8

9
X = 255
10

11

12
class TestLibPack:
13
    def assert_pack(
14
        self,
15
        mode: str,
16
        rawmode: str,
17
        data: int | bytes,
18
        *pixels: float | tuple[int, ...],
19
    ) -> None:
20
        """
21
        data - either raw bytes with data or just number of bytes in rawmode.
22
        """
23
        im = Image.new(mode, (len(pixels), 1))
24
        for x, pixel in enumerate(pixels):
25
            im.putpixel((x, 0), pixel)
26

27
        if isinstance(data, int):
28
            data_len = data * len(pixels)
29
            data = bytes(range(1, data_len + 1))
30

31
        assert data == im.tobytes("raw", rawmode)
32

33
    def test_1(self) -> None:
34
        self.assert_pack("1", "1", b"\x01", 0, 0, 0, 0, 0, 0, 0, X)
35
        self.assert_pack("1", "1;I", b"\x01", X, X, X, X, X, X, X, 0)
36
        self.assert_pack("1", "1;R", b"\x01", X, 0, 0, 0, 0, 0, 0, 0)
37
        self.assert_pack("1", "1;IR", b"\x01", 0, X, X, X, X, X, X, X)
38

39
        self.assert_pack("1", "1", b"\xaa", X, 0, X, 0, X, 0, X, 0)
40
        self.assert_pack("1", "1;I", b"\xaa", 0, X, 0, X, 0, X, 0, X)
41
        self.assert_pack("1", "1;R", b"\xaa", 0, X, 0, X, 0, X, 0, X)
42
        self.assert_pack("1", "1;IR", b"\xaa", X, 0, X, 0, X, 0, X, 0)
43

44
        self.assert_pack("1", "L", b"\xff\x00\x00\xff\x00\x00", X, 0, 0, X, 0, 0)
45

46
    def test_L(self) -> None:
47
        self.assert_pack("L", "L", 1, 1, 2, 3, 4)
48
        self.assert_pack("L", "L;16", b"\x00\xc6\x00\xaf", 198, 175)
49
        self.assert_pack("L", "L;16B", b"\xc6\x00\xaf\x00", 198, 175)
50

51
    def test_LA(self) -> None:
52
        self.assert_pack("LA", "LA", 2, (1, 2), (3, 4), (5, 6))
53
        self.assert_pack("LA", "LA;L", 2, (1, 4), (2, 5), (3, 6))
54

55
    def test_La(self) -> None:
56
        self.assert_pack("La", "La", 2, (1, 2), (3, 4), (5, 6))
57

58
    def test_P(self) -> None:
59
        self.assert_pack("P", "P;1", b"\xe4", 1, 1, 1, 0, 0, 255, 0, 0)
60
        self.assert_pack("P", "P;2", b"\xe4", 3, 2, 1, 0)
61
        self.assert_pack("P", "P;4", b"\x02\xef", 0, 2, 14, 15)
62
        self.assert_pack("P", "P", 1, 1, 2, 3, 4)
63

64
    def test_PA(self) -> None:
65
        self.assert_pack("PA", "PA", 2, (1, 2), (3, 4), (5, 6))
66
        self.assert_pack("PA", "PA;L", 2, (1, 4), (2, 5), (3, 6))
67

68
    def test_RGB(self) -> None:
69
        self.assert_pack("RGB", "RGB", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
70
        self.assert_pack(
71
            "RGB", "RGBX", b"\x01\x02\x03\xff\x05\x06\x07\xff", (1, 2, 3), (5, 6, 7)
72
        )
73
        self.assert_pack(
74
            "RGB", "XRGB", b"\x00\x02\x03\x04\x00\x06\x07\x08", (2, 3, 4), (6, 7, 8)
75
        )
76
        self.assert_pack("RGB", "BGR", 3, (3, 2, 1), (6, 5, 4), (9, 8, 7))
77
        self.assert_pack(
78
            "RGB", "BGRX", b"\x01\x02\x03\x00\x05\x06\x07\x00", (3, 2, 1), (7, 6, 5)
79
        )
80
        self.assert_pack(
81
            "RGB", "XBGR", b"\x00\x02\x03\x04\x00\x06\x07\x08", (4, 3, 2), (8, 7, 6)
82
        )
83
        self.assert_pack("RGB", "RGB;L", 3, (1, 4, 7), (2, 5, 8), (3, 6, 9))
84
        self.assert_pack("RGB", "R", 1, (1, 9, 9), (2, 9, 9), (3, 9, 9))
85
        self.assert_pack("RGB", "G", 1, (9, 1, 9), (9, 2, 9), (9, 3, 9))
86
        self.assert_pack("RGB", "B", 1, (9, 9, 1), (9, 9, 2), (9, 9, 3))
87

88
    def test_RGBA(self) -> None:
89
        self.assert_pack("RGBA", "RGBA", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))
90
        self.assert_pack(
91
            "RGBA", "RGBA;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
92
        )
93
        self.assert_pack("RGBA", "RGB", 3, (1, 2, 3, 14), (4, 5, 6, 15), (7, 8, 9, 16))
94
        self.assert_pack("RGBA", "BGR", 3, (3, 2, 1, 14), (6, 5, 4, 15), (9, 8, 7, 16))
95
        self.assert_pack("RGBA", "BGRA", 4, (3, 2, 1, 4), (7, 6, 5, 8), (11, 10, 9, 12))
96
        self.assert_pack("RGBA", "ABGR", 4, (4, 3, 2, 1), (8, 7, 6, 5), (12, 11, 10, 9))
97
        self.assert_pack(
98
            "RGBA",
99
            "BGRa",
100
            4,
101
            (191, 127, 63, 4),
102
            (223, 191, 159, 8),
103
            (233, 212, 191, 12),
104
        )
105
        self.assert_pack("RGBA", "R", 1, (1, 0, 8, 9), (2, 0, 8, 9), (3, 0, 8, 0))
106
        self.assert_pack("RGBA", "G", 1, (6, 1, 8, 9), (6, 2, 8, 9), (6, 3, 8, 9))
107
        self.assert_pack("RGBA", "B", 1, (6, 7, 1, 9), (6, 7, 2, 0), (6, 7, 3, 9))
108
        self.assert_pack("RGBA", "A", 1, (6, 7, 0, 1), (6, 7, 0, 2), (0, 7, 0, 3))
109

110
    def test_RGBa(self) -> None:
111
        self.assert_pack("RGBa", "RGBa", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))
112
        self.assert_pack("RGBa", "BGRa", 4, (3, 2, 1, 4), (7, 6, 5, 8), (11, 10, 9, 12))
113
        self.assert_pack("RGBa", "aBGR", 4, (4, 3, 2, 1), (8, 7, 6, 5), (12, 11, 10, 9))
114

115
    def test_RGBX(self) -> None:
116
        self.assert_pack("RGBX", "RGBX", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))
117
        self.assert_pack(
118
            "RGBX", "RGBX;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
119
        )
120
        self.assert_pack("RGBX", "RGB", 3, (1, 2, 3, X), (4, 5, 6, X), (7, 8, 9, X))
121
        self.assert_pack("RGBX", "BGR", 3, (3, 2, 1, X), (6, 5, 4, X), (9, 8, 7, X))
122
        self.assert_pack(
123
            "RGBX",
124
            "BGRX",
125
            b"\x01\x02\x03\x00\x05\x06\x07\x00\t\n\x0b\x00",
126
            (3, 2, 1, X),
127
            (7, 6, 5, X),
128
            (11, 10, 9, X),
129
        )
130
        self.assert_pack(
131
            "RGBX",
132
            "XBGR",
133
            b"\x00\x02\x03\x04\x00\x06\x07\x08\x00\n\x0b\x0c",
134
            (4, 3, 2, X),
135
            (8, 7, 6, X),
136
            (12, 11, 10, X),
137
        )
138
        self.assert_pack("RGBX", "R", 1, (1, 0, 8, 9), (2, 0, 8, 9), (3, 0, 8, 0))
139
        self.assert_pack("RGBX", "G", 1, (6, 1, 8, 9), (6, 2, 8, 9), (6, 3, 8, 9))
140
        self.assert_pack("RGBX", "B", 1, (6, 7, 1, 9), (6, 7, 2, 0), (6, 7, 3, 9))
141
        self.assert_pack("RGBX", "X", 1, (6, 7, 0, 1), (6, 7, 0, 2), (0, 7, 0, 3))
142

143
    def test_CMYK(self) -> None:
144
        self.assert_pack("CMYK", "CMYK", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))
145
        self.assert_pack(
146
            "CMYK",
147
            "CMYK;I",
148
            4,
149
            (254, 253, 252, 251),
150
            (250, 249, 248, 247),
151
            (246, 245, 244, 243),
152
        )
153
        self.assert_pack(
154
            "CMYK", "CMYK;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
155
        )
156
        self.assert_pack("CMYK", "K", 1, (6, 7, 0, 1), (6, 7, 0, 2), (0, 7, 0, 3))
157

158
    def test_YCbCr(self) -> None:
159
        self.assert_pack("YCbCr", "YCbCr", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
160
        self.assert_pack("YCbCr", "YCbCr;L", 3, (1, 4, 7), (2, 5, 8), (3, 6, 9))
161
        self.assert_pack(
162
            "YCbCr",
163
            "YCbCrX",
164
            b"\x01\x02\x03\xff\x05\x06\x07\xff\t\n\x0b\xff",
165
            (1, 2, 3),
166
            (5, 6, 7),
167
            (9, 10, 11),
168
        )
169
        self.assert_pack(
170
            "YCbCr",
171
            "YCbCrK",
172
            b"\x01\x02\x03\xff\x05\x06\x07\xff\t\n\x0b\xff",
173
            (1, 2, 3),
174
            (5, 6, 7),
175
            (9, 10, 11),
176
        )
177
        self.assert_pack("YCbCr", "Y", 1, (1, 0, 8, 9), (2, 0, 8, 9), (3, 0, 8, 0))
178
        self.assert_pack("YCbCr", "Cb", 1, (6, 1, 8, 9), (6, 2, 8, 9), (6, 3, 8, 9))
179
        self.assert_pack("YCbCr", "Cr", 1, (6, 7, 1, 9), (6, 7, 2, 0), (6, 7, 3, 9))
180

181
    def test_LAB(self) -> None:
182
        self.assert_pack("LAB", "LAB", 3, (1, 130, 131), (4, 133, 134), (7, 136, 137))
183
        self.assert_pack("LAB", "L", 1, (1, 9, 9), (2, 9, 9), (3, 9, 9))
184
        self.assert_pack("LAB", "A", 1, (9, 1, 9), (9, 2, 9), (9, 3, 9))
185
        self.assert_pack("LAB", "B", 1, (9, 9, 1), (9, 9, 2), (9, 9, 3))
186

187
    def test_HSV(self) -> None:
188
        self.assert_pack("HSV", "HSV", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
189
        self.assert_pack("HSV", "H", 1, (1, 9, 9), (2, 9, 9), (3, 9, 9))
190
        self.assert_pack("HSV", "S", 1, (9, 1, 9), (9, 2, 9), (9, 3, 9))
191
        self.assert_pack("HSV", "V", 1, (9, 9, 1), (9, 9, 2), (9, 9, 3))
192

193
    def test_I(self) -> None:
194
        self.assert_pack("I", "I;16B", 2, 0x0102, 0x0304)
195
        self.assert_pack(
196
            "I", "I;32S", b"\x83\x00\x00\x01\x01\x00\x00\x83", 0x01000083, -2097151999
197
        )
198

199
        if sys.byteorder == "little":
200
            self.assert_pack("I", "I", 4, 0x04030201, 0x08070605)
201
            self.assert_pack(
202
                "I",
203
                "I;32NS",
204
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
205
                0x01000083,
206
                -2097151999,
207
            )
208
        else:
209
            self.assert_pack("I", "I", 4, 0x01020304, 0x05060708)
210
            self.assert_pack(
211
                "I",
212
                "I;32NS",
213
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
214
                -2097151999,
215
                0x01000083,
216
            )
217

218
    def test_I16(self) -> None:
219
        if sys.byteorder == "little":
220
            self.assert_pack("I;16N", "I;16N", 2, 0x0201, 0x0403, 0x0605)
221
        else:
222
            self.assert_pack("I;16N", "I;16N", 2, 0x0102, 0x0304, 0x0506)
223

224
    def test_F_float(self) -> None:
225
        self.assert_pack("F", "F;32F", 4, 1.539989614439558e-36, 4.063216068939723e-34)
226

227
        if sys.byteorder == "little":
228
            self.assert_pack("F", "F", 4, 1.539989614439558e-36, 4.063216068939723e-34)
229
            self.assert_pack(
230
                "F", "F;32NF", 4, 1.539989614439558e-36, 4.063216068939723e-34
231
            )
232
        else:
233
            self.assert_pack("F", "F", 4, 2.387939260590663e-38, 6.301941157072183e-36)
234
            self.assert_pack(
235
                "F", "F;32NF", 4, 2.387939260590663e-38, 6.301941157072183e-36
236
            )
237

238

239
class TestLibUnpack:
240
    def assert_unpack(
241
        self,
242
        mode: str,
243
        rawmode: str,
244
        data: int | bytes,
245
        *pixels: float | tuple[int, ...],
246
    ) -> None:
247
        """
248
        data - either raw bytes with data or just number of bytes in rawmode.
249
        """
250
        if isinstance(data, int):
251
            data_len = data * len(pixels)
252
            data = bytes(range(1, data_len + 1))
253

254
        im = Image.frombytes(mode, (len(pixels), 1), data, "raw", rawmode, 0, 1)
255

256
        for x, pixel in enumerate(pixels):
257
            assert pixel == im.getpixel((x, 0))
258

259
    def test_1(self) -> None:
260
        self.assert_unpack("1", "1", b"\x01", 0, 0, 0, 0, 0, 0, 0, X)
261
        self.assert_unpack("1", "1;I", b"\x01", X, X, X, X, X, X, X, 0)
262
        self.assert_unpack("1", "1;R", b"\x01", X, 0, 0, 0, 0, 0, 0, 0)
263
        self.assert_unpack("1", "1;IR", b"\x01", 0, X, X, X, X, X, X, X)
264

265
        self.assert_unpack("1", "1", b"\xaa", X, 0, X, 0, X, 0, X, 0)
266
        self.assert_unpack("1", "1;I", b"\xaa", 0, X, 0, X, 0, X, 0, X)
267
        self.assert_unpack("1", "1;R", b"\xaa", 0, X, 0, X, 0, X, 0, X)
268
        self.assert_unpack("1", "1;IR", b"\xaa", X, 0, X, 0, X, 0, X, 0)
269

270
        self.assert_unpack("1", "1;8", b"\x00\x01\x02\xff", 0, X, X, X)
271

272
    def test_L(self) -> None:
273
        self.assert_unpack("L", "L;2", b"\xe4", 255, 170, 85, 0)
274
        self.assert_unpack("L", "L;2I", b"\xe4", 0, 85, 170, 255)
275
        self.assert_unpack("L", "L;2R", b"\xe4", 0, 170, 85, 255)
276
        self.assert_unpack("L", "L;2IR", b"\xe4", 255, 85, 170, 0)
277

278
        self.assert_unpack("L", "L;4", b"\x02\xef", 0, 34, 238, 255)
279
        self.assert_unpack("L", "L;4I", b"\x02\xef", 255, 221, 17, 0)
280
        self.assert_unpack("L", "L;4R", b"\x02\xef", 68, 0, 255, 119)
281
        self.assert_unpack("L", "L;4IR", b"\x02\xef", 187, 255, 0, 136)
282

283
        self.assert_unpack("L", "L", 1, 1, 2, 3, 4)
284
        self.assert_unpack("L", "L;I", 1, 254, 253, 252, 251)
285
        self.assert_unpack("L", "L;R", 1, 128, 64, 192, 32)
286
        self.assert_unpack("L", "L;16", 2, 2, 4, 6, 8)
287
        self.assert_unpack("L", "L;16B", 2, 1, 3, 5, 7)
288
        self.assert_unpack("L", "L;16", b"\x00\xc6\x00\xaf", 198, 175)
289
        self.assert_unpack("L", "L;16B", b"\xc6\x00\xaf\x00", 198, 175)
290

291
    def test_LA(self) -> None:
292
        self.assert_unpack("LA", "LA", 2, (1, 2), (3, 4), (5, 6))
293
        self.assert_unpack("LA", "LA;L", 2, (1, 4), (2, 5), (3, 6))
294

295
    def test_La(self) -> None:
296
        self.assert_unpack("La", "La", 2, (1, 2), (3, 4), (5, 6))
297

298
    def test_P(self) -> None:
299
        self.assert_unpack("P", "P;1", b"\xe4", 1, 1, 1, 0, 0, 1, 0, 0)
300
        self.assert_unpack("P", "P;2", b"\xe4", 3, 2, 1, 0)
301
        # erroneous?
302
        # self.assert_unpack("P", "P;2L", b'\xe4', 1, 1, 1, 0)
303
        self.assert_unpack("P", "P;4", b"\x02\xef", 0, 2, 14, 15)
304
        # erroneous?
305
        # self.assert_unpack("P", "P;4L", b'\x02\xef', 2, 10, 10, 0)
306
        self.assert_unpack("P", "P", 1, 1, 2, 3, 4)
307
        self.assert_unpack("P", "P;R", 1, 128, 64, 192, 32)
308

309
    def test_PA(self) -> None:
310
        self.assert_unpack("PA", "PA", 2, (1, 2), (3, 4), (5, 6))
311
        self.assert_unpack("PA", "PA;L", 2, (1, 4), (2, 5), (3, 6))
312

313
    def test_RGB(self) -> None:
314
        self.assert_unpack("RGB", "RGB", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
315
        self.assert_unpack("RGB", "RGB;L", 3, (1, 4, 7), (2, 5, 8), (3, 6, 9))
316
        self.assert_unpack("RGB", "RGB;R", 3, (128, 64, 192), (32, 160, 96))
317
        self.assert_unpack("RGB", "RGB;16L", 6, (2, 4, 6), (8, 10, 12))
318
        self.assert_unpack("RGB", "RGB;16B", 6, (1, 3, 5), (7, 9, 11))
319
        self.assert_unpack("RGB", "BGR", 3, (3, 2, 1), (6, 5, 4), (9, 8, 7))
320
        self.assert_unpack("RGB", "RGB;15", 2, (8, 131, 0), (24, 0, 8))
321
        self.assert_unpack("RGB", "BGR;15", 2, (0, 131, 8), (8, 0, 24))
322
        self.assert_unpack("RGB", "RGB;16", 2, (8, 64, 0), (24, 129, 0))
323
        self.assert_unpack("RGB", "BGR;16", 2, (0, 64, 8), (0, 129, 24))
324
        self.assert_unpack("RGB", "RGB;4B", 2, (17, 0, 34), (51, 0, 68))
325
        self.assert_unpack("RGB", "RGBX", 4, (1, 2, 3), (5, 6, 7), (9, 10, 11))
326
        self.assert_unpack("RGB", "RGBX;L", 4, (1, 4, 7), (2, 5, 8), (3, 6, 9))
327
        self.assert_unpack("RGB", "BGRX", 4, (3, 2, 1), (7, 6, 5), (11, 10, 9))
328
        self.assert_unpack("RGB", "XRGB", 4, (2, 3, 4), (6, 7, 8), (10, 11, 12))
329
        self.assert_unpack("RGB", "XBGR", 4, (4, 3, 2), (8, 7, 6), (12, 11, 10))
330
        self.assert_unpack(
331
            "RGB",
332
            "YCC;P",
333
            b"D]\x9c\x82\x1a\x91\xfaOC\xe7J\x12",  # random data
334
            (127, 102, 0),
335
            (192, 227, 0),
336
            (213, 255, 170),
337
            (98, 255, 133),
338
        )
339
        self.assert_unpack("RGB", "R", 1, (1, 0, 0), (2, 0, 0), (3, 0, 0))
340
        self.assert_unpack("RGB", "G", 1, (0, 1, 0), (0, 2, 0), (0, 3, 0))
341
        self.assert_unpack("RGB", "B", 1, (0, 0, 1), (0, 0, 2), (0, 0, 3))
342

343
        self.assert_unpack("RGB", "R;16B", 2, (1, 0, 0), (3, 0, 0), (5, 0, 0))
344
        self.assert_unpack("RGB", "G;16B", 2, (0, 1, 0), (0, 3, 0), (0, 5, 0))
345
        self.assert_unpack("RGB", "B;16B", 2, (0, 0, 1), (0, 0, 3), (0, 0, 5))
346

347
        self.assert_unpack("RGB", "R;16L", 2, (2, 0, 0), (4, 0, 0), (6, 0, 0))
348
        self.assert_unpack("RGB", "G;16L", 2, (0, 2, 0), (0, 4, 0), (0, 6, 0))
349
        self.assert_unpack("RGB", "B;16L", 2, (0, 0, 2), (0, 0, 4), (0, 0, 6))
350

351
        if sys.byteorder == "little":
352
            self.assert_unpack("RGB", "R;16N", 2, (2, 0, 0), (4, 0, 0), (6, 0, 0))
353
            self.assert_unpack("RGB", "G;16N", 2, (0, 2, 0), (0, 4, 0), (0, 6, 0))
354
            self.assert_unpack("RGB", "B;16N", 2, (0, 0, 2), (0, 0, 4), (0, 0, 6))
355
        else:
356
            self.assert_unpack("RGB", "R;16N", 2, (1, 0, 0), (3, 0, 0), (5, 0, 0))
357
            self.assert_unpack("RGB", "G;16N", 2, (0, 1, 0), (0, 3, 0), (0, 5, 0))
358
            self.assert_unpack("RGB", "B;16N", 2, (0, 0, 1), (0, 0, 3), (0, 0, 5))
359

360
        self.assert_unpack(
361
            "RGB", "CMYK", 4, (250, 249, 248), (242, 241, 240), (234, 233, 233)
362
        )
363

364
    def test_BGR(self) -> None:
365
        with pytest.warns(DeprecationWarning):
366
            self.assert_unpack(
367
                "BGR;15", "BGR;15", 3, (8, 131, 0), (24, 0, 8), (41, 131, 8)
368
            )
369
            self.assert_unpack(
370
                "BGR;16", "BGR;16", 3, (8, 64, 0), (24, 129, 0), (41, 194, 0)
371
            )
372
            self.assert_unpack("BGR;24", "BGR;24", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
373

374
    def test_RGBA(self) -> None:
375
        self.assert_unpack("RGBA", "LA", 2, (1, 1, 1, 2), (3, 3, 3, 4), (5, 5, 5, 6))
376
        self.assert_unpack(
377
            "RGBA", "LA;16B", 4, (1, 1, 1, 3), (5, 5, 5, 7), (9, 9, 9, 11)
378
        )
379
        self.assert_unpack(
380
            "RGBA", "RGBA", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)
381
        )
382
        self.assert_unpack(
383
            "RGBA", "RGBAX", 5, (1, 2, 3, 4), (6, 7, 8, 9), (11, 12, 13, 14)
384
        )
385
        self.assert_unpack(
386
            "RGBA", "RGBAXX", 6, (1, 2, 3, 4), (7, 8, 9, 10), (13, 14, 15, 16)
387
        )
388
        self.assert_unpack(
389
            "RGBA",
390
            "RGBa",
391
            4,
392
            (63, 127, 191, 4),
393
            (159, 191, 223, 8),
394
            (191, 212, 233, 12),
395
        )
396
        self.assert_unpack(
397
            "RGBA",
398
            "RGBa",
399
            b"\x01\x02\x03\x00\x10\x20\x30\x7f\x10\x20\x30\xff",
400
            (0, 0, 0, 0),
401
            (32, 64, 96, 127),
402
            (16, 32, 48, 255),
403
        )
404
        self.assert_unpack(
405
            "RGBA",
406
            "RGBaX",
407
            b"\x01\x02\x03\x00-\x10\x20\x30\x7f-\x10\x20\x30\xff-",
408
            (0, 0, 0, 0),
409
            (32, 64, 96, 127),
410
            (16, 32, 48, 255),
411
        )
412
        self.assert_unpack(
413
            "RGBA",
414
            "RGBaXX",
415
            b"\x01\x02\x03\x00==\x10\x20\x30\x7f!!\x10\x20\x30\xff??",
416
            (0, 0, 0, 0),
417
            (32, 64, 96, 127),
418
            (16, 32, 48, 255),
419
        )
420
        self.assert_unpack(
421
            "RGBA",
422
            "RGBa;16L",
423
            8,
424
            (63, 127, 191, 8),
425
            (159, 191, 223, 16),
426
            (191, 212, 233, 24),
427
        )
428
        self.assert_unpack(
429
            "RGBA",
430
            "RGBa;16L",
431
            b"\x88\x01\x88\x02\x88\x03\x88\x00\x88\x10\x88\x20\x88\x30\x88\xff",
432
            (0, 0, 0, 0),
433
            (16, 32, 48, 255),
434
        )
435
        self.assert_unpack(
436
            "RGBA",
437
            "RGBa;16B",
438
            8,
439
            (36, 109, 182, 7),
440
            (153, 187, 221, 15),
441
            (188, 210, 232, 23),
442
        )
443
        self.assert_unpack(
444
            "RGBA",
445
            "RGBa;16B",
446
            b"\x01\x88\x02\x88\x03\x88\x00\x88\x10\x88\x20\x88\x30\x88\xff\x88",
447
            (0, 0, 0, 0),
448
            (16, 32, 48, 255),
449
        )
450
        self.assert_unpack(
451
            "RGBA",
452
            "BGRa",
453
            4,
454
            (191, 127, 63, 4),
455
            (223, 191, 159, 8),
456
            (233, 212, 191, 12),
457
        )
458
        self.assert_unpack(
459
            "RGBA",
460
            "BGRa",
461
            b"\x01\x02\x03\x00\x10\x20\x30\xff",
462
            (0, 0, 0, 0),
463
            (48, 32, 16, 255),
464
        )
465
        self.assert_unpack(
466
            "RGBA",
467
            "RGBA;I",
468
            4,
469
            (254, 253, 252, 4),
470
            (250, 249, 248, 8),
471
            (246, 245, 244, 12),
472
        )
473
        self.assert_unpack(
474
            "RGBA", "RGBA;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
475
        )
476
        self.assert_unpack("RGBA", "RGBA;15", 2, (8, 131, 0, 0), (24, 0, 8, 0))
477
        self.assert_unpack("RGBA", "BGRA;15", 2, (0, 131, 8, 0), (8, 0, 24, 0))
478
        self.assert_unpack("RGBA", "RGBA;4B", 2, (17, 0, 34, 0), (51, 0, 68, 0))
479
        self.assert_unpack("RGBA", "RGBA;16L", 8, (2, 4, 6, 8), (10, 12, 14, 16))
480
        self.assert_unpack("RGBA", "RGBA;16B", 8, (1, 3, 5, 7), (9, 11, 13, 15))
481
        self.assert_unpack("RGBA", "BGRA;16L", 8, (6, 4, 2, 8), (14, 12, 10, 16))
482
        self.assert_unpack("RGBA", "BGRA;16B", 8, (5, 3, 1, 7), (13, 11, 9, 15))
483
        self.assert_unpack(
484
            "RGBA", "BGRA", 4, (3, 2, 1, 4), (7, 6, 5, 8), (11, 10, 9, 12)
485
        )
486
        self.assert_unpack(
487
            "RGBA", "ARGB", 4, (2, 3, 4, 1), (6, 7, 8, 5), (10, 11, 12, 9)
488
        )
489
        self.assert_unpack(
490
            "RGBA", "ABGR", 4, (4, 3, 2, 1), (8, 7, 6, 5), (12, 11, 10, 9)
491
        )
492
        self.assert_unpack(
493
            "RGBA",
494
            "YCCA;P",
495
            b"]bE\x04\xdd\xbej\xed57T\xce\xac\xce:\x11",  # random data
496
            (0, 161, 0, 4),
497
            (255, 255, 255, 237),
498
            (27, 158, 0, 206),
499
            (0, 118, 0, 17),
500
        )
501
        self.assert_unpack("RGBA", "R", 1, (1, 0, 0, 0), (2, 0, 0, 0), (3, 0, 0, 0))
502
        self.assert_unpack("RGBA", "G", 1, (0, 1, 0, 0), (0, 2, 0, 0), (0, 3, 0, 0))
503
        self.assert_unpack("RGBA", "B", 1, (0, 0, 1, 0), (0, 0, 2, 0), (0, 0, 3, 0))
504
        self.assert_unpack("RGBA", "A", 1, (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3))
505

506
        self.assert_unpack("RGBA", "R;16B", 2, (1, 0, 0, 0), (3, 0, 0, 0), (5, 0, 0, 0))
507
        self.assert_unpack("RGBA", "G;16B", 2, (0, 1, 0, 0), (0, 3, 0, 0), (0, 5, 0, 0))
508
        self.assert_unpack("RGBA", "B;16B", 2, (0, 0, 1, 0), (0, 0, 3, 0), (0, 0, 5, 0))
509
        self.assert_unpack("RGBA", "A;16B", 2, (0, 0, 0, 1), (0, 0, 0, 3), (0, 0, 0, 5))
510

511
        self.assert_unpack("RGBA", "R;16L", 2, (2, 0, 0, 0), (4, 0, 0, 0), (6, 0, 0, 0))
512
        self.assert_unpack("RGBA", "G;16L", 2, (0, 2, 0, 0), (0, 4, 0, 0), (0, 6, 0, 0))
513
        self.assert_unpack("RGBA", "B;16L", 2, (0, 0, 2, 0), (0, 0, 4, 0), (0, 0, 6, 0))
514
        self.assert_unpack("RGBA", "A;16L", 2, (0, 0, 0, 2), (0, 0, 0, 4), (0, 0, 0, 6))
515

516
        if sys.byteorder == "little":
517
            self.assert_unpack(
518
                "RGBA", "R;16N", 2, (2, 0, 0, 0), (4, 0, 0, 0), (6, 0, 0, 0)
519
            )
520
            self.assert_unpack(
521
                "RGBA", "G;16N", 2, (0, 2, 0, 0), (0, 4, 0, 0), (0, 6, 0, 0)
522
            )
523
            self.assert_unpack(
524
                "RGBA", "B;16N", 2, (0, 0, 2, 0), (0, 0, 4, 0), (0, 0, 6, 0)
525
            )
526
            self.assert_unpack(
527
                "RGBA", "A;16N", 2, (0, 0, 0, 2), (0, 0, 0, 4), (0, 0, 0, 6)
528
            )
529
        else:
530
            self.assert_unpack(
531
                "RGBA", "R;16N", 2, (1, 0, 0, 0), (3, 0, 0, 0), (5, 0, 0, 0)
532
            )
533
            self.assert_unpack(
534
                "RGBA", "G;16N", 2, (0, 1, 0, 0), (0, 3, 0, 0), (0, 5, 0, 0)
535
            )
536
            self.assert_unpack(
537
                "RGBA", "B;16N", 2, (0, 0, 1, 0), (0, 0, 3, 0), (0, 0, 5, 0)
538
            )
539
            self.assert_unpack(
540
                "RGBA", "A;16N", 2, (0, 0, 0, 1), (0, 0, 0, 3), (0, 0, 0, 5)
541
            )
542

543
    def test_RGBa(self) -> None:
544
        self.assert_unpack(
545
            "RGBa", "RGBa", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)
546
        )
547
        self.assert_unpack(
548
            "RGBa", "BGRa", 4, (3, 2, 1, 4), (7, 6, 5, 8), (11, 10, 9, 12)
549
        )
550
        self.assert_unpack(
551
            "RGBa", "aRGB", 4, (2, 3, 4, 1), (6, 7, 8, 5), (10, 11, 12, 9)
552
        )
553
        self.assert_unpack(
554
            "RGBa", "aBGR", 4, (4, 3, 2, 1), (8, 7, 6, 5), (12, 11, 10, 9)
555
        )
556

557
    def test_RGBX(self) -> None:
558
        self.assert_unpack("RGBX", "RGB", 3, (1, 2, 3, X), (4, 5, 6, X), (7, 8, 9, X))
559
        self.assert_unpack("RGBX", "RGB;L", 3, (1, 4, 7, X), (2, 5, 8, X), (3, 6, 9, X))
560
        self.assert_unpack("RGBX", "RGB;16B", 6, (1, 3, 5, X), (7, 9, 11, X))
561
        self.assert_unpack("RGBX", "BGR", 3, (3, 2, 1, X), (6, 5, 4, X), (9, 8, 7, X))
562
        self.assert_unpack("RGBX", "RGB;15", 2, (8, 131, 0, X), (24, 0, 8, X))
563
        self.assert_unpack("RGBX", "BGR;15", 2, (0, 131, 8, X), (8, 0, 24, X))
564
        self.assert_unpack("RGBX", "RGB;4B", 2, (17, 0, 34, X), (51, 0, 68, X))
565
        self.assert_unpack(
566
            "RGBX", "RGBX", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)
567
        )
568
        self.assert_unpack(
569
            "RGBX", "RGBXX", 5, (1, 2, 3, 4), (6, 7, 8, 9), (11, 12, 13, 14)
570
        )
571
        self.assert_unpack(
572
            "RGBX", "RGBXXX", 6, (1, 2, 3, 4), (7, 8, 9, 10), (13, 14, 15, 16)
573
        )
574
        self.assert_unpack(
575
            "RGBX", "RGBX;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
576
        )
577
        self.assert_unpack("RGBX", "RGBX;16L", 8, (2, 4, 6, 8), (10, 12, 14, 16))
578
        self.assert_unpack("RGBX", "RGBX;16B", 8, (1, 3, 5, 7), (9, 11, 13, 15))
579
        self.assert_unpack(
580
            "RGBX", "BGRX", 4, (3, 2, 1, X), (7, 6, 5, X), (11, 10, 9, X)
581
        )
582
        self.assert_unpack(
583
            "RGBX", "XRGB", 4, (2, 3, 4, X), (6, 7, 8, X), (10, 11, 12, X)
584
        )
585
        self.assert_unpack(
586
            "RGBX", "XBGR", 4, (4, 3, 2, X), (8, 7, 6, X), (12, 11, 10, X)
587
        )
588
        self.assert_unpack(
589
            "RGBX",
590
            "YCC;P",
591
            b"D]\x9c\x82\x1a\x91\xfaOC\xe7J\x12",  # random data
592
            (127, 102, 0, X),
593
            (192, 227, 0, X),
594
            (213, 255, 170, X),
595
            (98, 255, 133, X),
596
        )
597
        self.assert_unpack("RGBX", "R", 1, (1, 0, 0, 0), (2, 0, 0, 0), (3, 0, 0, 0))
598
        self.assert_unpack("RGBX", "G", 1, (0, 1, 0, 0), (0, 2, 0, 0), (0, 3, 0, 0))
599
        self.assert_unpack("RGBX", "B", 1, (0, 0, 1, 0), (0, 0, 2, 0), (0, 0, 3, 0))
600
        self.assert_unpack("RGBX", "X", 1, (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3))
601

602
    def test_CMYK(self) -> None:
603
        self.assert_unpack(
604
            "CMYK", "CMYK", 4, (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)
605
        )
606
        self.assert_unpack(
607
            "CMYK", "CMYKX", 5, (1, 2, 3, 4), (6, 7, 8, 9), (11, 12, 13, 14)
608
        )
609
        self.assert_unpack(
610
            "CMYK", "CMYKXX", 6, (1, 2, 3, 4), (7, 8, 9, 10), (13, 14, 15, 16)
611
        )
612
        self.assert_unpack(
613
            "CMYK",
614
            "CMYK;I",
615
            4,
616
            (254, 253, 252, 251),
617
            (250, 249, 248, 247),
618
            (246, 245, 244, 243),
619
        )
620
        self.assert_unpack(
621
            "CMYK", "CMYK;L", 4, (1, 4, 7, 10), (2, 5, 8, 11), (3, 6, 9, 12)
622
        )
623
        self.assert_unpack("CMYK", "C", 1, (1, 0, 0, 0), (2, 0, 0, 0), (3, 0, 0, 0))
624
        self.assert_unpack("CMYK", "M", 1, (0, 1, 0, 0), (0, 2, 0, 0), (0, 3, 0, 0))
625
        self.assert_unpack("CMYK", "Y", 1, (0, 0, 1, 0), (0, 0, 2, 0), (0, 0, 3, 0))
626
        self.assert_unpack("CMYK", "K", 1, (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3))
627
        self.assert_unpack(
628
            "CMYK", "C;I", 1, (254, 0, 0, 0), (253, 0, 0, 0), (252, 0, 0, 0)
629
        )
630
        self.assert_unpack(
631
            "CMYK", "M;I", 1, (0, 254, 0, 0), (0, 253, 0, 0), (0, 252, 0, 0)
632
        )
633
        self.assert_unpack(
634
            "CMYK", "Y;I", 1, (0, 0, 254, 0), (0, 0, 253, 0), (0, 0, 252, 0)
635
        )
636
        self.assert_unpack(
637
            "CMYK", "K;I", 1, (0, 0, 0, 254), (0, 0, 0, 253), (0, 0, 0, 252)
638
        )
639

640
    def test_YCbCr(self) -> None:
641
        self.assert_unpack("YCbCr", "YCbCr", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
642
        self.assert_unpack("YCbCr", "YCbCr;L", 3, (1, 4, 7), (2, 5, 8), (3, 6, 9))
643
        self.assert_unpack("YCbCr", "YCbCrK", 4, (1, 2, 3), (5, 6, 7), (9, 10, 11))
644
        self.assert_unpack("YCbCr", "YCbCrX", 4, (1, 2, 3), (5, 6, 7), (9, 10, 11))
645

646
    def test_LAB(self) -> None:
647
        self.assert_unpack("LAB", "LAB", 3, (1, 130, 131), (4, 133, 134), (7, 136, 137))
648
        self.assert_unpack("LAB", "L", 1, (1, 0, 0), (2, 0, 0), (3, 0, 0))
649
        self.assert_unpack("LAB", "A", 1, (0, 1, 0), (0, 2, 0), (0, 3, 0))
650
        self.assert_unpack("LAB", "B", 1, (0, 0, 1), (0, 0, 2), (0, 0, 3))
651

652
    def test_HSV(self) -> None:
653
        self.assert_unpack("HSV", "HSV", 3, (1, 2, 3), (4, 5, 6), (7, 8, 9))
654
        self.assert_unpack("HSV", "H", 1, (1, 0, 0), (2, 0, 0), (3, 0, 0))
655
        self.assert_unpack("HSV", "S", 1, (0, 1, 0), (0, 2, 0), (0, 3, 0))
656
        self.assert_unpack("HSV", "V", 1, (0, 0, 1), (0, 0, 2), (0, 0, 3))
657

658
    def test_I(self) -> None:
659
        self.assert_unpack("I", "I;8", 1, 0x01, 0x02, 0x03, 0x04)
660
        self.assert_unpack("I", "I;8S", b"\x01\x83", 1, -125)
661
        self.assert_unpack("I", "I;16", 2, 0x0201, 0x0403)
662
        self.assert_unpack("I", "I;16S", b"\x83\x01\x01\x83", 0x0183, -31999)
663
        self.assert_unpack("I", "I;16B", 2, 0x0102, 0x0304)
664
        self.assert_unpack("I", "I;16BS", b"\x83\x01\x01\x83", -31999, 0x0183)
665
        self.assert_unpack("I", "I;32", 4, 0x04030201, 0x08070605)
666
        self.assert_unpack(
667
            "I", "I;32S", b"\x83\x00\x00\x01\x01\x00\x00\x83", 0x01000083, -2097151999
668
        )
669
        self.assert_unpack("I", "I;32B", 4, 0x01020304, 0x05060708)
670
        self.assert_unpack(
671
            "I", "I;32BS", b"\x83\x00\x00\x01\x01\x00\x00\x83", -2097151999, 0x01000083
672
        )
673

674
        if sys.byteorder == "little":
675
            self.assert_unpack("I", "I", 4, 0x04030201, 0x08070605)
676
            self.assert_unpack("I", "I;16N", 2, 0x0201, 0x0403)
677
            self.assert_unpack("I", "I;16NS", b"\x83\x01\x01\x83", 0x0183, -31999)
678
            self.assert_unpack("I", "I;32N", 4, 0x04030201, 0x08070605)
679
            self.assert_unpack(
680
                "I",
681
                "I;32NS",
682
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
683
                0x01000083,
684
                -2097151999,
685
            )
686
        else:
687
            self.assert_unpack("I", "I", 4, 0x01020304, 0x05060708)
688
            self.assert_unpack("I", "I;16N", 2, 0x0102, 0x0304)
689
            self.assert_unpack("I", "I;16NS", b"\x83\x01\x01\x83", -31999, 0x0183)
690
            self.assert_unpack("I", "I;32N", 4, 0x01020304, 0x05060708)
691
            self.assert_unpack(
692
                "I",
693
                "I;32NS",
694
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
695
                -2097151999,
696
                0x01000083,
697
            )
698

699
    def test_F_int(self) -> None:
700
        self.assert_unpack("F", "F;8", 1, 0x01, 0x02, 0x03, 0x04)
701
        self.assert_unpack("F", "F;8S", b"\x01\x83", 1, -125)
702
        self.assert_unpack("F", "F;16", 2, 0x0201, 0x0403)
703
        self.assert_unpack("F", "F;16S", b"\x83\x01\x01\x83", 0x0183, -31999)
704
        self.assert_unpack("F", "F;16B", 2, 0x0102, 0x0304)
705
        self.assert_unpack("F", "F;16BS", b"\x83\x01\x01\x83", -31999, 0x0183)
706
        self.assert_unpack("F", "F;32", 4, 67305984, 134678016)
707
        self.assert_unpack(
708
            "F", "F;32S", b"\x83\x00\x00\x01\x01\x00\x00\x83", 16777348, -2097152000
709
        )
710
        self.assert_unpack("F", "F;32B", 4, 0x01020304, 0x05060708)
711
        self.assert_unpack(
712
            "F", "F;32BS", b"\x83\x00\x00\x01\x01\x00\x00\x83", -2097152000, 16777348
713
        )
714

715
        if sys.byteorder == "little":
716
            self.assert_unpack("F", "F;16N", 2, 0x0201, 0x0403)
717
            self.assert_unpack("F", "F;16NS", b"\x83\x01\x01\x83", 0x0183, -31999)
718
            self.assert_unpack("F", "F;32N", 4, 67305984, 134678016)
719
            self.assert_unpack(
720
                "F",
721
                "F;32NS",
722
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
723
                16777348,
724
                -2097152000,
725
            )
726
        else:
727
            self.assert_unpack("F", "F;16N", 2, 0x0102, 0x0304)
728
            self.assert_unpack("F", "F;16NS", b"\x83\x01\x01\x83", -31999, 0x0183)
729
            self.assert_unpack("F", "F;32N", 4, 0x01020304, 0x05060708)
730
            self.assert_unpack(
731
                "F",
732
                "F;32NS",
733
                b"\x83\x00\x00\x01\x01\x00\x00\x83",
734
                -2097152000,
735
                16777348,
736
            )
737

738
    def test_F_float(self) -> None:
739
        self.assert_unpack(
740
            "F", "F;32F", 4, 1.539989614439558e-36, 4.063216068939723e-34
741
        )
742
        self.assert_unpack(
743
            "F", "F;32BF", 4, 2.387939260590663e-38, 6.301941157072183e-36
744
        )
745
        self.assert_unpack(
746
            "F",
747
            "F;64F",
748
            b"333333\xc3?\x00\x00\x00\x00\x00J\x93\xc0",  # by struct.pack
749
            0.15000000596046448,
750
            -1234.5,
751
        )
752
        self.assert_unpack(
753
            "F",
754
            "F;64BF",
755
            b"?\xc3333333\xc0\x93J\x00\x00\x00\x00\x00",  # by struct.pack
756
            0.15000000596046448,
757
            -1234.5,
758
        )
759

760
        if sys.byteorder == "little":
761
            self.assert_unpack(
762
                "F", "F", 4, 1.539989614439558e-36, 4.063216068939723e-34
763
            )
764
            self.assert_unpack(
765
                "F", "F;32NF", 4, 1.539989614439558e-36, 4.063216068939723e-34
766
            )
767
            self.assert_unpack(
768
                "F",
769
                "F;64NF",
770
                b"333333\xc3?\x00\x00\x00\x00\x00J\x93\xc0",
771
                0.15000000596046448,
772
                -1234.5,
773
            )
774
        else:
775
            self.assert_unpack(
776
                "F", "F", 4, 2.387939260590663e-38, 6.301941157072183e-36
777
            )
778
            self.assert_unpack(
779
                "F", "F;32NF", 4, 2.387939260590663e-38, 6.301941157072183e-36
780
            )
781
            self.assert_unpack(
782
                "F",
783
                "F;64NF",
784
                b"?\xc3333333\xc0\x93J\x00\x00\x00\x00\x00",
785
                0.15000000596046448,
786
                -1234.5,
787
            )
788

789
    def test_I16(self) -> None:
790
        self.assert_unpack("I;16", "I;16", 2, 0x0201, 0x0403, 0x0605)
791
        self.assert_unpack("I;16", "I;16B", 2, 0x0102, 0x0304, 0x0506)
792
        self.assert_unpack("I;16B", "I;16B", 2, 0x0102, 0x0304, 0x0506)
793
        self.assert_unpack("I;16L", "I;16L", 2, 0x0201, 0x0403, 0x0605)
794
        self.assert_unpack("I;16", "I;12", 2, 0x0010, 0x0203, 0x0040)
795
        if sys.byteorder == "little":
796
            self.assert_unpack("I;16", "I;16N", 2, 0x0201, 0x0403, 0x0605)
797
            self.assert_unpack("I;16B", "I;16N", 2, 0x0201, 0x0403, 0x0605)
798
            self.assert_unpack("I;16L", "I;16N", 2, 0x0201, 0x0403, 0x0605)
799
            self.assert_unpack("I;16N", "I;16N", 2, 0x0201, 0x0403, 0x0605)
800
        else:
801
            self.assert_unpack("I;16", "I;16N", 2, 0x0102, 0x0304, 0x0506)
802
            self.assert_unpack("I;16B", "I;16N", 2, 0x0102, 0x0304, 0x0506)
803
            self.assert_unpack("I;16L", "I;16N", 2, 0x0102, 0x0304, 0x0506)
804
            self.assert_unpack("I;16N", "I;16N", 2, 0x0102, 0x0304, 0x0506)
805

806
    def test_CMYK16(self) -> None:
807
        self.assert_unpack("CMYK", "CMYK;16L", 8, (2, 4, 6, 8), (10, 12, 14, 16))
808
        self.assert_unpack("CMYK", "CMYK;16B", 8, (1, 3, 5, 7), (9, 11, 13, 15))
809
        if sys.byteorder == "little":
810
            self.assert_unpack("CMYK", "CMYK;16N", 8, (2, 4, 6, 8), (10, 12, 14, 16))
811
        else:
812
            self.assert_unpack("CMYK", "CMYK;16N", 8, (1, 3, 5, 7), (9, 11, 13, 15))
813

814
    def test_value_error(self) -> None:
815
        with pytest.raises(ValueError):
816
            self.assert_unpack("L", "L", 0, 0)
817
        with pytest.raises(ValueError):
818
            self.assert_unpack("RGB", "RGB", 2, 0)
819
        with pytest.raises(ValueError):
820
            self.assert_unpack("CMYK", "CMYK", 2, 0)
821