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