Lines Matching refs:self
26 def test_simple_bad_args(self):
27 self.assertRaises(TypeError, LZMACompressor, [])
28 self.assertRaises(TypeError, LZMACompressor, format=3.45)
29 self.assertRaises(TypeError, LZMACompressor, check="")
30 self.assertRaises(TypeError, LZMACompressor, preset="asdf")
31 self.assertRaises(TypeError, LZMACompressor, filters=3)
33 self.assertRaises(ValueError, LZMACompressor, format=lzma.FORMAT_AUTO)
35 with self.assertRaises(ValueError):
38 self.assertRaises(TypeError, LZMADecompressor, ())
39 self.assertRaises(TypeError, LZMADecompressor, memlimit=b"qw")
40 with self.assertRaises(TypeError):
43 with self.assertRaises(ValueError):
46 self.assertRaises(ValueError, LZMADecompressor, filters=FILTERS_RAW_1)
47 with self.assertRaises(ValueError):
49 with self.assertRaises(ValueError):
53 self.assertRaises(TypeError, lzc.compress)
54 self.assertRaises(TypeError, lzc.compress, b"foo", b"bar")
55 self.assertRaises(TypeError, lzc.flush, b"blah")
57 self.assertRaises(ValueError, lzc.compress, b"quux")
58 self.assertRaises(ValueError, lzc.flush)
61 self.assertRaises(TypeError, lzd.decompress)
62 self.assertRaises(TypeError, lzd.decompress, b"foo", b"bar")
64 self.assertRaises(EOFError, lzd.decompress, b"quux")
66 def test_bad_filter_spec(self):
67 self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
68 self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])
69 self.assertRaises(ValueError, LZMACompressor, filters=[{"id": 98765}])
70 with self.assertRaises(ValueError):
72 with self.assertRaises(ValueError):
74 with self.assertRaises(ValueError):
77 def test_decompressor_after_eof(self):
80 self.assertRaises(EOFError, lzd.decompress, b"nyan")
82 def test_decompressor_memlimit(self):
84 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
87 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
90 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_ALONE)
94 def _test_decompressor(self, lzd, data, check, unused_data=b""):
95 self.assertFalse(lzd.eof)
97 self.assertEqual(out, INPUT)
98 self.assertEqual(lzd.check, check)
99 self.assertTrue(lzd.eof)
100 self.assertEqual(lzd.unused_data, unused_data)
102 def test_decompressor_auto(self):
104 self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
107 self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
109 def test_decompressor_xz(self):
111 self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
113 def test_decompressor_alone(self):
115 self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
117 def test_decompressor_raw_1(self):
119 self._test_decompressor(lzd, COMPRESSED_RAW_1, lzma.CHECK_NONE)
121 def test_decompressor_raw_2(self):
123 self._test_decompressor(lzd, COMPRESSED_RAW_2, lzma.CHECK_NONE)
125 def test_decompressor_raw_3(self):
127 self._test_decompressor(lzd, COMPRESSED_RAW_3, lzma.CHECK_NONE)
129 def test_decompressor_raw_4(self):
131 self._test_decompressor(lzd, COMPRESSED_RAW_4, lzma.CHECK_NONE)
133 def test_decompressor_chunks(self):
137 self.assertFalse(lzd.eof)
140 self.assertEqual(out, INPUT)
141 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
142 self.assertTrue(lzd.eof)
143 self.assertEqual(lzd.unused_data, b"")
145 def test_decompressor_chunks_empty(self):
149 self.assertFalse(lzd.eof)
155 self.assertEqual(out, INPUT)
156 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
157 self.assertTrue(lzd.eof)
158 self.assertEqual(lzd.unused_data, b"")
160 def test_decompressor_chunks_maxsize(self):
169 self.assertFalse(lzd.needs_input)
170 self.assertEqual(len(out[-1]), max_length)
174 self.assertFalse(lzd.needs_input)
175 self.assertEqual(len(out[-1]), max_length)
180 self.assertLessEqual(len(out[-1]), max_length)
185 self.assertLessEqual(len(out[-1]), max_length)
188 self.assertEqual(out, INPUT)
189 self.assertEqual(lzd.check, lzma.CHECK_CRC64)
190 self.assertEqual(lzd.unused_data, b"")
192 def test_decompressor_inputbuf_1(self):
199 self.assertEqual(lzd.decompress(COMPRESSED_XZ[:100],
212 self.assertEqual(b''.join(out), INPUT)
214 def test_decompressor_inputbuf_2(self):
221 self.assertEqual(lzd.decompress(COMPRESSED_XZ[:200],
233 self.assertEqual(b''.join(out), INPUT)
235 def test_decompressor_inputbuf_3(self):
249 self.assertEqual(b''.join(out), INPUT)
251 def test_decompressor_unused_data(self):
254 self._test_decompressor(lzd, COMPRESSED_XZ + extra, lzma.CHECK_CRC64,
257 def test_decompressor_bad_input(self):
259 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
262 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_ALONE)
265 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
268 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
270 def test_decompressor_bug_28275(self):
273 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
275 self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
279 def test_roundtrip_xz(self):
283 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
285 def test_roundtrip_alone(self):
289 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
291 def test_roundtrip_raw(self):
295 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
297 def test_roundtrip_raw_empty(self):
305 self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
307 def test_roundtrip_chunks(self):
315 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
317 def test_roundtrip_empty_chunks(self):
328 self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
332 def test_decompressor_multistream(self):
334 self._test_decompressor(lzd, COMPRESSED_XZ + COMPRESSED_ALONE,
341 def test_compressor_bigmem(self, size):
346 self.assertEqual(len(ddata), size)
347 self.assertEqual(len(ddata.strip(b"x")), 0)
353 def test_decompressor_bigmem(self, size):
361 self.assertEqual(ddata, input)
367 def test_pickle(self):
369 with self.assertRaises(TypeError):
371 with self.assertRaises(TypeError):
375 def test_refleaks_in_decompressor___init__(self):
381 self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
388 def test_bad_args(self):
389 self.assertRaises(TypeError, lzma.compress)
390 self.assertRaises(TypeError, lzma.compress, [])
391 self.assertRaises(TypeError, lzma.compress, b"", format="xz")
392 self.assertRaises(TypeError, lzma.compress, b"", check="none")
393 self.assertRaises(TypeError, lzma.compress, b"", preset="blah")
394 self.assertRaises(TypeError, lzma.compress, b"", filters=1024)
396 with self.assertRaises(ValueError):
399 self.assertRaises(TypeError, lzma.decompress)
400 self.assertRaises(TypeError, lzma.decompress, [])
401 self.assertRaises(TypeError, lzma.decompress, b"", format="lzma")
402 self.assertRaises(TypeError, lzma.decompress, b"", memlimit=7.3e9)
403 with self.assertRaises(TypeError):
406 with self.assertRaises(ValueError):
409 with self.assertRaises(ValueError):
411 with self.assertRaises(ValueError):
413 with self.assertRaises(ValueError):
417 def test_decompress_memlimit(self):
418 with self.assertRaises(LZMAError):
420 with self.assertRaises(LZMAError):
423 with self.assertRaises(LZMAError):
429 def test_decompress_good_input(self):
431 self.assertEqual(ddata, INPUT)
434 self.assertEqual(ddata, INPUT)
437 self.assertEqual(ddata, INPUT)
440 self.assertEqual(ddata, INPUT)
444 self.assertEqual(ddata, INPUT)
448 self.assertEqual(ddata, INPUT)
452 self.assertEqual(ddata, INPUT)
456 self.assertEqual(ddata, INPUT)
458 def test_decompress_incomplete_input(self):
459 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_XZ[:128])
460 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_ALONE[:128])
461 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_1[:128],
463 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_2[:128],
465 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_3[:128],
467 self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_4[:128],
470 def test_decompress_bad_input(self):
471 with self.assertRaises(LZMAError):
473 with self.assertRaises(LZMAError):
475 with self.assertRaises(LZMAError):
477 with self.assertRaises(LZMAError):
479 with self.assertRaises(LZMAError):
485 def test_roundtrip(self):
488 self.assertEqual(ddata, INPUT)
492 self.assertEqual(ddata, INPUT)
496 self.assertEqual(ddata, INPUT)
500 self.assertEqual(ddata, INPUT)
504 def test_decompress_multistream(self):
506 self.assertEqual(ddata, INPUT * 2)
510 def test_decompress_trailing_junk(self):
512 self.assertEqual(ddata, INPUT)
514 def test_decompress_multistream_trailing_junk(self):
516 self.assertEqual(ddata, INPUT * 3)
522 def __init__(self, filename, data=b""):
523 self.filename = filename
524 self.data = data
526 def __enter__(self):
527 with open(self.filename, "wb") as f:
528 f.write(self.data)
530 def __exit__(self, *args):
531 unlink(self.filename)
536 def test_init(self):
546 def test_init_with_PathLike_filename(self):
550 self.assertEqual(f.read(), INPUT)
554 self.assertEqual(f.read(), INPUT * 2)
556 def test_init_with_filename(self):
565 def test_init_mode(self):
580 def test_init_with_x_mode(self):
581 self.addCleanup(unlink, TESTFN)
586 with self.assertRaises(FileExistsError):
590 def test_init_bad_mode(self):
591 with self.assertRaises(ValueError):
593 with self.assertRaises(ValueError):
595 with self.assertRaises(ValueError):
597 with self.assertRaises(ValueError):
599 with self.assertRaises(ValueError):
601 with self.assertRaises(ValueError):
603 with self.assertRaises(ValueError):
605 with self.assertRaises(ValueError):
607 with self.assertRaises(ValueError):
609 with self.assertRaises(ValueError):
611 with self.assertRaises(ValueError):
614 def test_init_bad_check(self):
615 with self.assertRaises(TypeError):
618 with self.assertRaises(LZMAError):
620 with self.assertRaises(LZMAError):
623 with self.assertRaises(ValueError):
625 with self.assertRaises(ValueError):
627 with self.assertRaises(ValueError):
629 with self.assertRaises(ValueError):
631 with self.assertRaises(ValueError):
634 def test_init_bad_preset(self):
635 with self.assertRaises(TypeError):
637 with self.assertRaises(LZMAError):
639 with self.assertRaises(LZMAError):
641 with self.assertRaises(OverflowError):
643 with self.assertRaises(OverflowError):
645 with self.assertRaises(TypeError):
648 with self.assertRaises(ValueError):
651 def test_init_bad_filter_spec(self):
652 with self.assertRaises(TypeError):
654 with self.assertRaises(ValueError):
656 with self.assertRaises(ValueError):
658 with self.assertRaises(ValueError):
661 with self.assertRaises(ValueError):
664 with self.assertRaises(ValueError):
668 def test_init_with_preset_and_filters(self):
669 with self.assertRaises(ValueError):
673 def test_close(self):
678 self.assertFalse(src.closed)
681 self.assertFalse(src.closed)
689 self.assertTrue(fp.closed)
693 def test_closed(self):
696 self.assertFalse(f.closed)
698 self.assertFalse(f.closed)
701 self.assertTrue(f.closed)
705 self.assertFalse(f.closed)
708 self.assertTrue(f.closed)
710 def test_fileno(self):
713 self.assertRaises(UnsupportedOperation, f.fileno)
716 self.assertRaises(ValueError, f.fileno)
720 self.assertEqual(f.fileno(), f._fp.fileno())
721 self.assertIsInstance(f.fileno(), int)
724 self.assertRaises(ValueError, f.fileno)
726 def test_seekable(self):
729 self.assertTrue(f.seekable())
731 self.assertTrue(f.seekable())
734 self.assertRaises(ValueError, f.seekable)
738 self.assertFalse(f.seekable())
741 self.assertRaises(ValueError, f.seekable)
747 self.assertFalse(f.seekable())
750 self.assertRaises(ValueError, f.seekable)
752 def test_readable(self):
755 self.assertTrue(f.readable())
757 self.assertTrue(f.readable())
760 self.assertRaises(ValueError, f.readable)
764 self.assertFalse(f.readable())
767 self.assertRaises(ValueError, f.readable)
769 def test_writable(self):
772 self.assertFalse(f.writable())
774 self.assertFalse(f.writable())
777 self.assertRaises(ValueError, f.writable)
781 self.assertTrue(f.writable())
784 self.assertRaises(ValueError, f.writable)
786 def test_read(self):
788 self.assertEqual(f.read(), INPUT)
789 self.assertEqual(f.read(), b"")
791 self.assertEqual(f.read(), INPUT)
793 self.assertEqual(f.read(), INPUT)
794 self.assertEqual(f.read(), b"")
796 self.assertEqual(f.read(), INPUT)
797 self.assertEqual(f.read(), b"")
800 self.assertEqual(f.read(), INPUT)
801 self.assertEqual(f.read(), b"")
804 self.assertEqual(f.read(), INPUT)
805 self.assertEqual(f.read(), b"")
808 self.assertEqual(f.read(), INPUT)
809 self.assertEqual(f.read(), b"")
812 self.assertEqual(f.read(), INPUT)
813 self.assertEqual(f.read(), b"")
815 def test_read_0(self):
817 self.assertEqual(f.read(0), b"")
819 self.assertEqual(f.read(0), b"")
821 self.assertEqual(f.read(0), b"")
823 self.assertEqual(f.read(0), b"")
825 def test_read_10(self):
832 self.assertLessEqual(len(result), 10)
834 self.assertEqual(b"".join(chunks), INPUT)
836 def test_read_multistream(self):
838 self.assertEqual(f.read(), INPUT * 5)
840 self.assertEqual(f.read(), INPUT * 2)
843 self.assertEqual(f.read(), INPUT * 4)
845 def test_read_multistream_buffer_size_aligned(self):
852 self.assertEqual(f.read(), INPUT * 5)
856 def test_read_trailing_junk(self):
858 self.assertEqual(f.read(), INPUT)
860 def test_read_multistream_trailing_junk(self):
862 self.assertEqual(f.read(), INPUT * 5)
864 def test_read_from_file(self):
867 self.assertEqual(f.read(), INPUT)
868 self.assertEqual(f.read(), b"")
870 def test_read_from_file_with_bytes_filename(self):
874 self.skipTest("Temporary file name needs to be ASCII")
877 self.assertEqual(f.read(), INPUT)
878 self.assertEqual(f.read(), b"")
880 def test_read_incomplete(self):
882 self.assertRaises(EOFError, f.read)
884 def test_read_truncated(self):
889 self.assertRaises(EOFError, f.read)
891 self.assertEqual(f.read(len(INPUT)), INPUT)
892 self.assertRaises(EOFError, f.read, 1)
896 self.assertRaises(EOFError, f.read, 1)
898 def test_read_bad_args(self):
901 self.assertRaises(ValueError, f.read)
903 self.assertRaises(ValueError, f.read)
905 self.assertRaises(TypeError, f.read, float())
907 def test_read_bad_data(self):
909 self.assertRaises(LZMAError, f.read)
911 def test_read1(self):
919 self.assertEqual(b"".join(blocks), INPUT)
920 self.assertEqual(f.read1(), b"")
922 def test_read1_0(self):
924 self.assertEqual(f.read1(0), b"")
926 def test_read1_10(self):
934 self.assertEqual(b"".join(blocks), INPUT)
935 self.assertEqual(f.read1(), b"")
937 def test_read1_multistream(self):
945 self.assertEqual(b"".join(blocks), INPUT * 5)
946 self.assertEqual(f.read1(), b"")
948 def test_read1_bad_args(self):
951 self.assertRaises(ValueError, f.read1)
953 self.assertRaises(ValueError, f.read1)
955 self.assertRaises(TypeError, f.read1, None)
957 def test_peek(self):
960 self.assertGreater(len(result), 0)
961 self.assertTrue(INPUT.startswith(result))
962 self.assertEqual(f.read(), INPUT)
965 self.assertGreater(len(result), 0)
966 self.assertTrue(INPUT.startswith(result))
967 self.assertEqual(f.read(), INPUT)
969 def test_peek_bad_args(self):
971 self.assertRaises(ValueError, f.peek)
973 def test_iterator(self):
977 self.assertListEqual(list(iter(f)), lines)
979 self.assertListEqual(list(iter(f)), lines)
981 self.assertListEqual(list(iter(f)), lines)
983 self.assertListEqual(list(iter(f)), lines)
986 self.assertListEqual(list(iter(f)), lines)
988 def test_readline(self):
993 self.assertEqual(f.readline(), line)
995 def test_readlines(self):
999 self.assertListEqual(f.readlines(), lines)
1001 def test_decompress_limited(self):
1004 self.assertLess(len(bomb), _compression.BUFFER_SIZE)
1007 self.assertEqual(decomp.read(1), b'\0')
1009 self.assertLessEqual(decomp._buffer.raw.tell(), max_decomp,
1012 def test_write(self):
1017 self.assertEqual(dst.getvalue(), expected)
1022 self.assertEqual(dst.getvalue(), expected)
1027 self.assertEqual(dst.getvalue(), expected)
1034 self.assertEqual(dst.getvalue(), expected)
1036 def test_write_10(self):
1042 self.assertEqual(dst.getvalue(), expected)
1044 def test_write_append(self):
1056 self.assertEqual(dst.getvalue(), expected)
1058 def test_write_to_file(self):
1064 self.assertEqual(f.read(), expected)
1068 def test_write_to_file_with_bytes_filename(self):
1072 self.skipTest("Temporary file name needs to be ASCII")
1078 self.assertEqual(f.read(), expected)
1082 def test_write_append_to_file(self):
1095 self.assertEqual(f.read(), expected)
1099 def test_write_bad_args(self):
1102 self.assertRaises(ValueError, f.write, b"foo")
1104 self.assertRaises(ValueError, f.write, b"bar")
1106 self.assertRaises(TypeError, f.write, None)
1107 self.assertRaises(TypeError, f.write, "text")
1108 self.assertRaises(TypeError, f.write, 789)
1110 def test_writelines(self):
1117 self.assertEqual(dst.getvalue(), expected)
1119 def test_seek_forward(self):
1122 self.assertEqual(f.read(), INPUT[555:])
1124 def test_seek_forward_across_streams(self):
1127 self.assertEqual(f.read(), INPUT[123:])
1129 def test_seek_forward_relative_to_current(self):
1133 self.assertEqual(f.read(), INPUT[1336:])
1135 def test_seek_forward_relative_to_end(self):
1138 self.assertEqual(f.read(), INPUT[-555:])
1140 def test_seek_backward(self):
1144 self.assertEqual(f.read(), INPUT[211:])
1146 def test_seek_backward_across_streams(self):
1150 self.assertEqual(f.read(), INPUT[737:] + INPUT)
1152 def test_seek_backward_relative_to_end(self):
1155 self.assertEqual(f.read(), INPUT[-150:])
1157 def test_seek_past_end(self):
1160 self.assertEqual(f.tell(), len(INPUT))
1161 self.assertEqual(f.read(), b"")
1163 def test_seek_past_start(self):
1166 self.assertEqual(f.tell(), 0)
1167 self.assertEqual(f.read(), INPUT)
1169 def test_seek_bad_args(self):
1172 self.assertRaises(ValueError, f.seek, 0)
1174 self.assertRaises(ValueError, f.seek, 0)
1176 self.assertRaises(ValueError, f.seek, 0, 3)
1178 self.assertRaises((TypeError, ValueError), f.seek, 9, ())
1179 self.assertRaises(TypeError, f.seek, None)
1180 self.assertRaises(TypeError, f.seek, b"derp")
1182 def test_tell(self):
1186 self.assertEqual(f.tell(), pos)
1191 self.assertEqual(f.tell(), len(INPUT))
1194 self.assertEqual(f.tell(), pos)
1196 self.assertEqual(f.tell(), len(INPUT))
1198 def test_tell_bad_args(self):
1201 self.assertRaises(ValueError, f.tell)
1203 def test_issue21872(self):
1211 self.assertEqual(len(entire), 13160)
1212 self.assertTrue(d1.eof)
1223 self.assertFalse(d2.needs_input) # ensure needs_input mechanism works
1224 self.assertFalse(d2.eof)
1229 self.assertEqual(len(out2), 11)
1230 self.assertTrue(d2.eof)
1231 self.assertEqual(out1 + out2, entire)
1233 def test_issue44439(self):
1238 self.assertEqual(f.write(q), LENGTH)
1239 self.assertEqual(f.tell(), LENGTH)
1244 def test_binary_modes(self):
1246 self.assertEqual(f.read(), INPUT)
1251 self.assertEqual(file_data, INPUT)
1255 self.assertEqual(file_data, INPUT * 2)
1257 def test_text_modes(self):
1261 self.assertEqual(f.read(), uncompressed)
1266 self.assertEqual(file_data, uncompressed_raw)
1270 self.assertEqual(file_data, uncompressed_raw * 2)
1272 def test_filename(self):
1278 self.assertEqual(file_data, INPUT)
1280 self.assertEqual(f.read(), INPUT)
1284 self.assertEqual(f.read(), INPUT * 2)
1286 def test_with_pathlike_filename(self):
1293 self.assertEqual(file_data, INPUT)
1295 self.assertEqual(f.read(), INPUT)
1297 def test_bad_params(self):
1299 with self.assertRaises(ValueError):
1301 with self.assertRaises(ValueError):
1303 with self.assertRaises(ValueError):
1305 with self.assertRaises(ValueError):
1307 with self.assertRaises(ValueError):
1310 def test_format_and_filters(self):
1314 self.assertEqual(f.read(), INPUT)
1319 self.assertEqual(file_data, INPUT)
1321 def test_encoding(self):
1329 self.assertEqual(file_data, uncompressed_raw)
1332 self.assertEqual(f.read(), uncompressed)
1334 def test_encoding_error_handler(self):
1338 self.assertEqual(f.read(), "foobar")
1340 def test_newline(self):
1348 self.assertEqual(f.readlines(), [text])
1350 def test_x_mode(self):
1351 self.addCleanup(unlink, TESTFN)
1357 with self.assertRaises(FileExistsError):
1364 def test_is_check_supported(self):
1367 self.assertTrue(lzma.is_check_supported(lzma.CHECK_NONE))
1368 self.assertTrue(lzma.is_check_supported(lzma.CHECK_CRC32))
1371 self.assertFalse(lzma.is_check_supported(lzma.CHECK_ID_MAX + 1))
1374 self.assertFalse(lzma.is_check_supported(lzma.CHECK_UNKNOWN))
1376 def test__encode_filter_properties(self):
1377 with self.assertRaises(TypeError):
1379 with self.assertRaises(ValueError):
1381 with self.assertRaises(ValueError):
1383 with self.assertRaises(lzma.LZMAError):
1395 self.assertEqual(props, b"]\x00\x00\x80\x00")
1397 def test__decode_filter_properties(self):
1398 with self.assertRaises(TypeError):
1400 with self.assertRaises(lzma.LZMAError):
1406 self.assertEqual(filterspec["id"], lzma.FILTER_LZMA1)
1407 self.assertEqual(filterspec["pb"], 2)
1408 self.assertEqual(filterspec["lp"], 0)
1409 self.assertEqual(filterspec["lc"], 3)
1410 self.assertEqual(filterspec["dict_size"], 8 << 20)
1412 def test_filter_properties_roundtrip(self):
1417 self.assertEqual(spec1, spec2)