X-Git-Url: http://www.git.cypherpunks.ru/?p=pyderasn.git;a=blobdiff_plain;f=tests%2Ftest_pyderasn.py;fp=tests%2Ftest_pyderasn.py;h=4edf0608f61f544f9ca5a91d9e9bd9c714e77c39;hp=fec6b763674bee4a60f98a4f98e7c6fbf8c272fb;hb=6ffa181faaed35d38e9057c473363b5b6e44efd6;hpb=eda9a545dda258ca202cb812633239eefeb2c5d6 diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py index fec6b76..4edf060 100644 --- a/tests/test_pyderasn.py +++ b/tests/test_pyderasn.py @@ -53,19 +53,9 @@ from hypothesis.strategies import sampled_from from hypothesis.strategies import sets from hypothesis.strategies import text from hypothesis.strategies import tuples -from six import assertRaisesRegex -from six import binary_type -from six import byte2int -from six import indexbytes -from six import int2byte -from six import iterbytes -from six import PY2 -from six import text_type -from six import unichr as six_unichr -from six.moves import xrange as six_xrange -from six.moves.cPickle import dumps as pickle_dumps -from six.moves.cPickle import HIGHEST_PROTOCOL as pickle_proto -from six.moves.cPickle import loads as pickle_loads +from pickle import dumps as pickle_dumps +from pickle import HIGHEST_PROTOCOL as pickle_proto +from pickle import loads as pickle_loads from pyderasn import _pp from pyderasn import abs_decode_path @@ -170,7 +160,7 @@ def register_class(klass): def assert_exceeding_data(self, call, junk): if len(junk) <= 0: return - with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err: + with self.assertRaisesRegex(ExceedingData, "%d trailing bytes" % len(junk)) as err: call() repr(err) @@ -194,8 +184,8 @@ class TestTagCoder(TestCase): self.assertEqual(tag_decode(raw), (klass, form, num)) self.assertEqual(len(raw), 1) self.assertEqual( - byte2int(tag_encode(klass=klass, form=form, num=0)), - byte2int(raw) & (1 << 7 | 1 << 6 | 1 << 5), + tag_encode(klass=klass, form=form, num=0)[0], + raw[0] & (1 << 7 | 1 << 6 | 1 << 5), ) stripped, tlen, tail = tag_strip(memoryview(raw + junk)) self.assertSequenceEqual(stripped.tobytes(), raw) @@ -214,11 +204,11 @@ class TestTagCoder(TestCase): self.assertEqual(tag_decode(raw), (klass, form, num)) self.assertGreater(len(raw), 1) self.assertEqual( - byte2int(tag_encode(klass=klass, form=form, num=0)) | 31, - byte2int(raw[:1]), + tag_encode(klass=klass, form=form, num=0)[0] | 31, + raw[0], ) - self.assertEqual(byte2int(raw[-1:]) & 0x80, 0) - self.assertTrue(all(b & 0x80 > 0 for b in iterbytes(raw[1:-1]))) + self.assertEqual(raw[-1] & 0x80, 0) + self.assertTrue(all(b & 0x80 > 0 for b in raw[1:-1])) stripped, tlen, tail = tag_strip(memoryview(raw + junk)) self.assertSequenceEqual(stripped.tobytes(), raw) self.assertEqual(tlen, len(raw)) @@ -230,7 +220,7 @@ class TestTagCoder(TestCase): raw = bytearray(tag_encode(num=num)) for i in range(1, len(raw)): raw[i] |= 0x80 - with assertRaisesRegex(self, DecodeError, "unfinished tag"): + with self.assertRaisesRegex(DecodeError, "unfinished tag"): tag_strip(bytes(raw)) def test_go_vectors_valid(self): @@ -272,8 +262,8 @@ class TestTagCoder(TestCase): integers(min_value=0, max_value=2), ) def test_long_instead_of_short(self, l, dummy_num): - octets = (b"\x00" * dummy_num) + int2byte(l) - octets = int2byte((dummy_num + 1) | 0x80) + octets + octets = (b"\x00" * dummy_num) + bytes([l]) + octets = bytes([(dummy_num + 1) | 0x80]) + octets with self.assertRaises(DecodeError): len_decode(octets) @@ -281,13 +271,13 @@ class TestTagCoder(TestCase): def test_leading_zero_byte(self, klass, form, num): raw = tag_encode(klass=klass, form=form, num=num) raw = b"".join((raw[:1], b"\x80", raw[1:])) - with assertRaisesRegex(self, DecodeError, "leading zero byte"): + with self.assertRaisesRegex(DecodeError, "leading zero byte"): tag_strip(raw) @given(tag_classes, tag_forms, integers(max_value=30, min_value=0)) def test_unexpected_long_form(self, klass, form, num): - raw = int2byte(klass | form | 31) + int2byte(num) - with assertRaisesRegex(self, DecodeError, "unexpected long form"): + raw = bytes([klass | form | 31, num]) + with self.assertRaisesRegex(DecodeError, "unexpected long form"): tag_strip(raw) @@ -314,9 +304,9 @@ class TestLenCoder(TestCase): raw = len_encode(l) + junk decoded, llen, tail = len_decode(memoryview(raw)) self.assertEqual(decoded, l) - self.assertEqual((llen - 1) | 0x80, byte2int(raw)) + self.assertEqual((llen - 1) | 0x80, raw[0]) self.assertEqual(llen, len(raw) - len(junk)) - self.assertNotEqual(indexbytes(raw, 1), 0) + self.assertNotEqual(raw[1], 0) self.assertSequenceEqual(tail.tobytes(), junk) def test_empty(self): @@ -335,8 +325,6 @@ text_printable = text(alphabet=printable, min_size=1) @composite def text_letters(draw): result = draw(text(alphabet=ascii_letters, min_size=1)) - if PY2: - result = result.encode("ascii") return result @@ -700,17 +688,13 @@ class TestBoolean(CommonMixin, TestCase): @given(integers(min_value=0 + 1, max_value=255 - 1)) def test_ber_value(self, value): - with assertRaisesRegex(self, DecodeError, "unacceptable Boolean value"): + with self.assertRaisesRegex(DecodeError, "unacceptable Boolean value"): Boolean().decode(b"".join(( Boolean.tag_default, len_encode(1), - int2byte(value), + bytes([value]), ))) - encoded = b"".join(( - Boolean.tag_default, - len_encode(1), - int2byte(value), - )) + encoded = b"".join((Boolean.tag_default, len_encode(1), bytes([value]))) obj, _ = Boolean().decode(encoded, ctx={"bered": True}) list(Boolean().decode_evgen(encoded, ctx={"bered": True})) self.assertTrue(bool(obj)) @@ -730,7 +714,7 @@ class TestBoolean(CommonMixin, TestCase): encoded = expl + LENINDEF + Boolean(False).encode() with self.assertRaises(LenIndefForm): Boolean(expl=expl).decode(encoded + junk) - with assertRaisesRegex(self, DecodeError, "no EOC"): + with self.assertRaisesRegex(DecodeError, "no EOC"): Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True}) obj, tail = Boolean(expl=expl).decode( encoded + EOC + junk, @@ -945,24 +929,24 @@ class TestInteger(CommonMixin, TestCase): with self.assertRaises(BoundsError) as err: Integer(value=values[0], bounds=(values[1], values[2])) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: Integer(bounds=(values[1], values[2])).decode( Integer(values[0]).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: Integer(bounds=(values[1], values[2])).decode( encode2pass(Integer(values[0])) ) with self.assertRaises(BoundsError) as err: Integer(value=values[2], bounds=(values[0], values[1])) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: Integer(bounds=(values[0], values[1])).decode( Integer(values[2]).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: Integer(bounds=(values[0], values[1])).decode( encode2pass(Integer(values[2])) ) @@ -1649,7 +1633,7 @@ class TestBitString(CommonMixin, TestCase): BitString().decode(b"".join(( BitString.tag_default, len_encode(1), - int2byte(pad_size), + bytes([pad_size]), ))) def test_go_vectors_invalid(self): @@ -1721,7 +1705,7 @@ class TestBitString(CommonMixin, TestCase): payload_expected = b"" bit_len_expected = 0 for chunk_input in chunk_inputs: - if isinstance(chunk_input, binary_type): + if isinstance(chunk_input, bytes): chunks.append(BitString(chunk_input).encode()) payload_expected += chunk_input bit_len_expected += len(chunk_input) * 8 @@ -1753,7 +1737,7 @@ class TestBitString(CommonMixin, TestCase): b"".join(chunks) + chunk_last.encode() ) - with assertRaisesRegex(self, DecodeError, "unallowed BER"): + with self.assertRaisesRegex(DecodeError, "unallowed BER"): BitString(impl=tag_encode(impl)).decode(encoded_indefinite) for lenindef_expected, encoded in ( (True, encoded_indefinite), @@ -1793,7 +1777,7 @@ class TestBitString(CommonMixin, TestCase): decode_path_strat, ) def test_ber_definite_too_short(self, offset, decode_path): - with assertRaisesRegex(self, DecodeError, "longer than data") as err: + with self.assertRaisesRegex(DecodeError, "longer than data") as err: BitString().decode( tag_encode(3, form=TagFormConstructed) + len_encode(1), offset=offset, @@ -1808,7 +1792,7 @@ class TestBitString(CommonMixin, TestCase): decode_path_strat, ) def test_ber_definite_no_data(self, offset, decode_path): - with assertRaisesRegex(self, DecodeError, "zero length") as err: + with self.assertRaisesRegex(DecodeError, "zero length") as err: BitString().decode( tag_encode(3, form=TagFormConstructed) + len_encode(0), offset=offset, @@ -1843,7 +1827,7 @@ class TestBitString(CommonMixin, TestCase): def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks): bs = BitString(b"data").encode() bs_longer = BitString(b"data-longer").encode() - with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err: + with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err: BitString().decode( ( tag_encode(3, form=TagFormConstructed) + @@ -1863,7 +1847,7 @@ class TestBitString(CommonMixin, TestCase): decode_path_strat, ) def test_ber_indefinite_no_chunks(self, offset, decode_path): - with assertRaisesRegex(self, DecodeError, "no chunks") as err: + with self.assertRaisesRegex(DecodeError, "no chunks") as err: BitString().decode( tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC, offset=offset, @@ -1883,7 +1867,7 @@ class TestBitString(CommonMixin, TestCase): chunks.append(bs_short) offset = d.draw(integers(min_value=0)) decode_path = d.draw(decode_path_strat) - with assertRaisesRegex(self, DecodeError, "multiple of 8 bits") as err: + with self.assertRaisesRegex(DecodeError, "multiple of 8 bits") as err: BitString().decode( ( tag_encode(3, form=TagFormConstructed) + @@ -1984,7 +1968,7 @@ class TestOctetString(CommonMixin, TestCase): def test_invalid_value_type(self): with self.assertRaises(InvalidValueType) as err: - OctetString(text_type(123)) + OctetString(str(123)) repr(err.exception) @given(booleans()) @@ -2045,12 +2029,12 @@ class TestOctetString(CommonMixin, TestCase): with self.assertRaises(BoundsError) as err: OctetString(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: OctetString(bounds=(bound_min, bound_max)).decode( OctetString(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: OctetString(bounds=(bound_min, bound_max)).decode( encode2pass(OctetString(value)) ) @@ -2058,12 +2042,12 @@ class TestOctetString(CommonMixin, TestCase): with self.assertRaises(BoundsError) as err: OctetString(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: OctetString(bounds=(bound_min, bound_max)).decode( OctetString(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: OctetString(bounds=(bound_min, bound_max)).decode( encode2pass(OctetString(value)) ) @@ -2336,7 +2320,7 @@ class TestOctetString(CommonMixin, TestCase): chunks_len_expected = [] payload_expected = b"" for chunk_input in chunk_inputs: - if isinstance(chunk_input, binary_type): + if isinstance(chunk_input, bytes): chunks.append(OctetString(chunk_input).encode()) payload_expected += chunk_input chunks_len_expected.append(len(chunk_input)) @@ -2358,7 +2342,7 @@ class TestOctetString(CommonMixin, TestCase): len_encode(len(b"".join(chunks))) + b"".join(chunks) ) - with assertRaisesRegex(self, DecodeError, "unallowed BER"): + with self.assertRaisesRegex(DecodeError, "unallowed BER"): OctetString(impl=tag_encode(impl)).decode(encoded_indefinite) for lenindef_expected, encoded in ( (True, encoded_indefinite), @@ -2397,7 +2381,7 @@ class TestOctetString(CommonMixin, TestCase): decode_path_strat, ) def test_ber_definite_too_short(self, offset, decode_path): - with assertRaisesRegex(self, DecodeError, "longer than data") as err: + with self.assertRaisesRegex(DecodeError, "longer than data") as err: OctetString().decode( tag_encode(4, form=TagFormConstructed) + len_encode(1), offset=offset, @@ -2432,7 +2416,7 @@ class TestOctetString(CommonMixin, TestCase): def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks): bs = OctetString(b"data").encode() bs_longer = OctetString(b"data-longer").encode() - with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err: + with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err: OctetString().decode( ( tag_encode(4, form=TagFormConstructed) + @@ -2921,7 +2905,7 @@ class TestObjectIdentifier(CommonMixin, TestCase): len_encode(len(data)), data, )) - with assertRaisesRegex(self, DecodeError, "unfinished OID"): + with self.assertRaisesRegex(DecodeError, "unfinished OID"): obj.decode(data) @given(integers(min_value=0)) @@ -3105,7 +3089,7 @@ class TestObjectIdentifier(CommonMixin, TestCase): obj = copy(obj) self.assertTrue(obj.ber_encoded) self.assertTrue(obj.bered) - with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"): + with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"): ObjectIdentifier().decode(tampered) @given(data_strategy()) @@ -3160,7 +3144,7 @@ class TestObjectIdentifier(CommonMixin, TestCase): obj = copy(obj) self.assertTrue(obj.ber_encoded) self.assertTrue(obj.bered) - with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"): + with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"): ObjectIdentifier().decode(tampered) @@ -3198,7 +3182,7 @@ class TestEnumerated(CommonMixin, TestCase): base_klass = EWhatever def test_schema_required(self): - with assertRaisesRegex(self, ValueError, "schema must be specified"): + with self.assertRaisesRegex(ValueError, "schema must be specified"): Enumerated() def test_invalid_value_type(self): @@ -3480,7 +3464,7 @@ class StringMixin(object): repr(err.exception) def text_alphabet(self): - return "".join(six_unichr(c) for c in six_xrange(256)) + return "".join(chr(c) for c in range(256)) @given(booleans()) def test_optional(self, optional): @@ -3494,7 +3478,7 @@ class StringMixin(object): repr(obj) list(obj.pps()) pprint(obj, big_blobs=True, with_decode_path=True) - text_type(obj) + str(obj) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) @@ -3506,7 +3490,7 @@ class StringMixin(object): repr(obj) list(obj.pps()) pprint(obj, big_blobs=True, with_decode_path=True) - text_type(obj) + str(obj) @given(data_strategy()) def test_comparison(self, d): @@ -3519,7 +3503,7 @@ class StringMixin(object): self.assertEqual(obj1 == obj2, value1 == value2) self.assertEqual(obj1 != obj2, value1 != value2) self.assertEqual(obj1 == bytes(obj2), value1 == value2) - self.assertEqual(obj1 == text_type(obj2), value1 == value2) + self.assertEqual(obj1 == str(obj2), value1 == value2) obj1 = self.base_klass(value1, impl=tag1) obj2 = self.base_klass(value1, impl=tag2) self.assertEqual(obj1 == obj2, tag1 == tag2) @@ -3544,12 +3528,12 @@ class StringMixin(object): with self.assertRaises(BoundsError) as err: self.base_klass(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: self.base_klass(bounds=(bound_min, bound_max)).decode( self.base_klass(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: self.base_klass(bounds=(bound_min, bound_max)).decode( encode2pass(self.base_klass(value)) ) @@ -3557,12 +3541,12 @@ class StringMixin(object): with self.assertRaises(BoundsError) as err: self.base_klass(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: self.base_klass(bounds=(bound_min, bound_max)).decode( self.base_klass(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: self.base_klass(bounds=(bound_min, bound_max)).decode( encode2pass(self.base_klass(value)) ) @@ -3763,8 +3747,8 @@ class StringMixin(object): self.assertNotEqual(obj_decoded, obj) self.assertEqual(bytes(obj_decoded), bytes(obj_expled)) self.assertEqual(bytes(obj_decoded), bytes(obj)) - self.assertEqual(text_type(obj_decoded), text_type(obj_expled)) - self.assertEqual(text_type(obj_decoded), text_type(obj)) + self.assertEqual(str(obj_decoded), str(obj_expled)) + self.assertEqual(str(obj_decoded), str(obj)) self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded) self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl) self.assertEqual(obj_decoded.expl_tlen, len(tag_expl)) @@ -3803,7 +3787,7 @@ class StringMixin(object): cyrillic_letters = text( - alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))), + alphabet="".join(chr(i) for i in list(range(0x0410, 0x044f + 1))), min_size=1, max_size=5, ) @@ -3844,7 +3828,7 @@ class TestNumericString(StringMixin, CommonMixin, TestCase): @given(text(alphabet=ascii_letters, min_size=1, max_size=5)) def test_non_numeric(self, non_numeric_text): - with assertRaisesRegex(self, DecodeError, "alphabet value"): + with self.assertRaisesRegex(DecodeError, "alphabet value"): self.base_klass(non_numeric_text) @given( @@ -3894,7 +3878,7 @@ class TestPrintableString( @given(text(alphabet=sorted(set(whitespace) - set(" ")), min_size=1, max_size=5)) def test_non_printable(self, non_printable_text): - with assertRaisesRegex(self, DecodeError, "alphabet value"): + with self.assertRaisesRegex(DecodeError, "alphabet value"): self.base_klass(non_printable_text) @given( @@ -3928,7 +3912,7 @@ class TestPrintableString( for prop in kwargs.keys(): self.assertFalse(getattr(obj, prop)) s += c - with assertRaisesRegex(self, DecodeError, "alphabet value"): + with self.assertRaisesRegex(DecodeError, "alphabet value"): self.base_klass(s) self.base_klass(s, **kwargs) klass = self.base_klass(**kwargs) @@ -3968,7 +3952,7 @@ class TestIA5String( base_klass = IA5String def text_alphabet(self): - return "".join(six_unichr(c) for c in six_xrange(128)) + return "".join(chr(c) for c in range(128)) @given(integers(min_value=128, max_value=255)) def test_alphabet_bad(self, code): @@ -4360,7 +4344,7 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase): self.assertFalse(obj_encoded.endswith(b"0Z")) def test_repr_not_ready(self): - unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime()) + str(GeneralizedTime()) repr(GeneralizedTime()) def test_x690_vector_valid(self): @@ -4441,8 +4425,7 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase): @settings(max_examples=LONG_TEST_MAX_EXAMPLES) @given(data_strategy()) def test_valid_ber(self, d): - min_year = 1901 if PY2 else 2 - year = d.draw(integers(min_value=min_year, max_value=9999)) + year = d.draw(integers(min_value=2, max_value=9999)) month = d.draw(integers(min_value=1, max_value=12)) day = d.draw(integers(min_value=1, max_value=28)) hours = d.draw(integers(min_value=0, max_value=23)) @@ -4697,7 +4680,7 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase): def test_ns_fractions(self): GeneralizedTime(b"20010101000000.000001Z") - with assertRaisesRegex(self, DecodeError, "only microsecond fractions"): + with self.assertRaisesRegex(DecodeError, "only microsecond fractions"): GeneralizedTime(b"20010101000000.0000001Z") def test_non_pure_integers(self): @@ -4738,7 +4721,7 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase): GeneralizedTime(data) def test_aware(self): - with assertRaisesRegex(self, ValueError, "only naive"): + with self.assertRaisesRegex(ValueError, "only naive"): GeneralizedTime(datetime(2000, 1, 1, 1, tzinfo=UTC)) @@ -4753,7 +4736,7 @@ class TestUTCTime(TimeMixin, CommonMixin, TestCase): pass def test_repr_not_ready(self): - unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime()) + str(GeneralizedTime()) repr(UTCTime()) def test_x690_vector_valid(self): @@ -5075,7 +5058,7 @@ class TestUTCTime(TimeMixin, CommonMixin, TestCase): ) def test_aware(self): - with assertRaisesRegex(self, ValueError, "only naive"): + with self.assertRaisesRegex(ValueError, "only naive"): UTCTime(datetime(2000, 1, 1, 1, tzinfo=UTC)) @@ -5478,11 +5461,11 @@ class TestChoice(CommonMixin, TestCase): base_klass = Wahl def test_schema_required(self): - with assertRaisesRegex(self, ValueError, "schema must be specified"): + with self.assertRaisesRegex(ValueError, "schema must be specified"): Choice() def test_impl_forbidden(self): - with assertRaisesRegex(self, ValueError, "no implicit tag allowed"): + with self.assertRaisesRegex(ValueError, "no implicit tag allowed"): Choice(impl=b"whatever") def test_invalid_value_type(self): @@ -6374,9 +6357,9 @@ class SeqMixing(object): for (n, v), t in zip(_schema, tags) ] seq_with_default = SeqWithDefault() - with assertRaisesRegex(self, DecodeError, "DEFAULT value met"): + with self.assertRaisesRegex(DecodeError, "DEFAULT value met"): seq_with_default.decode(seq_encoded) - with assertRaisesRegex(self, DecodeError, "DEFAULT value met"): + with self.assertRaisesRegex(DecodeError, "DEFAULT value met"): list(seq_with_default.decode_evgen(seq_encoded)) for ctx in ({"bered": True}, {"allow_default_values": True}): seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx) @@ -6485,7 +6468,7 @@ class TestSequence(SeqMixing, CommonMixin, TestCase): len_encode(len(int_encoded + junk)), int_encoded + junk, )) - with assertRaisesRegex(self, DecodeError, "remaining"): + with self.assertRaisesRegex(DecodeError, "remaining"): Seq().decode(junked) @given(sets(text_letters(), min_size=2)) @@ -6557,7 +6540,7 @@ class TestSet(SeqMixing, CommonMixin, TestCase): len_encode(len(encoded)), encoded, )) - with assertRaisesRegex(self, DecodeError, "unordered SET"): + with self.assertRaisesRegex(DecodeError, "unordered SET"): seq.decode(seq_encoded) for ctx in ({"bered": True}, {"allow_unordered_set": True}): seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx) @@ -6642,7 +6625,7 @@ class SeqOfMixing(object): repr(err.exception) def test_schema_required(self): - with assertRaisesRegex(self, ValueError, "schema must be specified"): + with self.assertRaisesRegex(ValueError, "schema must be specified"): self.base_klass.__mro__[1]() @given(booleans(), booleans(), binary(min_size=1), binary(min_size=1)) @@ -6734,12 +6717,12 @@ class SeqOfMixing(object): with self.assertRaises(BoundsError) as err: SeqOf(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: SeqOf(bounds=(bound_min, bound_max)).decode( SeqOf(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: SeqOf(bounds=(bound_min, bound_max)).decode( encode2pass(SeqOf(value)) ) @@ -6750,12 +6733,12 @@ class SeqOfMixing(object): with self.assertRaises(BoundsError) as err: SeqOf(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: SeqOf(bounds=(bound_min, bound_max)).decode( SeqOf(value).encode() ) repr(err.exception) - with assertRaisesRegex(self, DecodeError, "bounds") as err: + with self.assertRaisesRegex(DecodeError, "bounds") as err: SeqOf(bounds=(bound_min, bound_max)).decode( encode2pass(SeqOf(value)) ) @@ -7113,8 +7096,8 @@ class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase): register_class(SeqOf) seqof = SeqOf() pickle_dumps(seqof) - seqof = seqof(iter(six_xrange(10))) - with assertRaisesRegex(self, ValueError, "iterator"): + seqof = seqof(iter(range(10))) + with self.assertRaisesRegex(ValueError, "iterator"): pickle_dumps(seqof) def test_iterator_bounds(self): @@ -7124,7 +7107,7 @@ class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase): seqof = None def gen(n): - for i in six_xrange(n): + for i in range(n): yield Integer(i) for n in (9, 21): seqof = SeqOf(gen(n)) @@ -7144,7 +7127,7 @@ class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase): bounds = (1, float("+inf")) def gen(): - for i in six_xrange(10): + for i in range(10): yield Integer(i) seqof = SeqOf(gen()) self.assertTrue(seqof.ready) @@ -7159,7 +7142,7 @@ class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase): bounds = (1, float("+inf")) def gen(): - for i in six_xrange(10): + for i in range(10): yield Integer(i) seqof = SeqOf(gen()) self.assertTrue(seqof.ready) @@ -7228,7 +7211,7 @@ class TestSetOf(SeqOfMixing, CommonMixin, TestCase): class Seq(SetOf): schema = OctetString() seq = Seq() - with assertRaisesRegex(self, DecodeError, "unordered SET OF"): + with self.assertRaisesRegex(DecodeError, "unordered SET OF"): seq.decode(seq_encoded) for ctx in ({"bered": True}, {"allow_unordered_set": True}): @@ -7705,7 +7688,7 @@ class TestDefinesByPath(TestCase): ("oid", oid), ("tgt", OctetString(Integer(123).encode() + b"junk")), )) - with assertRaisesRegex(self, DecodeError, "remaining data"): + with self.assertRaisesRegex(DecodeError, "remaining data"): Seq().decode(seq.encode()) def test_remaining_data_seqof(self): @@ -7726,7 +7709,7 @@ class TestDefinesByPath(TestCase): ("oid", oid), ("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])), )) - with assertRaisesRegex(self, DecodeError, "remaining data"): + with self.assertRaisesRegex(DecodeError, "remaining data"): Seq().decode(seq.encode()) @@ -7780,7 +7763,7 @@ class TestStrictDefaultExistence(TestCase): raw = seq.encode() chosen_choice = "int%d" % chosen seq.specs[chosen_choice] = seq.specs[chosen_choice](default=123) - with assertRaisesRegex(self, DecodeError, "DEFAULT value met"): + with self.assertRaisesRegex(DecodeError, "DEFAULT value met"): seq.decode(raw) decoded, _ = seq.decode(raw, ctx={"allow_default_values": True}) self.assertTrue(decoded.ber_encoded) @@ -7848,7 +7831,7 @@ class TestExplOOB(TestCase): expl = tag_ctxc(123) raw = Integer(123).encode() + Integer(234).encode() raw = b"".join((expl, len_encode(len(raw)), raw)) - with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"): + with self.assertRaisesRegex(DecodeError, "explicit tag out-of-bound"): Integer(expl=expl).decode(raw) Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True}) @@ -7859,7 +7842,7 @@ class TestPickleDifferentVersion(TestCase): import pyderasn version_orig = pyderasn.__version__ pyderasn.__version__ += "different" - with assertRaisesRegex(self, ValueError, "different PyDERASN version"): + with self.assertRaisesRegex(ValueError, "different PyDERASN version"): pickle_loads(pickled) pyderasn.__version__ = version_orig pickle_loads(pickled)