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