Debian Codegraph @

Lib/test/test_lzma.py

raw
1 import array
2 from io import BytesIO, UnsupportedOperation, DEFAULT_BUFFER_SIZE
3 import os
4 import pickle
5 import random
6 import sys
7 from test import support
8 import unittest
9 from compression._common import _streams
10
11 from test.support import _4G, bigmemtest
12 from test.support.import_helper import import_module
13 from test.support.os_helper import (
14 TESTFN, unlink, FakePath
15 )
16
17 lzma = import_module("lzma")
18 from lzma import LZMACompressor, LZMADecompressor, LZMAError, LZMAFile
19
20
21 class CompressorDecompressorTestCase(unittest.TestCase):
22
23 # Test error cases.
24
25 def test_simple_bad_args(self):
26 self.assertRaises(TypeError, LZMACompressor, [])
27 self.assertRaises(TypeError, LZMACompressor, format=3.45)
28 self.assertRaises(TypeError, LZMACompressor, check="")
29 self.assertRaises(TypeError, LZMACompressor, preset="asdf")
30 self.assertRaises(TypeError, LZMACompressor, filters=3)
31 # Can't specify FORMAT_AUTO when compressing.
32 self.assertRaises(ValueError, LZMACompressor, format=lzma.FORMAT_AUTO)
33 # Can't specify a preset and a custom filter chain at the same time.
34 with self.assertRaises(ValueError):
35 LZMACompressor(preset=7, filters=[{"id": lzma.FILTER_LZMA2}])
36
37 self.assertRaises(TypeError, LZMADecompressor, ())
38 self.assertRaises(TypeError, LZMADecompressor, memlimit=b"qw")
39 with self.assertRaises(TypeError):
40 LZMADecompressor(lzma.FORMAT_RAW, filters="zzz")
41 # Cannot specify a memory limit with FILTER_RAW.
42 with self.assertRaises(ValueError):
43 LZMADecompressor(lzma.FORMAT_RAW, memlimit=0x1000000)
44 # Can only specify a custom filter chain with FILTER_RAW.
45 self.assertRaises(ValueError, LZMADecompressor, filters=FILTERS_RAW_1)
46 with self.assertRaises(ValueError):
47 LZMADecompressor(format=lzma.FORMAT_XZ, filters=FILTERS_RAW_1)
48 with self.assertRaises(ValueError):
49 LZMADecompressor(format=lzma.FORMAT_ALONE, filters=FILTERS_RAW_1)
50
51 lzc = LZMACompressor()
52 self.assertRaises(TypeError, lzc.compress)
53 self.assertRaises(TypeError, lzc.compress, b"foo", b"bar")
54 self.assertRaises(TypeError, lzc.flush, b"blah")
55 empty = lzc.flush()
56 self.assertRaises(ValueError, lzc.compress, b"quux")
57 self.assertRaises(ValueError, lzc.flush)
58
59 lzd = LZMADecompressor()
60 self.assertRaises(TypeError, lzd.decompress)
61 self.assertRaises(TypeError, lzd.decompress, b"foo", b"bar")
62 lzd.decompress(empty)
63 self.assertRaises(EOFError, lzd.decompress, b"quux")
64
65 def test_bad_filter_spec(self):
66 self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
67 self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])
68 self.assertRaises(ValueError, LZMACompressor, filters=[{"id": 98765}])
69 with self.assertRaises(ValueError):
70 LZMACompressor(filters=[{"id": lzma.FILTER_LZMA2, "foo": 0}])
71 with self.assertRaises(ValueError):
72 LZMACompressor(filters=[{"id": lzma.FILTER_DELTA, "foo": 0}])
73 with self.assertRaises(ValueError):
74 LZMACompressor(filters=[{"id": lzma.FILTER_X86, "foo": 0}])
75
76 def test_decompressor_after_eof(self):
77 lzd = LZMADecompressor()
78 lzd.decompress(COMPRESSED_XZ)
79 self.assertRaises(EOFError, lzd.decompress, b"nyan")
80
81 def test_decompressor_memlimit(self):
82 lzd = LZMADecompressor(memlimit=1024)
83 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
84
85 lzd = LZMADecompressor(lzma.FORMAT_XZ, memlimit=1024)
86 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
87
88 lzd = LZMADecompressor(lzma.FORMAT_ALONE, memlimit=1024)
89 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_ALONE)
90
91 # Test LZMADecompressor on known-good input data.
92
93 def _test_decompressor(self, lzd, data, check, unused_data=b""):
94 self.assertFalse(lzd.eof)
95 out = lzd.decompress(data)
96 self.assertEqual(out, INPUT)
97 self.assertEqual(lzd.check, check)
98 self.assertTrue(lzd.eof)
99 self.assertEqual(lzd.unused_data, unused_data)
100
101 def test_decompressor_auto(self):
102 lzd = LZMADecompressor()
103 self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
104
105 lzd = LZMADecompressor()
106 self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
107
108 def test_decompressor_xz(self):
109 lzd = LZMADecompressor(lzma.FORMAT_XZ)
110 self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
111
112 def test_decompressor_alone(self):
113 lzd = LZMADecompressor(lzma.FORMAT_ALONE)
114 self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
115
116 def test_decompressor_raw_1(self):
117 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
118 self._test_decompressor(lzd, COMPRESSED_RAW_1, lzma.CHECK_NONE)
119
120 def test_decompressor_raw_2(self):
121 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
122 self._test_decompressor(lzd, COMPRESSED_RAW_2, lzma.CHECK_NONE)
123
124 def test_decompressor_raw_3(self):
125 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
126 self._test_decompressor(lzd, COMPRESSED_RAW_3, lzma.CHECK_NONE)
127
128 def test_decompressor_raw_4(self):
129 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
130 self._test_decompressor(lzd, COMPRESSED_RAW_4, lzma.CHECK_NONE)
131
132 def test_decompressor_chunks(self):
133 lzd = LZMADecompressor()
134 out = []
135 for i in range(0, len(COMPRESSED_XZ), 10):
136 self.assertFalse(lzd.eof)
137 out.append(lzd.decompress(COMPRESSED_XZ[i:i+10]))
138 out = b"".join(out)
139 self.assertEqual(out, INPUT)
140 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
141 self.assertTrue(lzd.eof)
142 self.assertEqual(lzd.unused_data, b"")
143
144 def test_decompressor_chunks_empty(self):
145 lzd = LZMADecompressor()
146 out = []
147 for i in range(0, len(COMPRESSED_XZ), 10):
148 self.assertFalse(lzd.eof)
149 out.append(lzd.decompress(b''))
150 out.append(lzd.decompress(b''))
151 out.append(lzd.decompress(b''))
152 out.append(lzd.decompress(COMPRESSED_XZ[i:i+10]))
153 out = b"".join(out)
154 self.assertEqual(out, INPUT)
155 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
156 self.assertTrue(lzd.eof)
157 self.assertEqual(lzd.unused_data, b"")
158
159 def test_decompressor_chunks_maxsize(self):
160 lzd = LZMADecompressor()
161 max_length = 100
162 out = []
163
164 # Feed first half the input
165 len_ = len(COMPRESSED_XZ) // 2
166 out.append(lzd.decompress(COMPRESSED_XZ[:len_],
167 max_length=max_length))
168 self.assertFalse(lzd.needs_input)
169 self.assertEqual(len(out[-1]), max_length)
170
171 # Retrieve more data without providing more input
172 out.append(lzd.decompress(b'', max_length=max_length))
173 self.assertFalse(lzd.needs_input)
174 self.assertEqual(len(out[-1]), max_length)
175
176 # Retrieve more data while providing more input
177 out.append(lzd.decompress(COMPRESSED_XZ[len_:],
178 max_length=max_length))
179 self.assertLessEqual(len(out[-1]), max_length)
180
181 # Retrieve remaining uncompressed data
182 while not lzd.eof:
183 out.append(lzd.decompress(b'', max_length=max_length))
184 self.assertLessEqual(len(out[-1]), max_length)
185
186 out = b"".join(out)
187 self.assertEqual(out, INPUT)
188 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
189 self.assertEqual(lzd.unused_data, b"")
190
191 def test_decompressor_inputbuf_1(self):
192 # Test reusing input buffer after moving existing
193 # contents to beginning
194 lzd = LZMADecompressor()
195 out = []
196
197 # Create input buffer and fill it
198 self.assertEqual(lzd.decompress(COMPRESSED_XZ[:100],
199 max_length=0), b'')
200
201 # Retrieve some results, freeing capacity at beginning
202 # of input buffer
203 out.append(lzd.decompress(b'', 2))
204
205 # Add more data that fits into input buffer after
206 # moving existing data to beginning
207 out.append(lzd.decompress(COMPRESSED_XZ[100:105], 15))
208
209 # Decompress rest of data
210 out.append(lzd.decompress(COMPRESSED_XZ[105:]))
211 self.assertEqual(b''.join(out), INPUT)
212
213 def test_decompressor_inputbuf_2(self):
214 # Test reusing input buffer by appending data at the
215 # end right away
216 lzd = LZMADecompressor()
217 out = []
218
219 # Create input buffer and empty it
220 self.assertEqual(lzd.decompress(COMPRESSED_XZ[:200],
221 max_length=0), b'')
222 out.append(lzd.decompress(b''))
223
224 # Fill buffer with new data
225 out.append(lzd.decompress(COMPRESSED_XZ[200:280], 2))
226
227 # Append some more data, not enough to require resize
228 out.append(lzd.decompress(COMPRESSED_XZ[280:300], 2))
229
230 # Decompress rest of data
231 out.append(lzd.decompress(COMPRESSED_XZ[300:]))
232 self.assertEqual(b''.join(out), INPUT)
233
234 def test_decompressor_inputbuf_3(self):
235 # Test reusing input buffer after extending it
236
237 lzd = LZMADecompressor()
238 out = []
239
240 # Create almost full input buffer
241 out.append(lzd.decompress(COMPRESSED_XZ[:200], 5))
242
243 # Add even more data to it, requiring resize
244 out.append(lzd.decompress(COMPRESSED_XZ[200:300], 5))
245
246 # Decompress rest of data
247 out.append(lzd.decompress(COMPRESSED_XZ[300:]))
248 self.assertEqual(b''.join(out), INPUT)
249
250 def test_decompressor_unused_data(self):
251 lzd = LZMADecompressor()
252 extra = b"fooblibar"
253 self._test_decompressor(lzd, COMPRESSED_XZ + extra, lzma.CHECK_CRC64,
254 unused_data=extra)
255
256 def test_decompressor_bad_input(self):
257 lzd = LZMADecompressor()
258 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
259
260 lzd = LZMADecompressor(lzma.FORMAT_XZ)
261 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_ALONE)
262
263 lzd = LZMADecompressor(lzma.FORMAT_ALONE)
264 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
265
266 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
267 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
268
269 def test_decompressor_bug_28275(self):
270 # Test coverage for Issue 28275
271 lzd = LZMADecompressor()
272 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
273 # Previously, a second call could crash due to internal inconsistency
274 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
275
276 # Test that LZMACompressor->LZMADecompressor preserves the input data.
277
278 def test_roundtrip_xz(self):
279 lzc = LZMACompressor()
280 cdata = lzc.compress(INPUT) + lzc.flush()
281 lzd = LZMADecompressor()
282 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
283
284 def test_roundtrip_alone(self):
285 lzc = LZMACompressor(lzma.FORMAT_ALONE)
286 cdata = lzc.compress(INPUT) + lzc.flush()
287 lzd = LZMADecompressor()
288 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
289
290 def test_roundtrip_raw(self):
291 lzc = LZMACompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
292 cdata = lzc.compress(INPUT) + lzc.flush()
293 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
294 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
295
296 def test_roundtrip_raw_empty(self):
297 lzc = LZMACompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
298 cdata = lzc.compress(INPUT)
299 cdata += lzc.compress(b'')
300 cdata += lzc.compress(b'')
301 cdata += lzc.compress(b'')
302 cdata += lzc.flush()
303 lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
304 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
305
306 def test_roundtrip_chunks(self):
307 lzc = LZMACompressor()
308 cdata = []
309 for i in range(0, len(INPUT), 10):
310 cdata.append(lzc.compress(INPUT[i:i+10]))
311 cdata.append(lzc.flush())
312 cdata = b"".join(cdata)
313 lzd = LZMADecompressor()
314 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
315
316 def test_roundtrip_empty_chunks(self):
317 lzc = LZMACompressor()
318 cdata = []
319 for i in range(0, len(INPUT), 10):
320 cdata.append(lzc.compress(INPUT[i:i+10]))
321 cdata.append(lzc.compress(b''))
322 cdata.append(lzc.compress(b''))
323 cdata.append(lzc.compress(b''))
324 cdata.append(lzc.flush())
325 cdata = b"".join(cdata)
326 lzd = LZMADecompressor()
327 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
328
329 # LZMADecompressor intentionally does not handle concatenated streams.
330
331 def test_decompressor_multistream(self):
332 lzd = LZMADecompressor()
333 self._test_decompressor(lzd, COMPRESSED_XZ + COMPRESSED_ALONE,
334 lzma.CHECK_CRC64, unused_data=COMPRESSED_ALONE)
335
336 # Test with inputs larger than 4GiB.
337
338 @support.skip_if_pgo_task
339 @bigmemtest(size=_4G + 100, memuse=2)
340 def test_compressor_bigmem(self, size):
341 lzc = LZMACompressor()
342 cdata = lzc.compress(b"x" * size) + lzc.flush()
343 ddata = lzma.decompress(cdata)
344 try:
345 self.assertEqual(len(ddata), size)
346 self.assertEqual(len(ddata.strip(b"x")), 0)
347 finally:
348 ddata = None
349
350 @support.skip_if_pgo_task
351 @bigmemtest(size=_4G + 100, memuse=3)
352 def test_decompressor_bigmem(self, size):
353 lzd = LZMADecompressor()
354 blocksize = min(10 * 1024 * 1024, size)
355 block = random.randbytes(blocksize)
356 try:
357 input = block * ((size-1) // blocksize + 1)
358 cdata = lzma.compress(input)
359 ddata = lzd.decompress(cdata)
360 self.assertEqual(ddata, input)
361 finally:
362 input = cdata = ddata = None
363
364 # Pickling raises an exception; there's no way to serialize an lzma_stream.
365
366 def test_pickle(self):
367 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
368 with self.assertRaises(TypeError):
369 pickle.dumps(LZMACompressor(), proto)
370 with self.assertRaises(TypeError):
371 pickle.dumps(LZMADecompressor(), proto)
372
373 @support.refcount_test
374 def test_refleaks_in_decompressor___init__(self):
375 gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount')
376 lzd = LZMADecompressor()
377 refs_before = gettotalrefcount()
378 for i in range(100):
379 lzd.__init__()
380 self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
381
382 def test_uninitialized_LZMADecompressor_crash(self):
383 self.assertEqual(LZMADecompressor.__new__(LZMADecompressor).
384 decompress(bytes()), b'')
385
386
387 class CompressDecompressFunctionTestCase(unittest.TestCase):
388
389 # Test error cases:
390
391 def test_bad_args(self):
392 self.assertRaises(TypeError, lzma.compress)
393 self.assertRaises(TypeError, lzma.compress, [])
394 self.assertRaises(TypeError, lzma.compress, b"", format="xz")
395 self.assertRaises(TypeError, lzma.compress, b"", check="none")
396 self.assertRaises(TypeError, lzma.compress, b"", preset="blah")
397 self.assertRaises(TypeError, lzma.compress, b"", filters=1024)
398 # Can't specify a preset and a custom filter chain at the same time.
399 with self.assertRaises(ValueError):
400 lzma.compress(b"", preset=3, filters=[{"id": lzma.FILTER_LZMA2}])
401
402 self.assertRaises(TypeError, lzma.decompress)
403 self.assertRaises(TypeError, lzma.decompress, [])
404 self.assertRaises(TypeError, lzma.decompress, b"", format="lzma")
405 self.assertRaises(TypeError, lzma.decompress, b"", memlimit=7.3e9)
406 with self.assertRaises(TypeError):
407 lzma.decompress(b"", format=lzma.FORMAT_RAW, filters={})
408 # Cannot specify a memory limit with FILTER_RAW.
409 with self.assertRaises(ValueError):
410 lzma.decompress(b"", format=lzma.FORMAT_RAW, memlimit=0x1000000)
411 # Can only specify a custom filter chain with FILTER_RAW.
412 with self.assertRaises(ValueError):
413 lzma.decompress(b"", filters=FILTERS_RAW_1)
414 with self.assertRaises(ValueError):
415 lzma.decompress(b"", format=lzma.FORMAT_XZ, filters=FILTERS_RAW_1)
416 with self.assertRaises(ValueError):
417 lzma.decompress(
418 b"", format=lzma.FORMAT_ALONE, filters=FILTERS_RAW_1)
419
420 def test_decompress_memlimit(self):
421 with self.assertRaises(LZMAError):
422 lzma.decompress(COMPRESSED_XZ, memlimit=1024)
423 with self.assertRaises(LZMAError):
424 lzma.decompress(
425 COMPRESSED_XZ, format=lzma.FORMAT_XZ, memlimit=1024)
426 with self.assertRaises(LZMAError):
427 lzma.decompress(
428 COMPRESSED_ALONE, format=lzma.FORMAT_ALONE, memlimit=1024)
429
430 # Test LZMADecompressor on known-good input data.
431
432 def test_decompress_good_input(self):
433 ddata = lzma.decompress(COMPRESSED_XZ)
434 self.assertEqual(ddata, INPUT)
435
436 ddata = lzma.decompress(COMPRESSED_ALONE)
437 self.assertEqual(ddata, INPUT)
438
439 ddata = lzma.decompress(COMPRESSED_XZ, lzma.FORMAT_XZ)
440 self.assertEqual(ddata, INPUT)
441
442 ddata = lzma.decompress(COMPRESSED_ALONE, lzma.FORMAT_ALONE)
443 self.assertEqual(ddata, INPUT)
444
445 ddata = lzma.decompress(
446 COMPRESSED_RAW_1, lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
447 self.assertEqual(ddata, INPUT)
448
449 ddata = lzma.decompress(
450 COMPRESSED_RAW_2, lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
451 self.assertEqual(ddata, INPUT)
452
453 ddata = lzma.decompress(
454 COMPRESSED_RAW_3, lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
455 self.assertEqual(ddata, INPUT)
456
457 ddata = lzma.decompress(
458 COMPRESSED_RAW_4, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
459 self.assertEqual(ddata, INPUT)
460
461 def test_decompress_incomplete_input(self):
462 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_XZ[:128])
463 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_ALONE[:128])
464 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_1[:128],
465 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
466 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_2[:128],
467 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
468 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_3[:128],
469 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
470 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_4[:128],
471 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
472
473 def test_decompress_bad_input(self):
474 with self.assertRaises(LZMAError):
475 lzma.decompress(COMPRESSED_BOGUS)
476 with self.assertRaises(LZMAError):
477 lzma.decompress(COMPRESSED_RAW_1)
478 with self.assertRaises(LZMAError):
479 lzma.decompress(COMPRESSED_ALONE, format=lzma.FORMAT_XZ)
480 with self.assertRaises(LZMAError):
481 lzma.decompress(COMPRESSED_XZ, format=lzma.FORMAT_ALONE)
482 with self.assertRaises(LZMAError):
483 lzma.decompress(COMPRESSED_XZ, format=lzma.FORMAT_RAW,
484 filters=FILTERS_RAW_1)
485
486 # Test that compress()->decompress() preserves the input data.
487
488 def test_roundtrip(self):
489 cdata = lzma.compress(INPUT)
490 ddata = lzma.decompress(cdata)
491 self.assertEqual(ddata, INPUT)
492
493 cdata = lzma.compress(INPUT, lzma.FORMAT_XZ)
494 ddata = lzma.decompress(cdata)
495 self.assertEqual(ddata, INPUT)
496
497 cdata = lzma.compress(INPUT, lzma.FORMAT_ALONE)
498 ddata = lzma.decompress(cdata)
499 self.assertEqual(ddata, INPUT)
500
501 cdata = lzma.compress(INPUT, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
502 ddata = lzma.decompress(cdata, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
503 self.assertEqual(ddata, INPUT)
504
505 # Unlike LZMADecompressor, decompress() *does* handle concatenated streams.
506
507 def test_decompress_multistream(self):
508 ddata = lzma.decompress(COMPRESSED_XZ + COMPRESSED_ALONE)
509 self.assertEqual(ddata, INPUT * 2)
510
511 # Test robust handling of non-LZMA data following the compressed stream(s).
512
513 def test_decompress_trailing_junk(self):
514 ddata = lzma.decompress(COMPRESSED_XZ + COMPRESSED_BOGUS)
515 self.assertEqual(ddata, INPUT)
516
517 def test_decompress_multistream_trailing_junk(self):
518 ddata = lzma.decompress(COMPRESSED_XZ * 3 + COMPRESSED_BOGUS)
519 self.assertEqual(ddata, INPUT * 3)
520
521
522 class TempFile:
523 """Context manager - creates a file, and deletes it on __exit__."""
524
525 def __init__(self, filename, data=b""):
526 self.filename = filename
527 self.data = data
528
529 def __enter__(self):
530 with open(self.filename, "wb") as f:
531 f.write(self.data)
532
533 def __exit__(self, *args):
534 unlink(self.filename)
535
536
537 class FileTestCase(unittest.TestCase):
538
539 def test_init(self):
540 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
541 self.assertIsInstance(f, LZMAFile)
542 self.assertEqual(f.mode, "rb")
543 with LZMAFile(BytesIO(), "w") as f:
544 self.assertIsInstance(f, LZMAFile)
545 self.assertEqual(f.mode, "wb")
546 with LZMAFile(BytesIO(), "x") as f:
547 self.assertIsInstance(f, LZMAFile)
548 self.assertEqual(f.mode, "wb")
549 with LZMAFile(BytesIO(), "a") as f:
550 self.assertIsInstance(f, LZMAFile)
551 self.assertEqual(f.mode, "wb")
552
553 def test_init_with_PathLike_filename(self):
554 filename = FakePath(TESTFN)
555 with TempFile(filename, COMPRESSED_XZ):
556 with LZMAFile(filename) as f:
557 self.assertEqual(f.read(), INPUT)
558 self.assertEqual(f.name, TESTFN)
559 with LZMAFile(filename, "a") as f:
560 f.write(INPUT)
561 self.assertEqual(f.name, TESTFN)
562 with LZMAFile(filename) as f:
563 self.assertEqual(f.read(), INPUT * 2)
564 self.assertEqual(f.name, TESTFN)
565
566 def test_init_with_filename(self):
567 with TempFile(TESTFN, COMPRESSED_XZ):
568 with LZMAFile(TESTFN) as f:
569 self.assertEqual(f.name, TESTFN)
570 self.assertEqual(f.mode, 'rb')
571 with LZMAFile(TESTFN, "w") as f:
572 self.assertEqual(f.name, TESTFN)
573 self.assertEqual(f.mode, 'wb')
574 with LZMAFile(TESTFN, "a") as f:
575 self.assertEqual(f.name, TESTFN)
576 self.assertEqual(f.mode, 'wb')
577
578 def test_init_mode(self):
579 with TempFile(TESTFN):
580 with LZMAFile(TESTFN, "r") as f:
581 self.assertIsInstance(f, LZMAFile)
582 self.assertEqual(f.mode, "rb")
583 with LZMAFile(TESTFN, "rb") as f:
584 self.assertIsInstance(f, LZMAFile)
585 self.assertEqual(f.mode, "rb")
586 with LZMAFile(TESTFN, "w") as f:
587 self.assertIsInstance(f, LZMAFile)
588 self.assertEqual(f.mode, "wb")
589 with LZMAFile(TESTFN, "wb") as f:
590 self.assertIsInstance(f, LZMAFile)
591 self.assertEqual(f.mode, "wb")
592 with LZMAFile(TESTFN, "a") as f:
593 self.assertIsInstance(f, LZMAFile)
594 self.assertEqual(f.mode, "wb")
595 with LZMAFile(TESTFN, "ab") as f:
596 self.assertIsInstance(f, LZMAFile)
597 self.assertEqual(f.mode, "wb")
598
599 def test_init_with_x_mode(self):
600 self.addCleanup(unlink, TESTFN)
601 for mode in ("x", "xb"):
602 unlink(TESTFN)
603 with LZMAFile(TESTFN, mode) as f:
604 self.assertIsInstance(f, LZMAFile)
605 self.assertEqual(f.mode, 'wb')
606 with self.assertRaises(FileExistsError):
607 LZMAFile(TESTFN, mode)
608
609 def test_init_bad_mode(self):
610 with self.assertRaises(ValueError):
611 LZMAFile(BytesIO(COMPRESSED_XZ), (3, "x"))
612 with self.assertRaises(ValueError):
613 LZMAFile(BytesIO(COMPRESSED_XZ), "")
614 with self.assertRaises(ValueError):
615 LZMAFile(BytesIO(COMPRESSED_XZ), "xt")
616 with self.assertRaises(ValueError):
617 LZMAFile(BytesIO(COMPRESSED_XZ), "x+")
618 with self.assertRaises(ValueError):
619 LZMAFile(BytesIO(COMPRESSED_XZ), "rx")
620 with self.assertRaises(ValueError):
621 LZMAFile(BytesIO(COMPRESSED_XZ), "wx")
622 with self.assertRaises(ValueError):
623 LZMAFile(BytesIO(COMPRESSED_XZ), "rt")
624 with self.assertRaises(ValueError):
625 LZMAFile(BytesIO(COMPRESSED_XZ), "r+")
626 with self.assertRaises(ValueError):
627 LZMAFile(BytesIO(COMPRESSED_XZ), "wt")
628 with self.assertRaises(ValueError):
629 LZMAFile(BytesIO(COMPRESSED_XZ), "w+")
630 with self.assertRaises(ValueError):
631 LZMAFile(BytesIO(COMPRESSED_XZ), "rw")
632
633 def test_init_bad_check(self):
634 with self.assertRaises(TypeError):
635 LZMAFile(BytesIO(), "w", check=b"asd")
636 # CHECK_UNKNOWN and anything above CHECK_ID_MAX should be invalid.
637 with self.assertRaises(LZMAError):
638 LZMAFile(BytesIO(), "w", check=lzma.CHECK_UNKNOWN)
639 with self.assertRaises(LZMAError):
640 LZMAFile(BytesIO(), "w", check=lzma.CHECK_ID_MAX + 3)
641 # Cannot specify a check with mode="r".
642 with self.assertRaises(ValueError):
643 LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_NONE)
644 with self.assertRaises(ValueError):
645 LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_CRC32)
646 with self.assertRaises(ValueError):
647 LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_CRC64)
648 with self.assertRaises(ValueError):
649 LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_SHA256)
650 with self.assertRaises(ValueError):
651 LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_UNKNOWN)
652
653 def test_init_bad_preset(self):
654 with self.assertRaises(TypeError):
655 LZMAFile(BytesIO(), "w", preset=4.39)
656 with self.assertRaises(LZMAError):
657 LZMAFile(BytesIO(), "w", preset=10)
658 with self.assertRaises(LZMAError):
659 LZMAFile(BytesIO(), "w", preset=23)
660 with self.assertRaises(ValueError):
661 LZMAFile(BytesIO(), "w", preset=-1)
662 with self.assertRaises(ValueError):
663 LZMAFile(BytesIO(), "w", preset=-7)
664 with self.assertRaises(OverflowError):
665 LZMAFile(BytesIO(), "w", preset=2**1000)
666 with self.assertRaises(TypeError):
667 LZMAFile(BytesIO(), "w", preset="foo")
668 # Cannot specify a preset with mode="r".
669 with self.assertRaises(ValueError):
670 LZMAFile(BytesIO(COMPRESSED_XZ), preset=3)
671
672 def test_init_bad_filter_spec(self):
673 with self.assertRaises(TypeError):
674 LZMAFile(BytesIO(), "w", filters=[b"wobsite"])
675 with self.assertRaises(ValueError):
676 LZMAFile(BytesIO(), "w", filters=[{"xyzzy": 3}])
677 with self.assertRaises(ValueError):
678 LZMAFile(BytesIO(), "w", filters=[{"id": 98765}])
679 with self.assertRaises(ValueError):
680 LZMAFile(BytesIO(), "w",
681 filters=[{"id": lzma.FILTER_LZMA2, "foo": 0}])
682 with self.assertRaises(ValueError):
683 LZMAFile(BytesIO(), "w",
684 filters=[{"id": lzma.FILTER_DELTA, "foo": 0}])
685 with self.assertRaises(ValueError):
686 LZMAFile(BytesIO(), "w",
687 filters=[{"id": lzma.FILTER_X86, "foo": 0}])
688
689 def test_init_with_preset_and_filters(self):
690 with self.assertRaises(ValueError):
691 LZMAFile(BytesIO(), "w", format=lzma.FORMAT_RAW,
692 preset=6, filters=FILTERS_RAW_1)
693
694 def test_close(self):
695 with BytesIO(COMPRESSED_XZ) as src:
696 f = LZMAFile(src)
697 f.close()
698 # LZMAFile.close() should not close the underlying file object.
699 self.assertFalse(src.closed)
700 # Try closing an already-closed LZMAFile.
701 f.close()
702 self.assertFalse(src.closed)
703
704 # Test with a real file on disk, opened directly by LZMAFile.
705 with TempFile(TESTFN, COMPRESSED_XZ):
706 f = LZMAFile(TESTFN)
707 fp = f._fp
708 f.close()
709 # Here, LZMAFile.close() *should* close the underlying file object.
710 self.assertTrue(fp.closed)
711 # Try closing an already-closed LZMAFile.
712 f.close()
713
714 def test_closed(self):
715 f = LZMAFile(BytesIO(COMPRESSED_XZ))
716 try:
717 self.assertFalse(f.closed)
718 f.read()
719 self.assertFalse(f.closed)
720 finally:
721 f.close()
722 self.assertTrue(f.closed)
723
724 f = LZMAFile(BytesIO(), "w")
725 try:
726 self.assertFalse(f.closed)
727 finally:
728 f.close()
729 self.assertTrue(f.closed)
730
731 def test_fileno(self):
732 f = LZMAFile(BytesIO(COMPRESSED_XZ))
733 try:
734 self.assertRaises(UnsupportedOperation, f.fileno)
735 finally:
736 f.close()
737 self.assertRaises(ValueError, f.fileno)
738 with TempFile(TESTFN, COMPRESSED_XZ):
739 f = LZMAFile(TESTFN)
740 try:
741 self.assertEqual(f.fileno(), f._fp.fileno())
742 self.assertIsInstance(f.fileno(), int)
743 finally:
744 f.close()
745 self.assertRaises(ValueError, f.fileno)
746
747 def test_seekable(self):
748 f = LZMAFile(BytesIO(COMPRESSED_XZ))
749 try:
750 self.assertTrue(f.seekable())
751 f.read()
752 self.assertTrue(f.seekable())
753 finally:
754 f.close()
755 self.assertRaises(ValueError, f.seekable)
756
757 f = LZMAFile(BytesIO(), "w")
758 try:
759 self.assertFalse(f.seekable())
760 finally:
761 f.close()
762 self.assertRaises(ValueError, f.seekable)
763
764 src = BytesIO(COMPRESSED_XZ)
765 src.seekable = lambda: False
766 f = LZMAFile(src)
767 try:
768 self.assertFalse(f.seekable())
769 finally:
770 f.close()
771 self.assertRaises(ValueError, f.seekable)
772
773 def test_readable(self):
774 f = LZMAFile(BytesIO(COMPRESSED_XZ))
775 try:
776 self.assertTrue(f.readable())
777 f.read()
778 self.assertTrue(f.readable())
779 finally:
780 f.close()
781 self.assertRaises(ValueError, f.readable)
782
783 f = LZMAFile(BytesIO(), "w")
784 try:
785 self.assertFalse(f.readable())
786 finally:
787 f.close()
788 self.assertRaises(ValueError, f.readable)
789
790 def test_writable(self):
791 f = LZMAFile(BytesIO(COMPRESSED_XZ))
792 try:
793 self.assertFalse(f.writable())
794 f.read()
795 self.assertFalse(f.writable())
796 finally:
797 f.close()
798 self.assertRaises(ValueError, f.writable)
799
800 f = LZMAFile(BytesIO(), "w")
801 try:
802 self.assertTrue(f.writable())
803 finally:
804 f.close()
805 self.assertRaises(ValueError, f.writable)
806
807 def test_read(self):
808 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
809 self.assertEqual(f.read(), INPUT)
810 self.assertEqual(f.read(), b"")
811 with LZMAFile(BytesIO(COMPRESSED_ALONE)) as f:
812 self.assertEqual(f.read(), INPUT)
813 with LZMAFile(BytesIO(COMPRESSED_XZ), format=lzma.FORMAT_XZ) as f:
814 self.assertEqual(f.read(), INPUT)
815 self.assertEqual(f.read(), b"")
816 with LZMAFile(BytesIO(COMPRESSED_ALONE), format=lzma.FORMAT_ALONE) as f:
817 self.assertEqual(f.read(), INPUT)
818 self.assertEqual(f.read(), b"")
819 with LZMAFile(BytesIO(COMPRESSED_RAW_1),
820 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_1) as f:
821 self.assertEqual(f.read(), INPUT)
822 self.assertEqual(f.read(), b"")
823 with LZMAFile(BytesIO(COMPRESSED_RAW_2),
824 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_2) as f:
825 self.assertEqual(f.read(), INPUT)
826 self.assertEqual(f.read(), b"")
827 with LZMAFile(BytesIO(COMPRESSED_RAW_3),
828 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_3) as f:
829 self.assertEqual(f.read(), INPUT)
830 self.assertEqual(f.read(), b"")
831 with LZMAFile(BytesIO(COMPRESSED_RAW_4),
832 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_4) as f:
833 self.assertEqual(f.read(), INPUT)
834 self.assertEqual(f.read(), b"")
835
836 def test_read_0(self):
837 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
838 self.assertEqual(f.read(0), b"")
839 with LZMAFile(BytesIO(COMPRESSED_ALONE)) as f:
840 self.assertEqual(f.read(0), b"")
841 with LZMAFile(BytesIO(COMPRESSED_XZ), format=lzma.FORMAT_XZ) as f:
842 self.assertEqual(f.read(0), b"")
843 with LZMAFile(BytesIO(COMPRESSED_ALONE), format=lzma.FORMAT_ALONE) as f:
844 self.assertEqual(f.read(0), b"")
845
846 def test_read_10(self):
847 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
848 chunks = []
849 while result := f.read(10):
850 self.assertLessEqual(len(result), 10)
851 chunks.append(result)
852 self.assertEqual(b"".join(chunks), INPUT)
853
854 def test_read_multistream(self):
855 with LZMAFile(BytesIO(COMPRESSED_XZ * 5)) as f:
856 self.assertEqual(f.read(), INPUT * 5)
857 with LZMAFile(BytesIO(COMPRESSED_XZ + COMPRESSED_ALONE)) as f:
858 self.assertEqual(f.read(), INPUT * 2)
859 with LZMAFile(BytesIO(COMPRESSED_RAW_3 * 4),
860 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_3) as f:
861 self.assertEqual(f.read(), INPUT * 4)
862
863 def test_read_multistream_buffer_size_aligned(self):
864 # Test the case where a stream boundary coincides with the end
865 # of the raw read buffer.
866 saved_buffer_size = _streams.BUFFER_SIZE
867 _streams.BUFFER_SIZE = len(COMPRESSED_XZ)
868 try:
869 with LZMAFile(BytesIO(COMPRESSED_XZ * 5)) as f:
870 self.assertEqual(f.read(), INPUT * 5)
871 finally:
872 _streams.BUFFER_SIZE = saved_buffer_size
873
874 def test_read_trailing_junk(self):
875 with LZMAFile(BytesIO(COMPRESSED_XZ + COMPRESSED_BOGUS)) as f:
876 self.assertEqual(f.read(), INPUT)
877
878 def test_read_multistream_trailing_junk(self):
879 with LZMAFile(BytesIO(COMPRESSED_XZ * 5 + COMPRESSED_BOGUS)) as f:
880 self.assertEqual(f.read(), INPUT * 5)
881
882 def test_read_from_file(self):
883 with TempFile(TESTFN, COMPRESSED_XZ):
884 with LZMAFile(TESTFN) as f:
885 self.assertEqual(f.read(), INPUT)
886 self.assertEqual(f.read(), b"")
887 self.assertEqual(f.name, TESTFN)
888 self.assertIsInstance(f.fileno(), int)
889 self.assertEqual(f.mode, 'rb')
890 self.assertIs(f.readable(), True)
891 self.assertIs(f.writable(), False)
892 self.assertIs(f.seekable(), True)
893 self.assertIs(f.closed, False)
894 self.assertIs(f.closed, True)
895 with self.assertRaises(ValueError):
896 f.name
897 self.assertRaises(ValueError, f.fileno)
898 self.assertEqual(f.mode, 'rb')
899 self.assertRaises(ValueError, f.readable)
900 self.assertRaises(ValueError, f.writable)
901 self.assertRaises(ValueError, f.seekable)
902
903 def test_read_from_file_with_bytes_filename(self):
904 bytes_filename = os.fsencode(TESTFN)
905 with TempFile(TESTFN, COMPRESSED_XZ):
906 with LZMAFile(bytes_filename) as f:
907 self.assertEqual(f.read(), INPUT)
908 self.assertEqual(f.read(), b"")
909 self.assertEqual(f.name, bytes_filename)
910
911 def test_read_from_fileobj(self):
912 with TempFile(TESTFN, COMPRESSED_XZ):
913 with open(TESTFN, 'rb') as raw:
914 with LZMAFile(raw) as f:
915 self.assertEqual(f.read(), INPUT)
916 self.assertEqual(f.read(), b"")
917 self.assertEqual(f.name, raw.name)
918 self.assertEqual(f.fileno(), raw.fileno())
919 self.assertEqual(f.mode, 'rb')
920 self.assertIs(f.readable(), True)
921 self.assertIs(f.writable(), False)
922 self.assertIs(f.seekable(), True)
923 self.assertIs(f.closed, False)
924 self.assertIs(f.closed, True)
925 with self.assertRaises(ValueError):
926 f.name
927 self.assertRaises(ValueError, f.fileno)
928 self.assertEqual(f.mode, 'rb')
929 self.assertRaises(ValueError, f.readable)
930 self.assertRaises(ValueError, f.writable)
931 self.assertRaises(ValueError, f.seekable)
932
933 def test_read_from_fileobj_with_int_name(self):
934 with TempFile(TESTFN, COMPRESSED_XZ):
935 fd = os.open(TESTFN, os.O_RDONLY)
936 with open(fd, 'rb') as raw:
937 with LZMAFile(raw) as f:
938 self.assertEqual(f.read(), INPUT)
939 self.assertEqual(f.read(), b"")
940 self.assertEqual(f.name, raw.name)
941 self.assertEqual(f.fileno(), raw.fileno())
942 self.assertEqual(f.mode, 'rb')
943 self.assertIs(f.readable(), True)
944 self.assertIs(f.writable(), False)
945 self.assertIs(f.seekable(), True)
946 self.assertIs(f.closed, False)
947 self.assertIs(f.closed, True)
948 with self.assertRaises(ValueError):
949 f.name
950 self.assertRaises(ValueError, f.fileno)
951 self.assertEqual(f.mode, 'rb')
952 self.assertRaises(ValueError, f.readable)
953 self.assertRaises(ValueError, f.writable)
954 self.assertRaises(ValueError, f.seekable)
955
956 def test_read_incomplete(self):
957 with LZMAFile(BytesIO(COMPRESSED_XZ[:128])) as f:
958 self.assertRaises(EOFError, f.read)
959
960 def test_read_truncated(self):
961 # Drop stream footer: CRC (4 bytes), index size (4 bytes),
962 # flags (2 bytes) and magic number (2 bytes).
963 truncated = COMPRESSED_XZ[:-12]
964 with LZMAFile(BytesIO(truncated)) as f:
965 self.assertRaises(EOFError, f.read)
966 with LZMAFile(BytesIO(truncated)) as f:
967 self.assertEqual(f.read(len(INPUT)), INPUT)
968 self.assertRaises(EOFError, f.read, 1)
969 # Incomplete 12-byte header.
970 for i in range(12):
971 with LZMAFile(BytesIO(truncated[:i])) as f:
972 self.assertRaises(EOFError, f.read, 1)
973
974 def test_read_bad_args(self):
975 f = LZMAFile(BytesIO(COMPRESSED_XZ))
976 f.close()
977 self.assertRaises(ValueError, f.read)
978 with LZMAFile(BytesIO(), "w") as f:
979 self.assertRaises(ValueError, f.read)
980 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
981 self.assertRaises(TypeError, f.read, float())
982
983 def test_read_bad_data(self):
984 with LZMAFile(BytesIO(COMPRESSED_BOGUS)) as f:
985 self.assertRaises(LZMAError, f.read)
986
987 def test_read1(self):
988 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
989 blocks = []
990 while result := f.read1():
991 blocks.append(result)
992 self.assertEqual(b"".join(blocks), INPUT)
993 self.assertEqual(f.read1(), b"")
994
995 def test_read1_0(self):
996 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
997 self.assertEqual(f.read1(0), b"")
998
999 def test_read1_10(self):
1000 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1001 blocks = []
1002 while result := f.read1(10):
1003 blocks.append(result)
1004 self.assertEqual(b"".join(blocks), INPUT)
1005 self.assertEqual(f.read1(), b"")
1006
1007 def test_read1_multistream(self):
1008 with LZMAFile(BytesIO(COMPRESSED_XZ * 5)) as f:
1009 blocks = []
1010 while result := f.read1():
1011 blocks.append(result)
1012 self.assertEqual(b"".join(blocks), INPUT * 5)
1013 self.assertEqual(f.read1(), b"")
1014
1015 def test_read1_bad_args(self):
1016 f = LZMAFile(BytesIO(COMPRESSED_XZ))
1017 f.close()
1018 self.assertRaises(ValueError, f.read1)
1019 with LZMAFile(BytesIO(), "w") as f:
1020 self.assertRaises(ValueError, f.read1)
1021 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1022 self.assertRaises(TypeError, f.read1, None)
1023
1024 def test_peek(self):
1025 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1026 result = f.peek()
1027 self.assertGreater(len(result), 0)
1028 self.assertStartsWith(INPUT, result)
1029 self.assertEqual(f.read(), INPUT)
1030 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1031 result = f.peek(10)
1032 self.assertGreater(len(result), 0)
1033 self.assertStartsWith(INPUT, result)
1034 self.assertEqual(f.read(), INPUT)
1035
1036 def test_peek_bad_args(self):
1037 with LZMAFile(BytesIO(), "w") as f:
1038 self.assertRaises(ValueError, f.peek)
1039
1040 def test_iterator(self):
1041 with BytesIO(INPUT) as f:
1042 lines = f.readlines()
1043 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1044 self.assertListEqual(list(iter(f)), lines)
1045 with LZMAFile(BytesIO(COMPRESSED_ALONE)) as f:
1046 self.assertListEqual(list(iter(f)), lines)
1047 with LZMAFile(BytesIO(COMPRESSED_XZ), format=lzma.FORMAT_XZ) as f:
1048 self.assertListEqual(list(iter(f)), lines)
1049 with LZMAFile(BytesIO(COMPRESSED_ALONE), format=lzma.FORMAT_ALONE) as f:
1050 self.assertListEqual(list(iter(f)), lines)
1051 with LZMAFile(BytesIO(COMPRESSED_RAW_2),
1052 format=lzma.FORMAT_RAW, filters=FILTERS_RAW_2) as f:
1053 self.assertListEqual(list(iter(f)), lines)
1054
1055 def test_readline(self):
1056 with BytesIO(INPUT) as f:
1057 lines = f.readlines()
1058 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1059 for line in lines:
1060 self.assertEqual(f.readline(), line)
1061
1062 def test_readlines(self):
1063 with BytesIO(INPUT) as f:
1064 lines = f.readlines()
1065 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1066 self.assertListEqual(f.readlines(), lines)
1067
1068 def test_decompress_limited(self):
1069 """Decompressed data buffering should be limited"""
1070 bomb = lzma.compress(b'\0' * int(2e6), preset=6)
1071 self.assertLess(len(bomb), _streams.BUFFER_SIZE)
1072
1073 decomp = LZMAFile(BytesIO(bomb))
1074 self.assertEqual(decomp.read(1), b'\0')
1075 max_decomp = 1 + DEFAULT_BUFFER_SIZE
1076 self.assertLessEqual(decomp._buffer.raw.tell(), max_decomp,
1077 "Excessive amount of data was decompressed")
1078
1079 def test_write(self):
1080 with BytesIO() as dst:
1081 with LZMAFile(dst, "w") as f:
1082 f.write(INPUT)
1083 with self.assertRaises(AttributeError):
1084 f.name
1085 expected = lzma.compress(INPUT)
1086 self.assertEqual(dst.getvalue(), expected)
1087 with BytesIO() as dst:
1088 with LZMAFile(dst, "w", format=lzma.FORMAT_XZ) as f:
1089 f.write(INPUT)
1090 expected = lzma.compress(INPUT, format=lzma.FORMAT_XZ)
1091 self.assertEqual(dst.getvalue(), expected)
1092 with BytesIO() as dst:
1093 with LZMAFile(dst, "w", format=lzma.FORMAT_ALONE) as f:
1094 f.write(INPUT)
1095 expected = lzma.compress(INPUT, format=lzma.FORMAT_ALONE)
1096 self.assertEqual(dst.getvalue(), expected)
1097 with BytesIO() as dst:
1098 with LZMAFile(dst, "w", format=lzma.FORMAT_RAW,
1099 filters=FILTERS_RAW_2) as f:
1100 f.write(INPUT)
1101 expected = lzma.compress(INPUT, format=lzma.FORMAT_RAW,
1102 filters=FILTERS_RAW_2)
1103 self.assertEqual(dst.getvalue(), expected)
1104
1105 def test_write_10(self):
1106 with BytesIO() as dst:
1107 with LZMAFile(dst, "w") as f:
1108 for start in range(0, len(INPUT), 10):
1109 f.write(INPUT[start:start+10])
1110 expected = lzma.compress(INPUT)
1111 self.assertEqual(dst.getvalue(), expected)
1112
1113 def test_write_append(self):
1114 part1 = INPUT[:1024]
1115 part2 = INPUT[1024:1536]
1116 part3 = INPUT[1536:]
1117 expected = b"".join(lzma.compress(x) for x in (part1, part2, part3))
1118 with BytesIO() as dst:
1119 with LZMAFile(dst, "w") as f:
1120 f.write(part1)
1121 self.assertEqual(f.mode, 'wb')
1122 with LZMAFile(dst, "a") as f:
1123 f.write(part2)
1124 self.assertEqual(f.mode, 'wb')
1125 with LZMAFile(dst, "a") as f:
1126 f.write(part3)
1127 self.assertEqual(f.mode, 'wb')
1128 self.assertEqual(dst.getvalue(), expected)
1129
1130 def test_write_to_file(self):
1131 try:
1132 with LZMAFile(TESTFN, "w") as f:
1133 f.write(INPUT)
1134 self.assertEqual(f.name, TESTFN)
1135 self.assertIsInstance(f.fileno(), int)
1136 self.assertEqual(f.mode, 'wb')
1137 self.assertIs(f.readable(), False)
1138 self.assertIs(f.writable(), True)
1139 self.assertIs(f.seekable(), False)
1140 self.assertIs(f.closed, False)
1141 self.assertIs(f.closed, True)
1142 with self.assertRaises(ValueError):
1143 f.name
1144 self.assertRaises(ValueError, f.fileno)
1145 self.assertEqual(f.mode, 'wb')
1146 self.assertRaises(ValueError, f.readable)
1147 self.assertRaises(ValueError, f.writable)
1148 self.assertRaises(ValueError, f.seekable)
1149
1150 expected = lzma.compress(INPUT)
1151 with open(TESTFN, "rb") as f:
1152 self.assertEqual(f.read(), expected)
1153 finally:
1154 unlink(TESTFN)
1155
1156 def test_write_to_file_with_bytes_filename(self):
1157 bytes_filename = os.fsencode(TESTFN)
1158 try:
1159 with LZMAFile(bytes_filename, "w") as f:
1160 f.write(INPUT)
1161 self.assertEqual(f.name, bytes_filename)
1162 expected = lzma.compress(INPUT)
1163 with open(TESTFN, "rb") as f:
1164 self.assertEqual(f.read(), expected)
1165 finally:
1166 unlink(TESTFN)
1167
1168 def test_write_to_fileobj(self):
1169 try:
1170 with open(TESTFN, "wb") as raw:
1171 with LZMAFile(raw, "w") as f:
1172 f.write(INPUT)
1173 self.assertEqual(f.name, raw.name)
1174 self.assertEqual(f.fileno(), raw.fileno())
1175 self.assertEqual(f.mode, 'wb')
1176 self.assertIs(f.readable(), False)
1177 self.assertIs(f.writable(), True)
1178 self.assertIs(f.seekable(), False)
1179 self.assertIs(f.closed, False)
1180 self.assertIs(f.closed, True)
1181 with self.assertRaises(ValueError):
1182 f.name
1183 self.assertRaises(ValueError, f.fileno)
1184 self.assertEqual(f.mode, 'wb')
1185 self.assertRaises(ValueError, f.readable)
1186 self.assertRaises(ValueError, f.writable)
1187 self.assertRaises(ValueError, f.seekable)
1188
1189 expected = lzma.compress(INPUT)
1190 with open(TESTFN, "rb") as f:
1191 self.assertEqual(f.read(), expected)
1192 finally:
1193 unlink(TESTFN)
1194
1195 def test_write_to_fileobj_with_int_name(self):
1196 try:
1197 fd = os.open(TESTFN, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
1198 with open(fd, 'wb') as raw:
1199 with LZMAFile(raw, "w") as f:
1200 f.write(INPUT)
1201 self.assertEqual(f.name, raw.name)
1202 self.assertEqual(f.fileno(), raw.fileno())
1203 self.assertEqual(f.mode, 'wb')
1204 self.assertIs(f.readable(), False)
1205 self.assertIs(f.writable(), True)
1206 self.assertIs(f.seekable(), False)
1207 self.assertIs(f.closed, False)
1208 self.assertIs(f.closed, True)
1209 with self.assertRaises(ValueError):
1210 f.name
1211 self.assertRaises(ValueError, f.fileno)
1212 self.assertEqual(f.mode, 'wb')
1213 self.assertRaises(ValueError, f.readable)
1214 self.assertRaises(ValueError, f.writable)
1215 self.assertRaises(ValueError, f.seekable)
1216
1217 expected = lzma.compress(INPUT)
1218 with open(TESTFN, "rb") as f:
1219 self.assertEqual(f.read(), expected)
1220 finally:
1221 unlink(TESTFN)
1222
1223 def test_write_append_to_file(self):
1224 part1 = INPUT[:1024]
1225 part2 = INPUT[1024:1536]
1226 part3 = INPUT[1536:]
1227 expected = b"".join(lzma.compress(x) for x in (part1, part2, part3))
1228 try:
1229 with LZMAFile(TESTFN, "w") as f:
1230 f.write(part1)
1231 self.assertEqual(f.mode, 'wb')
1232 with LZMAFile(TESTFN, "a") as f:
1233 f.write(part2)
1234 self.assertEqual(f.mode, 'wb')
1235 with LZMAFile(TESTFN, "a") as f:
1236 f.write(part3)
1237 self.assertEqual(f.mode, 'wb')
1238 with open(TESTFN, "rb") as f:
1239 self.assertEqual(f.read(), expected)
1240 finally:
1241 unlink(TESTFN)
1242
1243 def test_write_bad_args(self):
1244 f = LZMAFile(BytesIO(), "w")
1245 f.close()
1246 self.assertRaises(ValueError, f.write, b"foo")
1247 with LZMAFile(BytesIO(COMPRESSED_XZ), "r") as f:
1248 self.assertRaises(ValueError, f.write, b"bar")
1249 with LZMAFile(BytesIO(), "w") as f:
1250 self.assertRaises(TypeError, f.write, None)
1251 self.assertRaises(TypeError, f.write, "text")
1252 self.assertRaises(TypeError, f.write, 789)
1253
1254 def test_writelines(self):
1255 with BytesIO(INPUT) as f:
1256 lines = f.readlines()
1257 with BytesIO() as dst:
1258 with LZMAFile(dst, "w") as f:
1259 f.writelines(lines)
1260 expected = lzma.compress(INPUT)
1261 self.assertEqual(dst.getvalue(), expected)
1262
1263 def test_seek_forward(self):
1264 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1265 f.seek(555)
1266 self.assertEqual(f.read(), INPUT[555:])
1267
1268 def test_seek_forward_across_streams(self):
1269 with LZMAFile(BytesIO(COMPRESSED_XZ * 2)) as f:
1270 f.seek(len(INPUT) + 123)
1271 self.assertEqual(f.read(), INPUT[123:])
1272
1273 def test_seek_forward_relative_to_current(self):
1274 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1275 f.read(100)
1276 f.seek(1236, 1)
1277 self.assertEqual(f.read(), INPUT[1336:])
1278
1279 def test_seek_forward_relative_to_end(self):
1280 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1281 f.seek(-555, 2)
1282 self.assertEqual(f.read(), INPUT[-555:])
1283
1284 def test_seek_backward(self):
1285 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1286 f.read(1001)
1287 f.seek(211)
1288 self.assertEqual(f.read(), INPUT[211:])
1289
1290 def test_seek_backward_across_streams(self):
1291 with LZMAFile(BytesIO(COMPRESSED_XZ * 2)) as f:
1292 f.read(len(INPUT) + 333)
1293 f.seek(737)
1294 self.assertEqual(f.read(), INPUT[737:] + INPUT)
1295
1296 def test_seek_backward_relative_to_end(self):
1297 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1298 f.seek(-150, 2)
1299 self.assertEqual(f.read(), INPUT[-150:])
1300
1301 def test_seek_past_end(self):
1302 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1303 f.seek(len(INPUT) + 9001)
1304 self.assertEqual(f.tell(), len(INPUT))
1305 self.assertEqual(f.read(), b"")
1306
1307 def test_seek_past_start(self):
1308 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1309 f.seek(-88)
1310 self.assertEqual(f.tell(), 0)
1311 self.assertEqual(f.read(), INPUT)
1312
1313 def test_seek_bad_args(self):
1314 f = LZMAFile(BytesIO(COMPRESSED_XZ))
1315 f.close()
1316 self.assertRaises(ValueError, f.seek, 0)
1317 with LZMAFile(BytesIO(), "w") as f:
1318 self.assertRaises(ValueError, f.seek, 0)
1319 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1320 self.assertRaises(ValueError, f.seek, 0, 3)
1321 # io.BufferedReader raises TypeError instead of ValueError
1322 self.assertRaises((TypeError, ValueError), f.seek, 9, ())
1323 self.assertRaises(TypeError, f.seek, None)
1324 self.assertRaises(TypeError, f.seek, b"derp")
1325
1326 def test_tell(self):
1327 with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
1328 pos = 0
1329 while True:
1330 self.assertEqual(f.tell(), pos)
1331 result = f.read(183)
1332 if not result:
1333 break
1334 pos += len(result)
1335 self.assertEqual(f.tell(), len(INPUT))
1336 with LZMAFile(BytesIO(), "w") as f:
1337 for pos in range(0, len(INPUT), 144):
1338 self.assertEqual(f.tell(), pos)
1339 f.write(INPUT[pos:pos+144])
1340 self.assertEqual(f.tell(), len(INPUT))
1341
1342 def test_tell_bad_args(self):
1343 f = LZMAFile(BytesIO(COMPRESSED_XZ))
1344 f.close()
1345 self.assertRaises(ValueError, f.tell)
1346
1347 def test_issue21872(self):
1348 # sometimes decompress data incompletely
1349
1350 # ---------------------
1351 # when max_length == -1
1352 # ---------------------
1353 d1 = LZMADecompressor()
1354 entire = d1.decompress(ISSUE_21872_DAT, max_length=-1)
1355 self.assertEqual(len(entire), 13160)
1356 self.assertTrue(d1.eof)
1357
1358 # ---------------------
1359 # when max_length > 0
1360 # ---------------------
1361 d2 = LZMADecompressor()
1362
1363 # When this value of max_length is used, the input and output
1364 # buffers are exhausted at the same time, and lzs's internal
1365 # state still have 11 bytes can be output.
1366 out1 = d2.decompress(ISSUE_21872_DAT, max_length=13149)
1367 self.assertFalse(d2.needs_input) # ensure needs_input mechanism works
1368 self.assertFalse(d2.eof)
1369
1370 # simulate needs_input mechanism
1371 # output internal state's 11 bytes
1372 out2 = d2.decompress(b'')
1373 self.assertEqual(len(out2), 11)
1374 self.assertTrue(d2.eof)
1375 self.assertEqual(out1 + out2, entire)
1376
1377 def test_issue44439(self):
1378 q = array.array('Q', [1, 2, 3, 4, 5])
1379 LENGTH = len(q) * q.itemsize
1380
1381 with LZMAFile(BytesIO(), 'w') as f:
1382 self.assertEqual(f.write(q), LENGTH)
1383 self.assertEqual(f.tell(), LENGTH)
1384
1385
1386 class OpenTestCase(unittest.TestCase):
1387
1388 def test_binary_modes(self):
1389 with lzma.open(BytesIO(COMPRESSED_XZ), "rb") as f:
1390 self.assertEqual(f.read(), INPUT)
1391 with BytesIO() as bio:
1392 with lzma.open(bio, "wb") as f:
1393 f.write(INPUT)
1394 file_data = lzma.decompress(bio.getvalue())
1395 self.assertEqual(file_data, INPUT)
1396 with lzma.open(bio, "ab") as f:
1397 f.write(INPUT)
1398 file_data = lzma.decompress(bio.getvalue())
1399 self.assertEqual(file_data, INPUT * 2)
1400
1401 def test_text_modes(self):
1402 uncompressed = INPUT.decode("ascii")
1403 uncompressed_raw = uncompressed.replace("\n", os.linesep)
1404 with lzma.open(BytesIO(COMPRESSED_XZ), "rt", encoding="ascii") as f:
1405 self.assertEqual(f.read(), uncompressed)
1406 with BytesIO() as bio:
1407 with lzma.open(bio, "wt", encoding="ascii") as f:
1408 f.write(uncompressed)
1409 file_data = lzma.decompress(bio.getvalue()).decode("ascii")
1410 self.assertEqual(file_data, uncompressed_raw)
1411 with lzma.open(bio, "at", encoding="ascii") as f:
1412 f.write(uncompressed)
1413 file_data = lzma.decompress(bio.getvalue()).decode("ascii")
1414 self.assertEqual(file_data, uncompressed_raw * 2)
1415
1416 def test_filename(self):
1417 with TempFile(TESTFN):
1418 with lzma.open(TESTFN, "wb") as f:
1419 f.write(INPUT)
1420 with open(TESTFN, "rb") as f:
1421 file_data = lzma.decompress(f.read())
1422 self.assertEqual(file_data, INPUT)
1423 with lzma.open(TESTFN, "rb") as f:
1424 self.assertEqual(f.read(), INPUT)
1425 with lzma.open(TESTFN, "ab") as f:
1426 f.write(INPUT)
1427 with lzma.open(TESTFN, "rb") as f:
1428 self.assertEqual(f.read(), INPUT * 2)
1429
1430 def test_with_pathlike_filename(self):
1431 filename = FakePath(TESTFN)
1432 with TempFile(filename):
1433 with lzma.open(filename, "wb") as f:
1434 f.write(INPUT)
1435 self.assertEqual(f.name, TESTFN)
1436 with open(filename, "rb") as f:
1437 file_data = lzma.decompress(f.read())
1438 self.assertEqual(file_data, INPUT)
1439 with lzma.open(filename, "rb") as f:
1440 self.assertEqual(f.read(), INPUT)
1441 self.assertEqual(f.name, TESTFN)
1442
1443 def test_bad_params(self):
1444 # Test invalid parameter combinations.
1445 with self.assertRaises(ValueError):
1446 lzma.open(TESTFN, "")
1447 with self.assertRaises(ValueError):
1448 lzma.open(TESTFN, "rbt")
1449 with self.assertRaises(ValueError):
1450 lzma.open(TESTFN, "rb", encoding="utf-8")
1451 with self.assertRaises(ValueError):
1452 lzma.open(TESTFN, "rb", errors="ignore")
1453 with self.assertRaises(ValueError):
1454 lzma.open(TESTFN, "rb", newline="\n")
1455
1456 def test_format_and_filters(self):
1457 # Test non-default format and filter chain.
1458 options = {"format": lzma.FORMAT_RAW, "filters": FILTERS_RAW_1}
1459 with lzma.open(BytesIO(COMPRESSED_RAW_1), "rb", **options) as f:
1460 self.assertEqual(f.read(), INPUT)
1461 with BytesIO() as bio:
1462 with lzma.open(bio, "wb", **options) as f:
1463 f.write(INPUT)
1464 file_data = lzma.decompress(bio.getvalue(), **options)
1465 self.assertEqual(file_data, INPUT)
1466
1467 def test_encoding(self):
1468 # Test non-default encoding.
1469 uncompressed = INPUT.decode("ascii")
1470 uncompressed_raw = uncompressed.replace("\n", os.linesep)
1471 with BytesIO() as bio:
1472 with lzma.open(bio, "wt", encoding="utf-16-le") as f:
1473 f.write(uncompressed)
1474 file_data = lzma.decompress(bio.getvalue()).decode("utf-16-le")
1475 self.assertEqual(file_data, uncompressed_raw)
1476 bio.seek(0)
1477 with lzma.open(bio, "rt", encoding="utf-16-le") as f:
1478 self.assertEqual(f.read(), uncompressed)
1479
1480 def test_encoding_error_handler(self):
1481 # Test with non-default encoding error handler.
1482 with BytesIO(lzma.compress(b"foo\xffbar")) as bio:
1483 with lzma.open(bio, "rt", encoding="ascii", errors="ignore") as f:
1484 self.assertEqual(f.read(), "foobar")
1485
1486 def test_newline(self):
1487 # Test with explicit newline (universal newline mode disabled).
1488 text = INPUT.decode("ascii")
1489 with BytesIO() as bio:
1490 with lzma.open(bio, "wt", encoding="ascii", newline="\n") as f:
1491 f.write(text)
1492 bio.seek(0)
1493 with lzma.open(bio, "rt", encoding="ascii", newline="\r") as f:
1494 self.assertEqual(f.readlines(), [text])
1495
1496 def test_x_mode(self):
1497 self.addCleanup(unlink, TESTFN)
1498 for mode in ("x", "xb", "xt"):
1499 unlink(TESTFN)
1500 encoding = "ascii" if "t" in mode else None
1501 with lzma.open(TESTFN, mode, encoding=encoding):
1502 pass
1503 with self.assertRaises(FileExistsError):
1504 with lzma.open(TESTFN, mode):
1505 pass
1506
1507
1508 class MiscellaneousTestCase(unittest.TestCase):
1509
1510 def test_is_check_supported(self):
1511 # CHECK_NONE and CHECK_CRC32 should always be supported,
1512 # regardless of the options liblzma was compiled with.
1513 self.assertTrue(lzma.is_check_supported(lzma.CHECK_NONE))
1514 self.assertTrue(lzma.is_check_supported(lzma.CHECK_CRC32))
1515
1516 # The .xz format spec cannot store check IDs above this value.
1517 self.assertFalse(lzma.is_check_supported(lzma.CHECK_ID_MAX + 1))
1518
1519 # This value should not be a valid check ID.
1520 self.assertFalse(lzma.is_check_supported(lzma.CHECK_UNKNOWN))
1521
1522 def test__encode_filter_properties(self):
1523 with self.assertRaises(TypeError):
1524 lzma._encode_filter_properties(b"not a dict")
1525 with self.assertRaises(ValueError):
1526 lzma._encode_filter_properties({"id": 0x100})
1527 with self.assertRaises(ValueError):
1528 lzma._encode_filter_properties({"id": lzma.FILTER_LZMA2, "junk": 12})
1529 with self.assertRaises(lzma.LZMAError):
1530 lzma._encode_filter_properties({"id": lzma.FILTER_DELTA,
1531 "dist": 9001})
1532
1533 # Test with parameters used by zipfile module.
1534 props = lzma._encode_filter_properties({
1535 "id": lzma.FILTER_LZMA1,
1536 "pb": 2,
1537 "lp": 0,
1538 "lc": 3,
1539 "dict_size": 8 << 20,
1540 })
1541 self.assertEqual(props, b"]\x00\x00\x80\x00")
1542
1543 def test__decode_filter_properties(self):
1544 with self.assertRaises(TypeError):
1545 lzma._decode_filter_properties(lzma.FILTER_X86, {"should be": bytes})
1546 with self.assertRaises(lzma.LZMAError):
1547 lzma._decode_filter_properties(lzma.FILTER_DELTA, b"too long")
1548
1549 # Test with parameters used by zipfile module.
1550 filterspec = lzma._decode_filter_properties(
1551 lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
1552 self.assertEqual(filterspec["id"], lzma.FILTER_LZMA1)
1553 self.assertEqual(filterspec["pb"], 2)
1554 self.assertEqual(filterspec["lp"], 0)
1555 self.assertEqual(filterspec["lc"], 3)
1556 self.assertEqual(filterspec["dict_size"], 8 << 20)
1557
1558 # see gh-104282
1559 filters = [lzma.FILTER_X86, lzma.FILTER_POWERPC,
1560 lzma.FILTER_IA64, lzma.FILTER_ARM,
1561 lzma.FILTER_ARMTHUMB, lzma.FILTER_SPARC]
1562 for f in filters:
1563 filterspec = lzma._decode_filter_properties(f, b"")
1564 self.assertEqual(filterspec, {"id": f})
1565
1566 def test_filter_properties_roundtrip(self):
1567 spec1 = lzma._decode_filter_properties(
1568 lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
1569 reencoded = lzma._encode_filter_properties(spec1)
1570 spec2 = lzma._decode_filter_properties(lzma.FILTER_LZMA1, reencoded)
1571 self.assertEqual(spec1, spec2)
1572
1573
1574 # Test data:
1575
1576 INPUT = b"""
1577 LAERTES
1578
1579 O, fear me not.
1580 I stay too long: but here my father comes.
1581
1582 Enter POLONIUS
1583
1584 A double blessing is a double grace,
1585 Occasion smiles upon a second leave.
1586
1587 LORD POLONIUS
1588
1589 Yet here, Laertes! aboard, aboard, for shame!
1590 The wind sits in the shoulder of your sail,
1591 And you are stay'd for. There; my blessing with thee!
1592 And these few precepts in thy memory
1593 See thou character. Give thy thoughts no tongue,
1594 Nor any unproportioned thought his act.
1595 Be thou familiar, but by no means vulgar.
1596 Those friends thou hast, and their adoption tried,
1597 Grapple them to thy soul with hoops of steel;
1598 But do not dull thy palm with entertainment
1599 Of each new-hatch'd, unfledged comrade. Beware
1600 Of entrance to a quarrel, but being in,
1601 Bear't that the opposed may beware of thee.
1602 Give every man thy ear, but few thy voice;
1603 Take each man's censure, but reserve thy judgment.
1604 Costly thy habit as thy purse can buy,
1605 But not express'd in fancy; rich, not gaudy;
1606 For the apparel oft proclaims the man,
1607 And they in France of the best rank and station
1608 Are of a most select and generous chief in that.
1609 Neither a borrower nor a lender be;
1610 For loan oft loses both itself and friend,
1611 And borrowing dulls the edge of husbandry.
1612 This above all: to thine ownself be true,
1613 And it must follow, as the night the day,
1614 Thou canst not then be false to any man.
1615 Farewell: my blessing season this in thee!
1616
1617 LAERTES
1618
1619 Most humbly do I take my leave, my lord.
1620
1621 LORD POLONIUS
1622
1623 The time invites you; go; your servants tend.
1624
1625 LAERTES
1626
1627 Farewell, Ophelia; and remember well
1628 What I have said to you.
1629
1630 OPHELIA
1631
1632 'Tis in my memory lock'd,
1633 And you yourself shall keep the key of it.
1634
1635 LAERTES
1636
1637 Farewell.
1638 """
1639
1640 COMPRESSED_BOGUS = b"this is not a valid lzma stream"
1641
1642 COMPRESSED_XZ = (
1643 b"\xfd7zXZ\x00\x00\x04\xe6\xd6\xb4F\x02\x00!\x01\x16\x00\x00\x00t/\xe5\xa3"
1644 b"\xe0\x07\x80\x03\xdf]\x00\x05\x14\x07bX\x19\xcd\xddn\x98\x15\xe4\xb4\x9d"
1645 b"o\x1d\xc4\xe5\n\x03\xcc2h\xc7\\\x86\xff\xf8\xe2\xfc\xe7\xd9\xfe6\xb8("
1646 b"\xa8wd\xc2\"u.n\x1e\xc3\xf2\x8e\x8d\x8f\x02\x17/\xa6=\xf0\xa2\xdf/M\x89"
1647 b"\xbe\xde\xa7\x1cz\x18-]\xd5\xef\x13\x8frZ\x15\x80\x8c\xf8\x8do\xfa\x12"
1648 b"\x9b#z/\xef\xf0\xfaF\x01\x82\xa3M\x8e\xa1t\xca6 BF$\xe5Q\xa4\x98\xee\xde"
1649 b"l\xe8\x7f\xf0\x9d,bn\x0b\x13\xd4\xa8\x81\xe4N\xc8\x86\x153\xf5x2\xa2O"
1650 b"\x13@Q\xa1\x00/\xa5\xd0O\x97\xdco\xae\xf7z\xc4\xcdS\xb6t<\x16\xf2\x9cI#"
1651 b"\x89ud\xc66Y\xd9\xee\xe6\xce\x12]\xe5\xf0\xaa\x96-Pe\xade:\x04\t\x1b\xf7"
1652 b"\xdb7\n\x86\x1fp\xc8J\xba\xf4\xf0V\xa9\xdc\xf0\x02%G\xf9\xdf=?\x15\x1b"
1653 b"\xe1(\xce\x82=\xd6I\xac3\x12\x0cR\xb7\xae\r\xb1i\x03\x95\x01\xbd\xbe\xfa"
1654 b"\x02s\x01P\x9d\x96X\xb12j\xc8L\xa8\x84b\xf6\xc3\xd4c-H\x93oJl\xd0iQ\xe4k"
1655 b"\x84\x0b\xc1\xb7\xbc\xb1\x17\x88\xb1\xca?@\xf6\x07\xea\xe6x\xf1H12P\x0f"
1656 b"\x8a\xc9\xeauw\xe3\xbe\xaai\xa9W\xd0\x80\xcd#cb5\x99\xd8]\xa9d\x0c\xbd"
1657 b"\xa2\xdcWl\xedUG\xbf\x89yF\xf77\x81v\xbd5\x98\xbeh8\x18W\x08\xf0\x1b\x99"
1658 b"5:\x1a?rD\x96\xa1\x04\x0f\xae\xba\x85\xeb\x9d5@\xf5\x83\xd37\x83\x8ac"
1659 b"\x06\xd4\x97i\xcdt\x16S\x82k\xf6K\x01vy\x88\x91\x9b6T\xdae\r\xfd]:k\xbal"
1660 b"\xa9\xbba\xc34\xf9r\xeb}r\xdb\xc7\xdb*\x8f\x03z\xdc8h\xcc\xc9\xd3\xbcl"
1661 b"\xa5-\xcb\xeaK\xa2\xc5\x15\xc0\xe3\xc1\x86Z\xfb\xebL\xe13\xcf\x9c\xe3"
1662 b"\x1d\xc9\xed\xc2\x06\xcc\xce!\x92\xe5\xfe\x9c^\xa59w \x9bP\xa3PK\x08d"
1663 b"\xf9\xe2Z}\xa7\xbf\xed\xeb%$\x0c\x82\xb8/\xb0\x01\xa9&,\xf7qh{Q\x96)\xf2"
1664 b"q\x96\xc3\x80\xb4\x12\xb0\xba\xe6o\xf4!\xb4[\xd4\x8aw\x10\xf7t\x0c\xb3"
1665 b"\xd9\xd5\xc3`^\x81\x11??\\\xa4\x99\x85R\xd4\x8e\x83\xc9\x1eX\xbfa\xf1"
1666 b"\xac\xb0\xea\xea\xd7\xd0\xab\x18\xe2\xf2\xed\xe1\xb7\xc9\x18\xcbS\xe4>"
1667 b"\xc9\x95H\xe8\xcb\t\r%\xeb\xc7$.o\xf1\xf3R\x17\x1db\xbb\xd8U\xa5^\xccS"
1668 b"\x16\x01\x87\xf3/\x93\xd1\xf0v\xc0r\xd7\xcc\xa2Gkz\xca\x80\x0e\xfd\xd0"
1669 b"\x8b\xbb\xd2Ix\xb3\x1ey\xca-0\xe3z^\xd6\xd6\x8f_\xf1\x9dP\x9fi\xa7\xd1"
1670 b"\xe8\x90\x84\xdc\xbf\xcdky\x8e\xdc\x81\x7f\xa3\xb2+\xbf\x04\xef\xd8\\"
1671 b"\xc4\xdf\xe1\xb0\x01\xe9\x93\xe3Y\xf1\x1dY\xe8h\x81\xcf\xf1w\xcc\xb4\xef"
1672 b" \x8b|\x04\xea\x83ej\xbe\x1f\xd4z\x9c`\xd3\x1a\x92A\x06\xe5\x8f\xa9\x13"
1673 b"\t\x9e=\xfa\x1c\xe5_\x9f%v\x1bo\x11ZO\xd8\xf4\t\xddM\x16-\x04\xfc\x18<\""
1674 b"CM\xddg~b\xf6\xef\x8e\x0c\xd0\xde|\xa0'\x8a\x0c\xd6x\xae!J\xa6F\x88\x15u"
1675 b"\x008\x17\xbc7y\xb3\xd8u\xac_\x85\x8d\xe7\xc1@\x9c\xecqc\xa3#\xad\xf1"
1676 b"\x935\xb5)_\r\xec3]\x0fo]5\xd0my\x07\x9b\xee\x81\xb5\x0f\xcfK+\x00\xc0"
1677 b"\xe4b\x10\xe4\x0c\x1a \x9b\xe0\x97t\xf6\xa1\x9e\x850\xba\x0c\x9a\x8d\xc8"
1678 b"\x8f\x07\xd7\xae\xc8\xf9+i\xdc\xb9k\xb0>f\x19\xb8\r\xa8\xf8\x1f$\xa5{p"
1679 b"\xc6\x880\xce\xdb\xcf\xca_\x86\xac\x88h6\x8bZ%'\xd0\n\xbf\x0f\x9c\"\xba"
1680 b"\xe5\x86\x9f\x0f7X=mNX[\xcc\x19FU\xc9\x860\xbc\x90a+* \xae_$\x03\x1e\xd3"
1681 b"\xcd_\xa0\x9c\xde\xaf46q\xa5\xc9\x92\xd7\xca\xe3`\x9d\x85}\xb4\xff\xb3"
1682 b"\x83\xfb\xb6\xca\xae`\x0bw\x7f\xfc\xd8\xacVe\x19\xc8\x17\x0bZ\xad\x88"
1683 b"\xeb#\x97\x03\x13\xb1d\x0f{\x0c\x04w\x07\r\x97\xbd\xd6\xc1\xc3B:\x95\x08"
1684 b"^\x10V\xaeaH\x02\xd9\xe3\n\\\x01X\xf6\x9c\x8a\x06u#%\xbe*\xa1\x18v\x85"
1685 b"\xec!\t4\x00\x00\x00\x00Vj?uLU\xf3\xa6\x00\x01\xfb\x07\x81\x0f\x00\x00tw"
1686 b"\x99P\xb1\xc4g\xfb\x02\x00\x00\x00\x00\x04YZ"
1687 )
1688
1689 COMPRESSED_ALONE = (
1690 b"]\x00\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x05\x14\x07bX\x19"
1691 b"\xcd\xddn\x98\x15\xe4\xb4\x9do\x1d\xc4\xe5\n\x03\xcc2h\xc7\\\x86\xff\xf8"
1692 b"\xe2\xfc\xe7\xd9\xfe6\xb8(\xa8wd\xc2\"u.n\x1e\xc3\xf2\x8e\x8d\x8f\x02"
1693 b"\x17/\xa6=\xf0\xa2\xdf/M\x89\xbe\xde\xa7\x1cz\x18-]\xd5\xef\x13\x8frZ"
1694 b"\x15\x80\x8c\xf8\x8do\xfa\x12\x9b#z/\xef\xf0\xfaF\x01\x82\xa3M\x8e\xa1t"
1695 b"\xca6 BF$\xe5Q\xa4\x98\xee\xdel\xe8\x7f\xf0\x9d,bn\x0b\x13\xd4\xa8\x81"
1696 b"\xe4N\xc8\x86\x153\xf5x2\xa2O\x13@Q\xa1\x00/\xa5\xd0O\x97\xdco\xae\xf7z"
1697 b"\xc4\xcdS\xb6t<\x16\xf2\x9cI#\x89ud\xc66Y\xd9\xee\xe6\xce\x12]\xe5\xf0"
1698 b"\xaa\x96-Pe\xade:\x04\t\x1b\xf7\xdb7\n\x86\x1fp\xc8J\xba\xf4\xf0V\xa9"
1699 b"\xdc\xf0\x02%G\xf9\xdf=?\x15\x1b\xe1(\xce\x82=\xd6I\xac3\x12\x0cR\xb7"
1700 b"\xae\r\xb1i\x03\x95\x01\xbd\xbe\xfa\x02s\x01P\x9d\x96X\xb12j\xc8L\xa8"
1701 b"\x84b\xf8\x1epl\xeajr\xd1=\t\x03\xdd\x13\x1b3!E\xf9vV\xdaF\xf3\xd7\xb4"
1702 b"\x0c\xa9P~\xec\xdeE\xe37\xf6\x1d\xc6\xbb\xddc%\xb6\x0fI\x07\xf0;\xaf\xe7"
1703 b"\xa0\x8b\xa7Z\x99(\xe9\xe2\xf0o\x18>`\xe1\xaa\xa8\xd9\xa1\xb2}\xe7\x8d"
1704 b"\x834T\xb6\xef\xc1\xde\xe3\x98\xbcD\x03MA@\xd8\xed\xdc\xc8\x93\x03\x1a"
1705 b"\x93\x0b\x7f\x94\x12\x0b\x02Sa\x18\xc9\xc5\x9bTJE}\xf6\xc8g\x17#ZV\x01"
1706 b"\xc9\x9dc\x83\x0e>0\x16\x90S\xb8/\x03y_\x18\xfa(\xd7\x0br\xa2\xb0\xba?"
1707 b"\x8c\xe6\x83@\x84\xdf\x02:\xc5z\x9e\xa6\x84\xc9\xf5BeyX\x83\x1a\xf1 :\t"
1708 b"\xf7\x19\xfexD\\&G\xf3\x85Y\xa2J\xf9\x0bv{\x89\xf6\xe7)A\xaf\x04o\x00"
1709 b"\x075\xd3\xe0\x7f\x97\x98F\x0f?v\x93\xedVtTf\xb5\x97\x83\xed\x19\xd7\x1a"
1710 b"'k\xd7\xd9\xc5\\Y\xd1\xdc\x07\x15|w\xbc\xacd\x87\x08d\xec\xa7\xf6\x82"
1711 b"\xfc\xb3\x93\xeb\xb9 \x8d\xbc ,\xb3X\xb0\xd2s\xd7\xd1\xffv\x05\xdf}\xa2"
1712 b"\x96\xfb%\n\xdf\xa2\x7f\x08.\xa16\n\xe0\x19\x93\x7fh\n\x1c\x8c\x0f \x11"
1713 b"\xc6Bl\x95\x19U}\xe4s\xb5\x10H\xea\x86pB\xe88\x95\xbe\x8cZ\xdb\xe4\x94A"
1714 b"\x92\xb9;z\xaa\xa7{\x1c5!\xc0\xaf\xc1A\xf9\xda\xf0$\xb0\x02qg\xc8\xc7/|"
1715 b"\xafr\x99^\x91\x88\xbf\x03\xd9=\xd7n\xda6{>8\n\xc7:\xa9'\xba.\x0b\xe2"
1716 b"\xb5\x1d\x0e\n\x9a\x8e\x06\x8f:\xdd\x82'[\xc3\"wD$\xa7w\xecq\x8c,1\x93"
1717 b"\xd0,\xae2w\x93\x12$Jd\x19mg\x02\x93\x9cA\x95\x9d&\xca8i\x9c\xb0;\xe7NQ"
1718 b"\x1frh\x8beL;\xb0m\xee\x07Q\x9b\xc6\xd8\x03\xb5\xdeN\xd4\xfe\x98\xd0\xdc"
1719 b"\x1a[\x04\xde\x1a\xf6\x91j\xf8EOli\x8eB^\x1d\x82\x07\xb2\xb5R]\xb7\xd7"
1720 b"\xe9\xa6\xc3.\xfb\xf0-\xb4e\x9b\xde\x03\x88\xc6\xc1iN\x0e\x84wbQ\xdf~"
1721 b"\xe9\xa4\x884\x96kM\xbc)T\xf3\x89\x97\x0f\x143\xe7)\xa0\xb3B\x00\xa8\xaf"
1722 b"\x82^\xcb\xc7..\xdb\xc7\t\x9dH\xee5\xe9#\xe6NV\x94\xcb$Kk\xe3\x7f\r\xe3t"
1723 b"\x12\xcf'\xefR\x8b\xf42\xcf-LH\xac\xe5\x1f0~?SO\xeb\xc1E\x1a\x1c]\xf2"
1724 b"\xc4<\x11\x02\x10Z0a*?\xe4r\xff\xfb\xff\xf6\x14nG\xead^\xd6\xef8\xb6uEI"
1725 b"\x99\nV\xe2\xb3\x95\x8e\x83\xf6i!\xb5&1F\xb1DP\xf4 SO3D!w\x99_G\x7f+\x90"
1726 b".\xab\xbb]\x91>\xc9#h;\x0f5J\x91K\xf4^-[\x9e\x8a\\\x94\xca\xaf\xf6\x19"
1727 b"\xd4\xa1\x9b\xc4\xb8p\xa1\xae\x15\xe9r\x84\xe0\xcar.l []\x8b\xaf+0\xf2g"
1728 b"\x01aKY\xdfI\xcf,\n\xe8\xf0\xe7V\x80_#\xb2\xf2\xa9\x06\x8c>w\xe2W,\xf4"
1729 b"\x8c\r\xf963\xf5J\xcc2\x05=kT\xeaUti\xe5_\xce\x1b\xfa\x8dl\x02h\xef\xa8"
1730 b"\xfbf\x7f\xff\xf0\x19\xeax"
1731 )
1732
1733 FILTERS_RAW_1 = [{"id": lzma.FILTER_LZMA2, "preset": 3}]
1734 COMPRESSED_RAW_1 = (
1735 b"\xe0\x07\x80\x03\xfd]\x00\x05\x14\x07bX\x19\xcd\xddn\x96cyq\xa1\xdd\xee"
1736 b"\xf8\xfam\xe3'\x88\xd3\xff\xe4\x9e \xceQ\x91\xa4\x14I\xf6\xb9\x9dVL8\x15"
1737 b"_\x0e\x12\xc3\xeb\xbc\xa5\xcd\nW\x1d$=R;\x1d\xf8k8\t\xb1{\xd4\xc5+\x9d"
1738 b"\x87c\xe5\xef\x98\xb4\xd7S3\xcd\xcc\xd2\xed\xa4\x0em\xe5\xf4\xdd\xd0b"
1739 b"\xbe4*\xaa\x0b\xc5\x08\x10\x85+\x81.\x17\xaf9\xc9b\xeaZrA\xe20\x7fs\"r"
1740 b"\xdaG\x81\xde\x90cu\xa5\xdb\xa9.A\x08l\xb0<\xf6\x03\xddOi\xd0\xc5\xb4"
1741 b"\xec\xecg4t6\"\xa6\xb8o\xb5?\x18^}\xb6}\x03[:\xeb\x03\xa9\n[\x89l\x19g"
1742 b"\x16\xc82\xed\x0b\xfb\x86n\xa2\x857@\x93\xcd6T\xc3u\xb0\t\xf9\x1b\x918"
1743 b"\xfc[\x1b\x1e4\xb3\x14\x06PCV\xa8\"\xf5\x81x~\xe9\xb5N\x9cK\x9f\xc6\xc3%"
1744 b"\xc8k:{6\xe7\xf7\xbd\x05\x02\xb4\xc4\xc3\xd3\xfd\xc3\xa8\\\xfc@\xb1F_"
1745 b"\xc8\x90\xd9sU\x98\xad8\x05\x07\xde7J\x8bM\xd0\xb3;X\xec\x87\xef\xae\xb3"
1746 b"eO,\xb1z,d\x11y\xeejlB\x02\x1d\xf28\x1f#\x896\xce\x0b\xf0\xf5\xa9PK\x0f"
1747 b"\xb3\x13P\xd8\x88\xd2\xa1\x08\x04C?\xdb\x94_\x9a\"\xe9\xe3e\x1d\xde\x9b"
1748 b"\xa1\xe8>H\x98\x10;\xc5\x03#\xb5\x9d4\x01\xe7\xc5\xba%v\xa49\x97A\xe0\""
1749 b"\x8c\xc22\xe3i\xc1\x9d\xab3\xdf\xbe\xfdDm7\x1b\x9d\xab\xb5\x15o:J\x92"
1750 b"\xdb\x816\x17\xc2O\x99\x1b\x0e\x8d\xf3\tQ\xed\x8e\x95S/\x16M\xb2S\x04"
1751 b"\x0f\xc3J\xc6\xc7\xe4\xcb\xc5\xf4\xe7d\x14\xe4=^B\xfb\xd3E\xd3\x1e\xcd"
1752 b"\x91\xa5\xd0G\x8f.\xf6\xf9\x0bb&\xd9\x9f\xc2\xfdj\xa2\x9e\xc4\\\x0e\x1dC"
1753 b"v\xe8\xd2\x8a?^H\xec\xae\xeb>\xfe\xb8\xab\xd4IqY\x8c\xd4K7\x11\xf4D\xd0W"
1754 b"\xa5\xbe\xeaO\xbf\xd0\x04\xfdl\x10\xae5\xd4U\x19\x06\xf9{\xaa\xe0\x81"
1755 b"\x0f\xcf\xa3k{\x95\xbd\x19\xa2\xf8\xe4\xa3\x08O*\xf1\xf1B-\xc7(\x0eR\xfd"
1756 b"@E\x9f\xd3\x1e:\xfdV\xb7\x04Y\x94\xeb]\x83\xc4\xa5\xd7\xc0gX\x98\xcf\x0f"
1757 b"\xcd3\x00]n\x17\xec\xbd\xa3Y\x86\xc5\xf3u\xf6*\xbdT\xedA$A\xd9A\xe7\x98"
1758 b"\xef\x14\x02\x9a\xfdiw\xec\xa0\x87\x11\xd9%\xc5\xeb\x8a=\xae\xc0\xc4\xc6"
1759 b"D\x80\x8f\xa8\xd1\xbbq\xb2\xc0\xa0\xf5Cqp\xeeL\xe3\xe5\xdc \x84\"\xe9"
1760 b"\x80t\x83\x05\xba\xf1\xc5~\x93\xc9\xf0\x01c\xceix\x9d\xed\xc5)l\x16)\xd1"
1761 b"\x03@l\x04\x7f\x87\xa5yn\x1b\x01D\xaa:\xd2\x96\xb4\xb3?\xb0\xf9\xce\x07"
1762 b"\xeb\x81\x00\xe4\xc3\xf5%_\xae\xd4\xf9\xeb\xe2\rh\xb2#\xd67Q\x16D\x82hn"
1763 b"\xd1\xa3_?q\xf0\xe2\xac\xf317\x9e\xd0_\x83|\xf1\xca\xb7\x95S\xabW\x12"
1764 b"\xff\xddt\xf69L\x01\xf2|\xdaW\xda\xees\x98L\x18\xb8_\xe8$\x82\xea\xd6"
1765 b"\xd1F\xd4\x0b\xcdk\x01vf\x88h\xc3\xae\xb91\xc7Q\x9f\xa5G\xd9\xcc\x1f\xe3"
1766 b"5\xb1\xdcy\x7fI\x8bcw\x8e\x10rIp\x02:\x19p_\xc8v\xcea\"\xc1\xd9\x91\x03"
1767 b"\xbfe\xbe\xa6\xb3\xa8\x14\x18\xc3\xabH*m}\xc2\xc1\x9a}>l%\xce\x84\x99"
1768 b"\xb3d\xaf\xd3\x82\x15\xdf\xc1\xfc5fOg\x9b\xfc\x8e^&\t@\xce\x9f\x06J\xb8"
1769 b"\xb5\x86\x1d\xda{\x9f\xae\xb0\xff\x02\x81r\x92z\x8cM\xb7ho\xc9^\x9c\xb6"
1770 b"\x9c\xae\xd1\xc9\xf4\xdfU7\xd6\\!\xea\x0b\x94k\xb9Ud~\x98\xe7\x86\x8az"
1771 b"\x10;\xe3\x1d\xe5PG\xf8\xa4\x12\x05w\x98^\xc4\xb1\xbb\xfb\xcf\xe0\x7f"
1772 b"\x033Sf\x0c \xb1\xf6@\x94\xe5\xa3\xb2\xa7\x10\x9a\xc0\x14\xc3s\xb5xRD"
1773 b"\xf4`W\xd9\xe5\xd3\xcf\x91\rTZ-X\xbe\xbf\xb5\xe2\xee|\x1a\xbf\xfb\x08"
1774 b"\x91\xe1\xfc\x9a\x18\xa3\x8b\xd6^\x89\xf5[\xef\x87\xd1\x06\x1c7\xd6\xa2"
1775 b"\t\tQ5/@S\xc05\xd2VhAK\x03VC\r\x9b\x93\xd6M\xf1xO\xaaO\xed\xb9<\x0c\xdae"
1776 b"*\xd0\x07Hk6\x9fG+\xa1)\xcd\x9cl\x87\xdb\xe1\xe7\xefK}\x875\xab\xa0\x19u"
1777 b"\xf6*F\xb32\x00\x00\x00"
1778 )
1779
1780 FILTERS_RAW_2 = [{"id": lzma.FILTER_DELTA, "dist": 2},
1781 {"id": lzma.FILTER_LZMA2,
1782 "preset": lzma.PRESET_DEFAULT | lzma.PRESET_EXTREME}]
1783 COMPRESSED_RAW_2 = (
1784 b"\xe0\x07\x80\x05\x91]\x00\x05\x14\x06-\xd4\xa8d?\xef\xbe\xafH\xee\x042"
1785 b"\xcb.\xb5g\x8f\xfb\x14\xab\xa5\x9f\x025z\xa4\xdd\xd8\t[}W\xf8\x0c\x1dmH"
1786 b"\xfa\x05\xfcg\xba\xe5\x01Q\x0b\x83R\xb6A\x885\xc0\xba\xee\n\x1cv~\xde:o"
1787 b"\x06:J\xa7\x11Cc\xea\xf7\xe5*o\xf7\x83\\l\xbdE\x19\x1f\r\xa8\x10\xb42"
1788 b"\x0caU{\xd7\xb8w\xdc\xbe\x1b\xfc8\xb4\xcc\xd38\\\xf6\x13\xf6\xe7\x98\xfa"
1789 b"\xc7[\x17_9\x86%\xa8\xf8\xaa\xb8\x8dfs#\x1e=\xed<\x92\x10\\t\xff\x86\xfb"
1790 b"=\x9e7\x18\x1dft\\\xb5\x01\x95Q\xc5\x19\xb38\xe0\xd4\xaa\x07\xc3\x7f\xd8"
1791 b"\xa2\x00>-\xd3\x8e\xa1#\xfa\x83ArAm\xdbJ~\x93\xa3B\x82\xe0\xc7\xcc(\x08`"
1792 b"WK\xad\x1b\x94kaj\x04 \xde\xfc\xe1\xed\xb0\x82\x91\xefS\x84%\x86\xfbi"
1793 b"\x99X\xf1B\xe7\x90;E\xfde\x98\xda\xca\xd6T\xb4bg\xa4\n\x9aj\xd1\x83\x9e]"
1794 b"\"\x7fM\xb5\x0fr\xd2\\\xa5j~P\x10GH\xbfN*Z\x10.\x81\tpE\x8a\x08\xbe1\xbd"
1795 b"\xcd\xa9\xe1\x8d\x1f\x04\xf9\x0eH\xb9\xae\xd6\xc3\xc1\xa5\xa9\x95P\xdc~"
1796 b"\xff\x01\x930\xa9\x04\xf6\x03\xfe\xb5JK\xc3]\xdd9\xb1\xd3\xd7F\xf5\xd1"
1797 b"\x1e\xa0\x1c_\xed[\x0c\xae\xd4\x8b\x946\xeb\xbf\xbb\xe3$kS{\xb5\x80,f:Sj"
1798 b"\x0f\x08z\x1c\xf5\xe8\xe6\xae\x98\xb0Q~r\x0f\xb0\x05?\xb6\x90\x19\x02&"
1799 b"\xcb\x80\t\xc4\xea\x9c|x\xce\x10\x9c\xc5|\xcbdhh+\x0c'\xc5\x81\xc33\xb5"
1800 b"\x14q\xd6\xc5\xe3`Z#\xdc\x8a\xab\xdd\xea\x08\xc2I\xe7\x02l{\xec\x196\x06"
1801 b"\x91\x8d\xdc\xd5\xb3x\xe1hz%\xd1\xf8\xa5\xdd\x98!\x8c\x1c\xc1\x17RUa\xbb"
1802 b"\x95\x0f\xe4X\xea1\x0c\xf1=R\xbe\xc60\xe3\xa4\x9a\x90bd\x97$]B\x01\xdd"
1803 b"\x1f\xe3h2c\x1e\xa0L`4\xc6x\xa3Z\x8a\r\x14]T^\xd8\x89\x1b\x92\r;\xedY"
1804 b"\x0c\xef\x8d9z\xf3o\xb6)f\xa9]$n\rp\x93\xd0\x10\xa4\x08\xb8\xb2\x8b\xb6"
1805 b"\x8f\x80\xae;\xdcQ\xf1\xfa\x9a\x06\x8e\xa5\x0e\x8cK\x9c @\xaa:UcX\n!\xc6"
1806 b"\x02\x12\xcb\x1b\"=\x16.\x1f\x176\xf2g=\xe1Wn\xe9\xe1\xd4\xf1O\xad\x15"
1807 b"\x86\xe9\xa3T\xaf\xa9\xd7D\xb5\xd1W3pnt\x11\xc7VOj\xb7M\xc4i\xa1\xf1$3"
1808 b"\xbb\xdc\x8af\xb0\xc5Y\r\xd1\xfb\xf2\xe7K\xe6\xc5hwO\xfe\x8c2^&\x07\xd5"
1809 b"\x1fV\x19\xfd\r\x14\xd2i=yZ\xe6o\xaf\xc6\xb6\x92\x9d\xc4\r\xb3\xafw\xac%"
1810 b"\xcfc\x1a\xf1`]\xf2\x1a\x9e\x808\xedm\xedQ\xb2\xfe\xe4h`[q\xae\xe0\x0f"
1811 b"\xba0g\xb6\"N\xc3\xfb\xcfR\x11\xc5\x18)(\xc40\\\xa3\x02\xd9G!\xce\x1b"
1812 b"\xc1\x96x\xb5\xc8z\x1f\x01\xb4\xaf\xde\xc2\xcd\x07\xe7H\xb3y\xa8M\n\\A\t"
1813 b"ar\xddM\x8b\x9a\xea\x84\x9b!\xf1\x8d\xb1\xf1~\x1e\r\xa5H\xba\xf1\x84o"
1814 b"\xda\x87\x01h\xe9\xa2\xbe\xbeqN\x9d\x84\x0b!WG\xda\xa1\xa5A\xb7\xc7`j"
1815 b"\x15\xf2\xe9\xdd?\x015B\xd2~E\x06\x11\xe0\x91!\x05^\x80\xdd\xa8y\x15}"
1816 b"\xa1)\xb1)\x81\x18\xf4\xf4\xf8\xc0\xefD\xe3\xdb2f\x1e\x12\xabu\xc9\x97"
1817 b"\xcd\x1e\xa7\x0c\x02x4_6\x03\xc4$t\xf39\x94\x1d=\xcb\xbfv\\\xf5\xa3\x1d"
1818 b"\x9d8jk\x95\x13)ff\xf9n\xc4\xa9\xe3\x01\xb8\xda\xfb\xab\xdfM\x99\xfb\x05"
1819 b"\xe0\xe9\xb0I\xf4E\xab\xe2\x15\xa3\x035\xe7\xdeT\xee\x82p\xb4\x88\xd3"
1820 b"\x893\x9c/\xc0\xd6\x8fou;\xf6\x95PR\xa9\xb2\xc1\xefFj\xe2\xa7$\xf7h\xf1"
1821 b"\xdfK(\xc9c\xba7\xe8\xe3)\xdd\xb2,\x83\xfb\x84\x18.y\x18Qi\x88\xf8`h-"
1822 b"\xef\xd5\xed\x8c\t\xd8\xc3^\x0f\x00\xb7\xd0[!\xafM\x9b\xd7.\x07\xd8\xfb"
1823 b"\xd9\xe2-S+\xaa8,\xa0\x03\x1b \xea\xa8\x00\xc3\xab~\xd0$e\xa5\x7f\xf7"
1824 b"\x95P]\x12\x19i\xd9\x7fo\x0c\xd8g^\rE\xa5\x80\x18\xc5\x01\x80\xaek`\xff~"
1825 b"\xb6y\xe7+\xe5\x11^D\xa7\x85\x18\"!\xd6\xd2\xa7\xf4\x1eT\xdb\x02\xe15"
1826 b"\x02Y\xbc\x174Z\xe7\x9cH\x1c\xbf\x0f\xc6\xe9f]\xcf\x8cx\xbc\xe5\x15\x94"
1827 b"\xfc3\xbc\xa7TUH\xf1\x84\x1b\xf7\xa9y\xc07\x84\xf8X\xd8\xef\xfc \x1c\xd8"
1828 b"( /\xf2\xb7\xec\xc1\\\x8c\xf6\x95\xa1\x03J\x83vP8\xe1\xe3\xbb~\xc24kA"
1829 b"\x98y\xa1\xf2P\xe9\x9d\xc9J\xf8N\x99\xb4\xceaO\xde\x16\x1e\xc2\x19\xa7"
1830 b"\x03\xd2\xe0\x8f:\x15\xf3\x84\x9e\xee\xe6e\xb8\x02q\xc7AC\x1emw\xfd\t"
1831 b"\x9a\x1eu\xc1\xa9\xcaCwUP\x00\xa5\xf78L4w!\x91L2 \x87\xd0\xf2\x06\x81j"
1832 b"\x80;\x03V\x06\x87\x92\xcb\x90lv@E\x8d\x8d\xa5\xa6\xe7Z[\xdf\xd6E\x03`>"
1833 b"\x8f\xde\xa1bZ\x84\xd0\xa9`\x05\x0e{\x80;\xe3\xbef\x8d\x1d\xebk1.\xe3"
1834 b"\xe9N\x15\xf7\xd4(\xfa\xbb\x15\xbdu\xf7\x7f\x86\xae!\x03L\x1d\xb5\xc1"
1835 b"\xb9\x11\xdb\xd0\x93\xe4\x02\xe1\xd2\xcbBjc_\xe8}d\xdb\xc3\xa0Y\xbe\xc9/"
1836 b"\x95\x01\xa3,\xe6bl@\x01\xdbp\xc2\xce\x14\x168\xc2q\xe3uH\x89X\xa4\xa9"
1837 b"\x19\x1d\xc1}\x7fOX\x19\x9f\xdd\xbe\x85\x83\xff\x96\x1ee\x82O`CF=K\xeb$I"
1838 b"\x17_\xefX\x8bJ'v\xde\x1f+\xd9.v\xf8Tv\x17\xf2\x9f5\x19\xe1\xb9\x91\xa8S"
1839 b"\x86\xbd\x1a\"(\xa5x\x8dC\x03X\x81\x91\xa8\x11\xc4pS\x13\xbc\xf2'J\xae!"
1840 b"\xef\xef\x84G\t\x8d\xc4\x10\x132\x00oS\x9e\xe0\xe4d\x8f\xb8y\xac\xa6\x9f"
1841 b",\xb8f\x87\r\xdf\x9eE\x0f\xe1\xd0\\L\x00\xb2\xe1h\x84\xef}\x98\xa8\x11"
1842 b"\xccW#\\\x83\x7fo\xbbz\x8f\x00"
1843 )
1844
1845 FILTERS_RAW_3 = [{"id": lzma.FILTER_IA64, "start_offset": 0x100},
1846 {"id": lzma.FILTER_LZMA2}]
1847 COMPRESSED_RAW_3 = (
1848 b"\xe0\x07\x80\x03\xdf]\x00\x05\x14\x07bX\x19\xcd\xddn\x98\x15\xe4\xb4\x9d"
1849 b"o\x1d\xc4\xe5\n\x03\xcc2h\xc7\\\x86\xff\xf8\xe2\xfc\xe7\xd9\xfe6\xb8("
1850 b"\xa8wd\xc2\"u.n\x1e\xc3\xf2\x8e\x8d\x8f\x02\x17/\xa6=\xf0\xa2\xdf/M\x89"
1851 b"\xbe\xde\xa7\x1cz\x18-]\xd5\xef\x13\x8frZ\x15\x80\x8c\xf8\x8do\xfa\x12"
1852 b"\x9b#z/\xef\xf0\xfaF\x01\x82\xa3M\x8e\xa1t\xca6 BF$\xe5Q\xa4\x98\xee\xde"
1853 b"l\xe8\x7f\xf0\x9d,bn\x0b\x13\xd4\xa8\x81\xe4N\xc8\x86\x153\xf5x2\xa2O"
1854 b"\x13@Q\xa1\x00/\xa5\xd0O\x97\xdco\xae\xf7z\xc4\xcdS\xb6t<\x16\xf2\x9cI#"
1855 b"\x89ud\xc66Y\xd9\xee\xe6\xce\x12]\xe5\xf0\xaa\x96-Pe\xade:\x04\t\x1b\xf7"
1856 b"\xdb7\n\x86\x1fp\xc8J\xba\xf4\xf0V\xa9\xdc\xf0\x02%G\xf9\xdf=?\x15\x1b"
1857 b"\xe1(\xce\x82=\xd6I\xac3\x12\x0cR\xb7\xae\r\xb1i\x03\x95\x01\xbd\xbe\xfa"
1858 b"\x02s\x01P\x9d\x96X\xb12j\xc8L\xa8\x84b\xf6\xc3\xd4c-H\x93oJl\xd0iQ\xe4k"
1859 b"\x84\x0b\xc1\xb7\xbc\xb1\x17\x88\xb1\xca?@\xf6\x07\xea\xe6x\xf1H12P\x0f"
1860 b"\x8a\xc9\xeauw\xe3\xbe\xaai\xa9W\xd0\x80\xcd#cb5\x99\xd8]\xa9d\x0c\xbd"
1861 b"\xa2\xdcWl\xedUG\xbf\x89yF\xf77\x81v\xbd5\x98\xbeh8\x18W\x08\xf0\x1b\x99"
1862 b"5:\x1a?rD\x96\xa1\x04\x0f\xae\xba\x85\xeb\x9d5@\xf5\x83\xd37\x83\x8ac"
1863 b"\x06\xd4\x97i\xcdt\x16S\x82k\xf6K\x01vy\x88\x91\x9b6T\xdae\r\xfd]:k\xbal"
1864 b"\xa9\xbba\xc34\xf9r\xeb}r\xdb\xc7\xdb*\x8f\x03z\xdc8h\xcc\xc9\xd3\xbcl"
1865 b"\xa5-\xcb\xeaK\xa2\xc5\x15\xc0\xe3\xc1\x86Z\xfb\xebL\xe13\xcf\x9c\xe3"
1866 b"\x1d\xc9\xed\xc2\x06\xcc\xce!\x92\xe5\xfe\x9c^\xa59w \x9bP\xa3PK\x08d"
1867 b"\xf9\xe2Z}\xa7\xbf\xed\xeb%$\x0c\x82\xb8/\xb0\x01\xa9&,\xf7qh{Q\x96)\xf2"
1868 b"q\x96\xc3\x80\xb4\x12\xb0\xba\xe6o\xf4!\xb4[\xd4\x8aw\x10\xf7t\x0c\xb3"
1869 b"\xd9\xd5\xc3`^\x81\x11??\\\xa4\x99\x85R\xd4\x8e\x83\xc9\x1eX\xbfa\xf1"
1870 b"\xac\xb0\xea\xea\xd7\xd0\xab\x18\xe2\xf2\xed\xe1\xb7\xc9\x18\xcbS\xe4>"
1871 b"\xc9\x95H\xe8\xcb\t\r%\xeb\xc7$.o\xf1\xf3R\x17\x1db\xbb\xd8U\xa5^\xccS"
1872 b"\x16\x01\x87\xf3/\x93\xd1\xf0v\xc0r\xd7\xcc\xa2Gkz\xca\x80\x0e\xfd\xd0"
1873 b"\x8b\xbb\xd2Ix\xb3\x1ey\xca-0\xe3z^\xd6\xd6\x8f_\xf1\x9dP\x9fi\xa7\xd1"
1874 b"\xe8\x90\x84\xdc\xbf\xcdky\x8e\xdc\x81\x7f\xa3\xb2+\xbf\x04\xef\xd8\\"
1875 b"\xc4\xdf\xe1\xb0\x01\xe9\x93\xe3Y\xf1\x1dY\xe8h\x81\xcf\xf1w\xcc\xb4\xef"
1876 b" \x8b|\x04\xea\x83ej\xbe\x1f\xd4z\x9c`\xd3\x1a\x92A\x06\xe5\x8f\xa9\x13"
1877 b"\t\x9e=\xfa\x1c\xe5_\x9f%v\x1bo\x11ZO\xd8\xf4\t\xddM\x16-\x04\xfc\x18<\""
1878 b"CM\xddg~b\xf6\xef\x8e\x0c\xd0\xde|\xa0'\x8a\x0c\xd6x\xae!J\xa6F\x88\x15u"
1879 b"\x008\x17\xbc7y\xb3\xd8u\xac_\x85\x8d\xe7\xc1@\x9c\xecqc\xa3#\xad\xf1"
1880 b"\x935\xb5)_\r\xec3]\x0fo]5\xd0my\x07\x9b\xee\x81\xb5\x0f\xcfK+\x00\xc0"
1881 b"\xe4b\x10\xe4\x0c\x1a \x9b\xe0\x97t\xf6\xa1\x9e\x850\xba\x0c\x9a\x8d\xc8"
1882 b"\x8f\x07\xd7\xae\xc8\xf9+i\xdc\xb9k\xb0>f\x19\xb8\r\xa8\xf8\x1f$\xa5{p"
1883 b"\xc6\x880\xce\xdb\xcf\xca_\x86\xac\x88h6\x8bZ%'\xd0\n\xbf\x0f\x9c\"\xba"
1884 b"\xe5\x86\x9f\x0f7X=mNX[\xcc\x19FU\xc9\x860\xbc\x90a+* \xae_$\x03\x1e\xd3"
1885 b"\xcd_\xa0\x9c\xde\xaf46q\xa5\xc9\x92\xd7\xca\xe3`\x9d\x85}\xb4\xff\xb3"
1886 b"\x83\xfb\xb6\xca\xae`\x0bw\x7f\xfc\xd8\xacVe\x19\xc8\x17\x0bZ\xad\x88"
1887 b"\xeb#\x97\x03\x13\xb1d\x0f{\x0c\x04w\x07\r\x97\xbd\xd6\xc1\xc3B:\x95\x08"
1888 b"^\x10V\xaeaH\x02\xd9\xe3\n\\\x01X\xf6\x9c\x8a\x06u#%\xbe*\xa1\x18v\x85"
1889 b"\xec!\t4\x00\x00\x00"
1890 )
1891
1892 FILTERS_RAW_4 = [{"id": lzma.FILTER_DELTA, "dist": 4},
1893 {"id": lzma.FILTER_X86, "start_offset": 0x40},
1894 {"id": lzma.FILTER_LZMA2, "preset": 4, "lc": 2}]
1895 COMPRESSED_RAW_4 = (
1896 b"\xe0\x07\x80\x06\x0e\\\x00\x05\x14\x07bW\xaah\xdd\x10\xdc'\xd6\x90,\xc6v"
1897 b"Jq \x14l\xb7\x83xB\x0b\x97f=&fx\xba\n>Tn\xbf\x8f\xfb\x1dF\xca\xc3v_\xca?"
1898 b"\xfbV<\x92#\xd4w\xa6\x8a\xeb\xf6\x03\xc0\x01\x94\xd8\x9e\x13\x12\x98\xd1"
1899 b"*\xfa]c\xe8\x1e~\xaf\xb5]Eg\xfb\x9e\x01\"8\xb2\x90\x06=~\xe9\x91W\xcd"
1900 b"\xecD\x12\xc7\xfa\xe1\x91\x06\xc7\x99\xb9\xe3\x901\x87\x19u\x0f\x869\xff"
1901 b"\xc1\xb0hw|\xb0\xdcl\xcck\xb16o7\x85\xee{Y_b\xbf\xbc$\xf3=\x8d\x8bw\xe5Z"
1902 b"\x08@\xc4kmE\xad\xfb\xf6*\xd8\xad\xa1\xfb\xc5{\xdej,)\x1emB\x1f<\xaeca"
1903 b"\x80(\xee\x07 \xdf\xe9\xf8\xeb\x0e-\x97\x86\x90c\xf9\xea'B\xf7`\xd7\xb0"
1904 b"\x92\xbd\xa0\x82]\xbd\x0e\x0eB\x19\xdc\x96\xc6\x19\xd86D\xf0\xd5\x831"
1905 b"\x03\xb7\x1c\xf7&5\x1a\x8f PZ&j\xf8\x98\x1bo\xcc\x86\x9bS\xd3\xa5\xcdu"
1906 b"\xf9$\xcc\x97o\xe5V~\xfb\x97\xb5\x0b\x17\x9c\xfdxW\x10\xfep4\x80\xdaHDY"
1907 b"\xfa)\xfet\xb5\"\xd4\xd3F\x81\xf4\x13\x1f\xec\xdf\xa5\x13\xfc\"\x91x\xb7"
1908 b"\x99\xce\xc8\x92\n\xeb[\x10l*Y\xd8\xb1@\x06\xc8o\x8d7r\xebu\xfd5\x0e\x7f"
1909 b"\xf1$U{\t}\x1fQ\xcfxN\x9d\x9fXX\xe9`\x83\xc1\x06\xf4\x87v-f\x11\xdb/\\"
1910 b"\x06\xff\xd7)B\xf3g\x06\x88#2\x1eB244\x7f4q\t\xc893?mPX\x95\xa6a\xfb)d"
1911 b"\x9b\xfc\x98\x9aj\x04\xae\x9b\x9d\x19w\xba\xf92\xfaA\x11\\\x17\x97C3\xa4"
1912 b"\xbc!\x88\xcdo[\xec:\x030\x91.\x85\xe0@\\4\x16\x12\x9d\xcaJv\x97\xb04"
1913 b"\xack\xcbkf\xa3ss\xfc\x16^\x8ce\x85a\xa5=&\xecr\xb3p\xd1E\xd5\x80y\xc7"
1914 b"\xda\xf6\xfek\xbcT\xbfH\xee\x15o\xc5\x8c\x830\xec\x1d\x01\xae\x0c-e\\"
1915 b"\x91\x90\x94\xb2\xf8\x88\x91\xe8\x0b\xae\xa7>\x98\xf6\x9ck\xd2\xc6\x08"
1916 b"\xe6\xab\t\x98\xf2!\xa0\x8c^\xacqA\x99<\x1cEG\x97\xc8\xf1\xb6\xb9\x82"
1917 b"\x8d\xf7\x08s\x98a\xff\xe3\xcc\x92\x0e\xd2\xb6U\xd7\xd9\x86\x7fa\xe5\x1c"
1918 b"\x8dTG@\t\x1e\x0e7*\xfc\xde\xbc]6N\xf7\xf1\x84\x9e\x9f\xcf\xe9\x1e\xb5'"
1919 b"\xf4<\xdf\x99sq\xd0\x9d\xbd\x99\x0b\xb4%p4\xbf{\xbb\x8a\xd2\x0b\xbc=M"
1920 b"\x94H:\xf5\xa8\xd6\xa4\xc90\xc2D\xb9\xd3\xa8\xb0S\x87 `\xa2\xeb\xf3W\xce"
1921 b" 7\xf9N#\r\xe6\xbe\t\x9d\xe7\x811\xf9\x10\xc1\xc2\x14\xf6\xfc\xcba\xb7"
1922 b"\xb1\x7f\x95l\xe4\tjA\xec:\x10\xe5\xfe\xc2\\=D\xe2\x0c\x0b3]\xf7\xc1\xf7"
1923 b"\xbceZ\xb1A\xea\x16\xe5\xfddgFQ\xed\xaf\x04\xa3\xd3\xf8\xa2q\x19B\xd4r"
1924 b"\xc5\x0c\x9a\x14\x94\xea\x91\xc4o\xe4\xbb\xb4\x99\xf4@\xd1\xe6\x0c\xe3"
1925 b"\xc6d\xa0Q\n\xf2/\xd8\xb8S5\x8a\x18:\xb5g\xac\x95D\xce\x17\x07\xd4z\xda"
1926 b"\x90\xe65\x07\x19H!\t\xfdu\x16\x8e\x0eR\x19\xf4\x8cl\x0c\xf9Q\xf1\x80"
1927 b"\xe3\xbf\xd7O\xf8\x8c\x18\x0b\x9c\xf1\x1fb\xe1\tR\xb2\xf1\xe1A\xea \xcf-"
1928 b"IGE\xf1\x14\x98$\x83\x15\xc9\xd8j\xbf\x19\x0f\xd5\xd1\xaa\xb3\xf3\xa5I2s"
1929 b"\x8d\x145\xca\xd5\xd93\x9c\xb8D0\xe6\xaa%\xd0\xc0P}JO^h\x8e\x08\xadlV."
1930 b"\x18\x88\x13\x05o\xb0\x07\xeaw\xe0\xb6\xa4\xd5*\xe4r\xef\x07G+\xc1\xbei["
1931 b"w\xe8\xab@_\xef\x15y\xe5\x12\xc9W\x1b.\xad\x85-\xc2\xf7\xe3mU6g\x8eSA"
1932 b"\x01(\xd3\xdb\x16\x13=\xde\x92\xf9,D\xb8\x8a\xb2\xb4\xc9\xc3\xefnE\xe8\\"
1933 b"\xa6\xe2Y\xd2\xcf\xcb\x8c\xb6\xd5\xe9\x1d\x1e\x9a\x8b~\xe2\xa6\rE\x84uV"
1934 b"\xed\xc6\x99\xddm<\x10[\x0fu\x1f\xc1\x1d1\n\xcfw\xb2%!\xf0[\xce\x87\x83B"
1935 b"\x08\xaa,\x08%d\xcef\x94\"\xd9g.\xc83\xcbXY+4\xec\x85qA\n\x1d=9\xf0*\xb1"
1936 b"\x1f/\xf3s\xd61b\x7f@\xfb\x9d\xe3FQ\\\xbd\x82\x1e\x00\xf3\xce\xd3\xe1"
1937 b"\xca,E\xfd7[\xab\xb6\xb7\xac!mA}\xbd\x9d3R5\x9cF\xabH\xeb\x92)cc\x13\xd0"
1938 b"\xbd\xee\xe9n{\x1dIJB\xa5\xeb\x11\xe8`w&`\x8b}@Oxe\t\x8a\x07\x02\x95\xf2"
1939 b"\xed\xda|\xb1e\xbe\xaa\xbbg\x19@\xe1Y\x878\x84\x0f\x8c\xe3\xc98\xf2\x9e"
1940 b"\xd5N\xb5J\xef\xab!\xe2\x8dq\xe1\xe5q\xc5\xee\x11W\xb7\xe4k*\x027\xa0"
1941 b"\xa3J\xf4\xd8m\xd0q\x94\xcb\x07\n:\xb6`.\xe4\x9c\x15+\xc0)\xde\x80X\xd4"
1942 b"\xcfQm\x01\xc2cP\x1cA\x85'\xc9\xac\x8b\xe6\xb2)\xe6\x84t\x1c\x92\xe4Z"
1943 b"\x1cR\xb0\x9e\x96\xd1\xfb\x1c\xa6\x8b\xcb`\x10\x12]\xf2gR\x9bFT\xe0\xc8H"
1944 b"S\xfb\xac<\x04\xc7\xc1\xe8\xedP\xf4\x16\xdb\xc0\xd7e\xc2\x17J^\x1f\xab"
1945 b"\xff[\x08\x19\xb4\xf5\xfb\x19\xb4\x04\xe5c~']\xcb\xc2A\xec\x90\xd0\xed"
1946 b"\x06,\xc5K{\x86\x03\xb1\xcdMx\xdeQ\x8c3\xf9\x8a\xea=\x89\xaba\xd2\xc89a"
1947 b"\xd72\xf0\xc3\x19\x8a\xdfs\xd4\xfd\xbb\x81b\xeaE\"\xd8\xf4d\x0cD\xf7IJ!"
1948 b"\xe5d\xbbG\xe9\xcam\xaa\x0f_r\x95\x91NBq\xcaP\xce\xa7\xa9\xb5\x10\x94eP!"
1949 b"|\x856\xcd\xbfIir\xb8e\x9bjP\x97q\xabwS7\x1a\x0ehM\xe7\xca\x86?\xdeP}y~"
1950 b"\x0f\x95I\xfc\x13\xe1<Q\x1b\x868\x1d\x11\xdf\x94\xf4\x82>r\xa9k\x88\xcb"
1951 b"\xfd\xc3v\xe2\xb9\x8a\x02\x8eq\x92I\xf8\xf6\xf1\x03s\x9b\xb8\xe3\"\xe3"
1952 b"\xa9\xa5>D\xb8\x96;\xe7\x92\xd133\xe8\xdd'e\xc9.\xdc;\x17\x1f\xf5H\x13q"
1953 b"\xa4W\x0c\xdb~\x98\x01\xeb\xdf\xe32\x13\x0f\xddx\n6\xa0\t\x10\xb6\xbb"
1954 b"\xb0\xc3\x18\xb6;\x9fj[\xd9\xd5\xc9\x06\x8a\x87\xcd\xe5\xee\xfc\x9c-%@"
1955 b"\xee\xe0\xeb\xd2\xe3\xe8\xfb\xc0\x122\\\xc7\xaf\xc2\xa1Oth\xb3\x8f\x82"
1956 b"\xb3\x18\xa8\x07\xd5\xee_\xbe\xe0\x1cA\x1e_\r\x9a\xb0\x17W&\xa2D\x91\x94"
1957 b"\x1a\xb2\xef\xf2\xdc\x85;X\xb0,\xeb>-7S\xe5\xca\x07)\x1fp\x7f\xcaQBL\xca"
1958 b"\xf3\xb9d\xfc\xb5su\xb0\xc8\x95\x90\xeb*)\xa0v\xe4\x9a{FW\xf4l\xde\xcdj"
1959 b"\x00"
1960 )
1961
1962 ISSUE_21872_DAT = (
1963 b']\x00\x00@\x00h3\x00\x00\x00\x00\x00\x00\x00\x00`D\x0c\x99\xc8'
1964 b'\xd1\xbbZ^\xc43+\x83\xcd\xf1\xc6g\xec-\x061F\xb1\xbb\xc7\x17%-\xea'
1965 b'\xfap\xfb\x8fs\x128\xb2,\x88\xe4\xc0\x12|*x\xd0\xa2\xc4b\x1b!\x02c'
1966 b'\xab\xd9\x87U\xb8n \xfaVJ\x9a"\xb78\xff%_\x17`?@*\xc2\x82'
1967 b"\xf2^\x1b\xb8\x04&\xc0\xbb\x03g\x9d\xca\xe9\xa4\xc9\xaf'\xe5\x8e}"
1968 b'F\xdd\x11\xf3\x86\xbe\x1fN\x95\\\xef\xa2Mz-\xcb\x9a\xe3O@'
1969 b"\x19\x07\xf6\xee\x9e\x9ag\xc6\xa5w\rnG'\x99\xfd\xfeGI\xb0"
1970 b'\xbb\xf9\xc2\xe1\xff\xc5r\xcf\x85y[\x01\xa1\xbd\xcc/\xa3\x1b\x83\xaa'
1971 b'\xc6\xf9\x99\x0c\xb6_\xc9MQ+x\xa2F\xda]\xdd\xe8\xfb\x1a&'
1972 b',\xc4\x19\x1df\x81\x1e\x90\xf3\xb8Hgr\x85v\xbe\xa3qx\x01Y\xb5\x9fF'
1973 b"\x13\x18\x01\xe69\x9b\xc8'\x1e\x9d\xd6\xe4F\x84\xac\xf8d<\x11\xd5"
1974 b'\\\x0b\xeb\x0e\x82\xab\xb1\xe6\x1fka\xe1i\xc4 C\xb1"4)\xd6\xa7`\x02'
1975 b'\xec\x11\x8c\xf0\x14\xb0\x1d\x1c\xecy\xf0\xb7|\x11j\x85X\xb2!\x1c'
1976 b'\xac\xb5N\xc7\x85j\x9ev\xf5\xe6\x0b\xc1]c\xc15\x16\x9f\xd5\x99'
1977 b"\xfei^\xd2G\x9b\xbdl\xab:\xbe,\xa9'4\x82\xe5\xee\xb3\xc1"
1978 b'$\x93\x95\xa8Y\x16\xf5\xbf\xacw\x91\x04\x1d\x18\x06\xe9\xc5\xfdk\x06'
1979 b'\xe8\xfck\xc5\x86>\x8b~\xa4\xcb\xf1\xb3\x04\xf1\x04G5\xe2\xcc]'
1980 b'\x16\xbf\x140d\x18\xe2\xedw#(3\xca\xa1\x80bX\x7f\xb3\x84'
1981 b'\x9d\xdb\xe7\x08\x97\xcd\x16\xb9\xf1\xd5r+m\x1e\xcb3q\xc5\x9e\x92'
1982 b"\x7f\x8e*\xc7\xde\xe9\xe26\xcds\xb1\x10-\xf6r\x02?\x9d\xddCgJN'"
1983 b'\x11M\xfa\nQ\n\xe6`m\xb8N\xbbq\x8el\x0b\x02\xc7:q\x04G\xa1T'
1984 b'\xf1\xfe!0\x85~\xe5\x884\xe9\x89\xfb\x13J8\x15\xe42\xb6\xad'
1985 b'\x877A\x9a\xa6\xbft]\xd0\xe35M\xb0\x0cK\xc8\xf6\x88\xae\xed\xa9,j7'
1986 b'\x81\x13\xa0(\xcb\xe1\xe9l2\x7f\xcd\xda\x95(\xa70B\xbd\xf4\xe3'
1987 b'hp\x94\xbdJ\xd7\t\xc7g\xffo?\x89?\xf8}\x7f\xbc\x1c\x87'
1988 b'\x14\xc0\xcf\x8cV:\x9a\x0e\xd0\xb2\x1ck\xffk\xb9\xe0=\xc7\x8d/'
1989 b'\xb8\xff\x7f\x1d\x87`\x19.\x98X*~\xa7j\xb9\x0b"\xf4\xe4;V`\xb9\xd7'
1990 b'\x03\x1e\xd0t0\xd3\xde\x1fd\xb9\xe2)\x16\x81}\xb1\\b\x7fJ'
1991 b'\x92\xf4\xff\n+V!\xe9\xde\x98\xa0\x8fK\xdf7\xb9\xc0\x12\x1f\xe2'
1992 b'\xe9\xb0`\xae\x14\r\xa7\xc4\x81~\xd8\x8d\xc5\x06\xd8m\xb0Y\x8a)'
1993 b'\x06/\xbb\xf9\xac\xeaP\xe0\x91\x05m[\xe5z\xe6Z\xf3\x9f\xc7\xd0'
1994 b'\xd3\x8b\xf3\x8a\x1b\xfa\xe4Pf\xbc0\x17\x10\xa9\xd0\x95J{\xb3\xc3'
1995 b'\xfdW\x9bop\x0f\xbe\xaee\xa3]\x93\x9c\xda\xb75<\xf6g!\xcc\xb1\xfc\\'
1996 b'7\x152Mc\x17\x84\x9d\xcd35\r0\xacL-\xf3\xfb\xcb\x96\x1e\xe9U\x7f'
1997 b'\xd7\xca\xb0\xcc\x89\x0c*\xce\x14\xd1P\xf1\x03\xb6.~9o?\xe8'
1998 b'\r\x86\xe0\x92\x87}\xa3\x84\x03P\xe0\xc2\x7f\n;m\x9d\x9e\xb4|'
1999 b'\x8c\x18\xc0#0\xfe3\x07<\xda\xd8\xcf^\xd4Hi\xd6\xb3\x0bT'
2000 b'\x1dF\x88\x85q}\x02\xc6&\xc4\xae\xce\x9cU\xfa\x0f\xcc\xb6\x1f\x11'
2001 b'drw\x9eN\x19\xbd\xffz\x0f\xf0\x04s\xadR\xc1\xc0\xbfl\xf1\xba\xf95^'
2002 b'e\xb1\xfbVY\xd9\x9f\x1c\xbf*\xc4\xa86\x08+\xd6\x88[\xc4_rc\xf0f'
2003 b'\xb8\xd4\xec\x1dx\x19|\xbf\xa7\xe0\x82\x0b\x8c~\x10L/\x90\xd6\xfb'
2004 b'\x81\xdb\x98\xcc\x02\x14\xa5C\xb2\xa7i\xfd\xcd\x1fO\xf7\xe9\x89t\xf0'
2005 b'\x17\xa5\x1c\xad\xfe<Q`%\x075k\n7\x9eI\x82<#)&\x04\xc2\xf0C\xd4`!'
2006 b'\xcb\xa9\xf9\xb3F\x86\xb5\xc3M\xbeu\x12\xb2\xca\x95e\x10\x0b\xb1\xcc'
2007 b'\x01b\x9bXa\x1b[B\x8c\x07\x11Of;\xeaC\xebr\x8eb\xd9\x9c\xe4i]<z\x9a'
2008 b'\x03T\x8b9pF\x10\x8c\x84\xc7\x0e\xeaPw\xe5\xa0\x94\x1f\x84\xdd'
2009 b'a\xe8\x85\xc2\x00\xebq\xe7&Wo5q8\xc2t\x98\xab\xb7\x7f\xe64-H'
2010 b'\t\xb4d\xbe\x06\xe3Q\x8b\xa9J\xb0\x00\xd7s.\x85"\xc0p\x05'
2011 b'\x1c\x06N\x87\xa5\xf8\xc3g\x1b}\x0f\x0f\xc3|\x90\xea\xefd3X'
2012 b'[\xab\x04E\xf2\xf2\xc9\x08\x8a\xa8+W\xa2v\xec\x15G\x08/I<L\\1'
2013 b'\xff\x15O\xaa\x89{\xd1mW\x13\xbd~\xe1\x90^\xc4@\r\xed\xb5D@\xb4\x08'
2014 b'A\x90\xe69;\xc7BO\xdb\xda\xebu\x9e\xa9tN\xae\x8aJ5\xcd\x11\x1d\xea'
2015 b"\xe5\xa7\x04\xe6\x82Z\xc7O\xe46[7\xdco*[\xbe\x0b\xc9\xb7a\xab'\xf6"
2016 b"\xd1u\xdb\xd9q\xf5+y\x1b\x00\xb4\xf3a\xae\xf1M\xc4\xbc\xd00'\x06pQ"
2017 b'\x8dH\xaa\xaa\xc4\xd2K\x9b\xc0\xe9\xec=n\xa9\x1a\x8a\xc2\xe8\x18\xbc'
2018 b'\x93\xb8F\xa1\x8fOY\xe7\xda\xcf0\t\xff|\xd9\xe5\xcf\xe7\xf6\xbe'
2019 b'\xf8\x04\x17\xf2\xe5P\xa7y~\xce\x11h0\x81\x80d[\x00_v\xbbc\xdbI'
2020 b'3\xbc`W\xc0yrkB\xf5\x9f\xe9i\xc5\x8a^\x8d\xd4\x81\xd9\x05\xc1\xfc>'
2021 b'"\xd1v`\x82\xd5$\x89\xcf^\xd52.\xafd\xe8d@\xaa\xd5Y|\x90\x84'
2022 b'j\xdb}\x84riV\x8e\xf0X4rB\xf2NPS[\x8e\x88\xd4\x0fI\xb8'
2023 b'\xdd\xcb\x1d\xf2(\xdf;9\x9e|\xef^0;.*[\x9fl\x7f\xa2_X\xaff!\xbb\x03'
2024 b'\xff\x19\x8f\x88\xb5\xb6\x884\xa3\x05\xde3D{\xe3\xcb\xce\xe4t]'
2025 b'\x875\xe3Uf\xae\xea\x88\x1c\x03b\n\xb1,Q\xec\xcf\x08\t\xde@\x83\xaa<'
2026 b',-\xe4\xee\x9b\x843\xe5\x007\tK\xac\x057\xd6*X\xa3\xc6~\xba\xe6O'
2027 b'\x81kz"\xbe\xe43sL\xf1\xfa;\xf4^\x1e\xb4\x80\xe2\xbd\xaa\x17Z\xe1f'
2028 b'\xda\xa6\xb9\x07:]}\x9fa\x0b?\xba\xe7\xf15\x04M\xe3\n}M\xa4\xcb\r'
2029 b'2\x8a\x88\xa9\xa7\x92\x93\x84\x81Yo\x00\xcc\xc4\xab\x9aT\x96\x0b\xbe'
2030 b'U\xac\x1d\x8d\x1b\x98"\xf8\x8f\xf1u\xc1n\xcc\xfcA\xcc\x90\xb7i'
2031 b'\x83\x9c\x9c~\x1d4\xa2\xf0*J\xe7t\x12\xb4\xe3\xa0u\xd7\x95Z'
2032 b'\xf7\xafG\x96~ST,\xa7\rC\x06\xf4\xf0\xeb`2\x9e>Q\x0e\xf6\xf5\xc5'
2033 b'\x9b\xb5\xaf\xbe\xa3\x8f\xc0\xa3hu\x14\x12 \x97\x99\x04b\x8e\xc7\x1b'
2034 b'VKc\xc1\xf3 \xde\x85-:\xdc\x1f\xac\xce*\x06\xb3\x80;`'
2035 b'\xdb\xdd\x97\xfdg\xbf\xe7\xa8S\x08}\xf55e7\xb8/\xf0!\xc8'
2036 b"Y\xa8\x9a\x07'\xe2\xde\r\x02\xe1\xb2\x0c\xf4C\xcd\xf9\xcb(\xe8\x90"
2037 b'\xd3bTD\x15_\xf6\xc3\xfb\xb3E\xfc\xd6\x98{\xc6\\fz\x81\xa99\x85\xcb'
2038 b'\xa5\xb1\x1d\x94bqW\x1a!;z~\x18\x88\xe8i\xdb\x1b\x8d\x8d'
2039 b'\x06\xaa\x0e\x99s+5k\x00\xe4\xffh\xfe\xdbt\xa6\x1bU\xde\xa3'
2040 b'\xef\xcb\x86\x9e\x81\x16j\n\x9d\xbc\xbbC\x80?\x010\xc7Jj;'
2041 b'\xc4\xe5\x86\xd5\x0e0d#\xc6;\xb8\xd1\xc7c\xb5&8?\xd9J\xe5\xden\xb9'
2042 b'\xe9cb4\xbb\xe6\x14\xe0\xe7l\x1b\x85\x94\x1fh\xf1n\xdeZ\xbe'
2043 b'\x88\xff\xc2e\xca\xdc,B-\x8ac\xc9\xdf\xf5|&\xe4LL\xf0\x1f\xaa8\xbd'
2044 b'\xc26\x94bVi\xd3\x0c\x1c\xb6\xbb\x99F\x8f\x0e\xcc\x8e4\xc6/^W\xf5?'
2045 b'\xdc\x84(\x14dO\x9aD6\x0f4\xa3,\x0c\x0bS\x9fJ\xe1\xacc^\x8a0\t\x80D['
2046 b'\xb8\xe6\x86\xb0\xe8\xd4\xf9\x1en\xf1\xf5^\xeb\xb8\xb8\xf8'
2047 b')\xa8\xbf\xaa\x84\x86\xb1a \x95\x16\x08\x1c\xbb@\xbd+\r/\xfb'
2048 b'\x92\xfbh\xf1\x8d3\xf9\x92\xde`\xf1\x86\x03\xaa+\xd9\xd9\xc6P\xaf'
2049 b'\xe3-\xea\xa5\x0fB\xca\xde\xd5n^\xe3/\xbf\xa6w\xc8\x0e<M'
2050 b'\xc2\x1e!\xd4\xc6E\xf2\xad\x0c\xbc\x1d\x88Y\x03\x98<\x92\xd9\xa6B'
2051 b'\xc7\x83\xb5"\x97D|&\xc4\xd4\xfad\x0e\xde\x06\xa3\xc2\x9c`\xf2'
2052 b'7\x03\x1a\xed\xd80\x10\xe9\x0co\x10\xcf\x18\x16\xa7\x1c'
2053 b"\xe5\x96\xa4\xd9\xe1\xa5v;]\xb7\xa9\xdc'hA\xe3\x9c&\x98\x0b9\xdf~@"
2054 b'\xf8\xact\x87<\xf94\x0c\x9d\x93\xb0)\xe1\xa2\x0f\x1e=:&\xd56\xa5A+'
2055 b'\xab\xc4\x00\x8d\x81\x93\xd4\xd8<\x82k\\d\xd8v\xab\xbd^l5C?\xd4\xa0'
2056 b'M\x12C\xc8\x80\r\xc83\xe8\xc0\xf5\xdf\xca\x05\xf4BPjy\xbe\x91\x9bzE'
2057 b"\xd8[\x93oT\r\x13\x16'\x1a\xbd*H\xd6\xfe\r\xf3\x91M\x8b\xee\x8f7f"
2058 b"\x0b;\xaa\x85\xf2\xdd'\x0fwM \xbd\x13\xb9\xe5\xb8\xb7 D+P\x1c\xe4g"
2059 b'n\xd2\xf1kc\x15\xaf\xc6\x90V\x03\xc2UovfZ\xcc\xd23^\xb3\xe7\xbf'
2060 b'\xacv\x1d\x82\xedx\xa3J\xa9\xb7\xcf\x0c\xe6j\x96n*o\x18>'
2061 b'\xc6\xfd\x97_+D{\x03\x15\xe8s\xb1\xc8HAG\xcf\xf4\x1a\xdd'
2062 b'\xad\x11\xbf\x157q+\xdeW\x89g"X\x82\xfd~\xf7\xab4\xf6`\xab\xf1q'
2063 b')\x82\x10K\xe9sV\xfe\xe45\xafs*\x14\xa7;\xac{\x06\x9d<@\x93G'
2064 b'j\x1d\xefL\xe9\xd8\x92\x19&\xa1\x16\x19\x04\tu5\x01]\xf6\xf4'
2065 b'\xcd\\\xd8A|I\xd4\xeb\x05\x88C\xc6e\xacQ\xe9*\x97~\x9au\xf8Xy'
2066 b"\x17P\x10\x9f\n\x8c\xe2fZEu>\x9b\x1e\x91\x0b'`\xbd\xc0\xa8\x86c\x1d"
2067 b'Z\xe2\xdc8j\x95\xffU\x90\x1e\xf4o\xbc\xe5\xe3e>\xd2R\xc0b#\xbc\x15'
2068 b'H-\xb9!\xde\x9d\x90k\xdew\x9b{\x99\xde\xf7/K)A\xfd\xf5\xe6:\xda'
2069 b'UM\xcc\xbb\xa2\x0b\x9a\x93\xf5{9\xc0 \xd2((6i\xc0\xbbu\xd8\x9e\x8d'
2070 b'\xf8\x04q\x10\xd4\x14\x9e7-\xb9B\xea\x01Q8\xc8v\x9a\x12A\x88Cd\x92'
2071 b"\x1c\x8c!\xf4\x94\x87'\xe3\xcd\xae\xf7\xd8\x93\xfa\xde\xa8b\x9e\xee2"
2072 b'K\xdb\x00l\x9d\t\xb1|D\x05U\xbb\xf4>\xf1w\x887\xd1}W\x9d|g|1\xb0\x13'
2073 b"\xa3 \xe5\xbfm@\xc06+\xb7\t\xcf\x15D\x9a \x1fM\x1f\xd2\xb5'\xa9\xbb"
2074 b'~Co\x82\xfa\xc2\t\xe6f\xfc\xbeI\xae1\x8e\xbe\xb8\xcf\x86\x17'
2075 b'\x9f\xe2`\xbd\xaf\xba\xb9\xbc\x1b\xa3\xcd\x82\x8fwc\xefd\xa9\xd5\x14'
2076 b'\xe2C\xafUE\xb6\x11MJH\xd0=\x05\xd4*I\xff"\r\x1b^\xcaS6=\xec@\xd5'
2077 b'\x11,\xe0\x87Gr\xaa[\xb8\xbc>n\xbd\x81\x0c\x07<\xe9\x92('
2078 b'\xb2\xff\xac}\xe7\xb6\x15\x90\x9f~4\x9a\xe6\xd6\xd8s\xed\x99tf'
2079 b'\xa0f\xf8\xf1\x87\t\x96/)\x85\xb6\n\xd7\xb2w\x0b\xbc\xba\x99\xee'
2080 b'Q\xeen\x1d\xad\x03\xc3s\xd1\xfd\xa2\xc6\xb7\x9a\x9c(G<6\xad[~H '
2081 b'\x16\x89\x89\xd0\xc3\xd2\xca~\xac\xea\xa5\xed\xe5\xfb\r:'
2082 b'\x8e\xa6\xf1e\xbb\xba\xbd\xe0(\xa3\x89_\x01(\xb5c\xcc\x9f\x1fg'
2083 b'v\xfd\x17\xb3\x08S=S\xee\xfc\x85>\x91\x8d\x8d\nYR\xb3G\xd1A\xa2\xb1'
2084 b'\xec\xb0\x01\xd2\xcd\xf9\xfe\x82\x06O\xb3\xecd\xa9c\xe0\x8eP\x90\xce'
2085 b'\xe0\xcd\xd8\xd8\xdc\x9f\xaa\x01"[Q~\xe4\x88\xa1#\xc1\x12C\xcf'
2086 b'\xbe\x80\x11H\xbf\x86\xd8\xbem\xcfWFQ(X\x01DK\xdfB\xaa\x10.-'
2087 b'\xd5\x9e|\x86\x15\x86N]\xc7Z\x17\xcd=\xd7)M\xde\x15\xa4LTi\xa0\x15'
2088 b'\xd1\xe7\xbdN\xa4?\xd1\xe7\x02\xfe4\xe4O\x89\x98&\x96\x0f\x02\x9c'
2089 b'\x9e\x19\xaa\x13u7\xbd0\xdc\xd8\x93\xf4BNE\x1d\x93\x82\x81\x16'
2090 b'\xe5y\xcf\x98D\xca\x9a\xe2\xfd\xcdL\xcc\xd1\xfc_\x0b\x1c\xa0]\xdc'
2091 b'\xa91 \xc9c\xd8\xbf\x97\xcfp\xe6\x19-\xad\xff\xcc\xd1N(\xe8'
2092 b'\xeb#\x182\x96I\xf7l\xf3r\x00'
2093 )
2094
2095
2096 if __name__ == "__main__":
2097 unittest.main()