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