Guido van Rossum | fdecda0 | 1999-10-19 19:08:13 +0000 | [diff] [blame] | 1 | """Test the binascii C module.""" |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 2 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 3 | import unittest |
Guido van Rossum | fdecda0 | 1999-10-19 19:08:13 +0000 | [diff] [blame] | 4 | import binascii |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 5 | import array |
Tal Einat | 1fba2ff | 2018-09-28 08:57:22 +0300 | [diff] [blame] | 6 | import re |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 7 | |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 8 | # Note: "*_hex" functions are aliases for "(un)hexlify" |
| 9 | b2a_functions = ['b2a_base64', 'b2a_hex', 'b2a_hqx', 'b2a_qp', 'b2a_uu', |
| 10 | 'hexlify', 'rlecode_hqx'] |
| 11 | a2b_functions = ['a2b_base64', 'a2b_hex', 'a2b_hqx', 'a2b_qp', 'a2b_uu', |
| 12 | 'unhexlify', 'rledecode_hqx'] |
| 13 | all_functions = a2b_functions + b2a_functions + ['crc32', 'crc_hqx'] |
| 14 | |
| 15 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 16 | class BinASCIITest(unittest.TestCase): |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 17 | |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 18 | type2test = bytes |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 19 | # Create binary test data |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 20 | rawdata = b"The quick brown fox jumps over the lazy dog.\r\n" |
Guido van Rossum | fdecda0 | 1999-10-19 19:08:13 +0000 | [diff] [blame] | 21 | # Be slow so we don't depend on other modules |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 22 | rawdata += bytes(range(256)) |
| 23 | rawdata += b"\r\nHello world.\n" |
| 24 | |
| 25 | def setUp(self): |
| 26 | self.data = self.type2test(self.rawdata) |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 27 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 28 | def test_exceptions(self): |
| 29 | # Check module exceptions |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 30 | self.assertTrue(issubclass(binascii.Error, Exception)) |
| 31 | self.assertTrue(issubclass(binascii.Incomplete, Exception)) |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 32 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 33 | def test_functions(self): |
| 34 | # Check presence of all functions |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 35 | for name in all_functions: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 36 | self.assertTrue(hasattr(getattr(binascii, name), '__call__')) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 37 | self.assertRaises(TypeError, getattr(binascii, name)) |
| 38 | |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 39 | def test_returned_value(self): |
| 40 | # Limit to the minimum of all limits (b2a_uu) |
| 41 | MAX_ALL = 45 |
| 42 | raw = self.rawdata[:MAX_ALL] |
| 43 | for fa, fb in zip(a2b_functions, b2a_functions): |
| 44 | a2b = getattr(binascii, fa) |
| 45 | b2a = getattr(binascii, fb) |
| 46 | try: |
| 47 | a = b2a(self.type2test(raw)) |
| 48 | res = a2b(self.type2test(a)) |
| 49 | except Exception as err: |
| 50 | self.fail("{}/{} conversion raises {!r}".format(fb, fa, err)) |
| 51 | if fb == 'b2a_hqx': |
| 52 | # b2a_hqx returns a tuple |
| 53 | res, _ = res |
| 54 | self.assertEqual(res, raw, "{}/{} conversion: " |
| 55 | "{!r} != {!r}".format(fb, fa, res, raw)) |
| 56 | self.assertIsInstance(res, bytes) |
| 57 | self.assertIsInstance(a, bytes) |
Florent Xicluna | f1046ca | 2010-07-27 21:20:15 +0000 | [diff] [blame] | 58 | self.assertLess(max(a), 128) |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 59 | self.assertIsInstance(binascii.crc_hqx(raw, 0), int) |
| 60 | self.assertIsInstance(binascii.crc32(raw), int) |
| 61 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 62 | def test_base64valid(self): |
| 63 | # Test base64 with valid data |
| 64 | MAX_BASE64 = 57 |
| 65 | lines = [] |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 66 | for i in range(0, len(self.rawdata), MAX_BASE64): |
| 67 | b = self.type2test(self.rawdata[i:i+MAX_BASE64]) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 68 | a = binascii.b2a_base64(b) |
| 69 | lines.append(a) |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 70 | res = bytes() |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 71 | for line in lines: |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 72 | a = self.type2test(line) |
| 73 | b = binascii.a2b_base64(a) |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 74 | res += b |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 75 | self.assertEqual(res, self.rawdata) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 76 | |
| 77 | def test_base64invalid(self): |
| 78 | # Test base64 with random invalid characters sprinkled throughout |
| 79 | # (This requires a new version of binascii.) |
| 80 | MAX_BASE64 = 57 |
| 81 | lines = [] |
| 82 | for i in range(0, len(self.data), MAX_BASE64): |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 83 | b = self.type2test(self.rawdata[i:i+MAX_BASE64]) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 84 | a = binascii.b2a_base64(b) |
| 85 | lines.append(a) |
| 86 | |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 87 | fillers = bytearray() |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 88 | valid = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/" |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 89 | for i in range(256): |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 90 | if i not in valid: |
| 91 | fillers.append(i) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 92 | def addnoise(line): |
| 93 | noise = fillers |
| 94 | ratio = len(line) // len(noise) |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 95 | res = bytearray() |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 96 | while line and noise: |
| 97 | if len(line) // len(noise) > ratio: |
| 98 | c, line = line[0], line[1:] |
| 99 | else: |
| 100 | c, noise = noise[0], noise[1:] |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 101 | res.append(c) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 102 | return res + noise + line |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 103 | res = bytearray() |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 104 | for line in map(addnoise, lines): |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 105 | a = self.type2test(line) |
| 106 | b = binascii.a2b_base64(a) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 107 | res += b |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 108 | self.assertEqual(res, self.rawdata) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 109 | |
| 110 | # Test base64 with just invalid characters, which should return |
| 111 | # empty strings. TBD: shouldn't it raise an exception instead ? |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 112 | self.assertEqual(binascii.a2b_base64(self.type2test(fillers)), b'') |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 113 | |
Tal Einat | 1b85c71 | 2018-06-10 10:01:50 +0300 | [diff] [blame] | 114 | def test_base64errors(self): |
| 115 | # Test base64 with invalid padding |
| 116 | def assertIncorrectPadding(data): |
| 117 | with self.assertRaisesRegex(binascii.Error, r'(?i)Incorrect padding'): |
| 118 | binascii.a2b_base64(self.type2test(data)) |
| 119 | |
| 120 | assertIncorrectPadding(b'ab') |
| 121 | assertIncorrectPadding(b'ab=') |
| 122 | assertIncorrectPadding(b'abc') |
| 123 | assertIncorrectPadding(b'abcdef') |
| 124 | assertIncorrectPadding(b'abcdef=') |
| 125 | assertIncorrectPadding(b'abcdefg') |
| 126 | assertIncorrectPadding(b'a=b=') |
| 127 | assertIncorrectPadding(b'a\nb=') |
| 128 | |
| 129 | # Test base64 with invalid number of valid characters (1 mod 4) |
| 130 | def assertInvalidLength(data): |
Tal Einat | 1fba2ff | 2018-09-28 08:57:22 +0300 | [diff] [blame] | 131 | n_data_chars = len(re.sub(br'[^A-Za-z0-9/+]', br'', data)) |
| 132 | expected_errmsg_re = \ |
| 133 | r'(?i)Invalid.+number of data characters.+' + str(n_data_chars) |
| 134 | with self.assertRaisesRegex(binascii.Error, expected_errmsg_re): |
Tal Einat | 1b85c71 | 2018-06-10 10:01:50 +0300 | [diff] [blame] | 135 | binascii.a2b_base64(self.type2test(data)) |
| 136 | |
| 137 | assertInvalidLength(b'a') |
| 138 | assertInvalidLength(b'a=') |
| 139 | assertInvalidLength(b'a==') |
| 140 | assertInvalidLength(b'a===') |
| 141 | assertInvalidLength(b'a' * 5) |
| 142 | assertInvalidLength(b'a' * (4 * 87 + 1)) |
| 143 | assertInvalidLength(b'A\tB\nC ??DE') # only 5 valid characters |
| 144 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 145 | def test_uu(self): |
| 146 | MAX_UU = 45 |
Xiang Zhang | 13f1f42 | 2017-05-03 11:16:21 +0800 | [diff] [blame] | 147 | for backtick in (True, False): |
| 148 | lines = [] |
| 149 | for i in range(0, len(self.data), MAX_UU): |
| 150 | b = self.type2test(self.rawdata[i:i+MAX_UU]) |
| 151 | a = binascii.b2a_uu(b, backtick=backtick) |
| 152 | lines.append(a) |
| 153 | res = bytes() |
| 154 | for line in lines: |
| 155 | a = self.type2test(line) |
| 156 | b = binascii.a2b_uu(a) |
| 157 | res += b |
| 158 | self.assertEqual(res, self.rawdata) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 159 | |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 160 | self.assertEqual(binascii.a2b_uu(b"\x7f"), b"\x00"*31) |
| 161 | self.assertEqual(binascii.a2b_uu(b"\x80"), b"\x00"*32) |
| 162 | self.assertEqual(binascii.a2b_uu(b"\xff"), b"\x00"*31) |
| 163 | self.assertRaises(binascii.Error, binascii.a2b_uu, b"\xff\x00") |
| 164 | self.assertRaises(binascii.Error, binascii.a2b_uu, b"!!!!") |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 165 | self.assertRaises(binascii.Error, binascii.b2a_uu, 46*b"!") |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 166 | |
Antoine Pitrou | 2843aa8 | 2010-01-15 00:27:43 +0000 | [diff] [blame] | 167 | # Issue #7701 (crash on a pydebug build) |
| 168 | self.assertEqual(binascii.b2a_uu(b'x'), b'!> \n') |
| 169 | |
Xiang Zhang | 13f1f42 | 2017-05-03 11:16:21 +0800 | [diff] [blame] | 170 | self.assertEqual(binascii.b2a_uu(b''), b' \n') |
| 171 | self.assertEqual(binascii.b2a_uu(b'', backtick=True), b'`\n') |
| 172 | self.assertEqual(binascii.a2b_uu(b' \n'), b'') |
| 173 | self.assertEqual(binascii.a2b_uu(b'`\n'), b'') |
| 174 | self.assertEqual(binascii.b2a_uu(b'\x00Cat'), b'$ $-A= \n') |
| 175 | self.assertEqual(binascii.b2a_uu(b'\x00Cat', backtick=True), |
| 176 | b'$`$-A=```\n') |
| 177 | self.assertEqual(binascii.a2b_uu(b'$`$-A=```\n'), |
| 178 | binascii.a2b_uu(b'$ $-A= \n')) |
| 179 | with self.assertRaises(TypeError): |
| 180 | binascii.b2a_uu(b"", True) |
| 181 | |
Serhiy Storchaka | 2ef7c47 | 2015-04-20 09:26:49 +0300 | [diff] [blame] | 182 | def test_crc_hqx(self): |
| 183 | crc = binascii.crc_hqx(self.type2test(b"Test the CRC-32 of"), 0) |
| 184 | crc = binascii.crc_hqx(self.type2test(b" this string."), crc) |
| 185 | self.assertEqual(crc, 14290) |
| 186 | |
| 187 | self.assertRaises(TypeError, binascii.crc_hqx) |
| 188 | self.assertRaises(TypeError, binascii.crc_hqx, self.type2test(b'')) |
| 189 | |
| 190 | for crc in 0, 1, 0x1234, 0x12345, 0x12345678, -1: |
| 191 | self.assertEqual(binascii.crc_hqx(self.type2test(b''), crc), |
| 192 | crc & 0xffff) |
| 193 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 194 | def test_crc32(self): |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 195 | crc = binascii.crc32(self.type2test(b"Test the CRC-32 of")) |
| 196 | crc = binascii.crc32(self.type2test(b" this string."), crc) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 197 | self.assertEqual(crc, 1571220330) |
| 198 | |
| 199 | self.assertRaises(TypeError, binascii.crc32) |
| 200 | |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 201 | def test_hqx(self): |
| 202 | # Perform binhex4 style RLE-compression |
| 203 | # Then calculate the hexbin4 binary-to-ASCII translation |
| 204 | rle = binascii.rlecode_hqx(self.data) |
| 205 | a = binascii.b2a_hqx(self.type2test(rle)) |
Victor Stinner | 1bfe930 | 2015-10-14 15:02:35 +0200 | [diff] [blame] | 206 | |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 207 | b, _ = binascii.a2b_hqx(self.type2test(a)) |
| 208 | res = binascii.rledecode_hqx(b) |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 209 | self.assertEqual(res, self.rawdata) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 210 | |
Victor Stinner | 1bfe930 | 2015-10-14 15:02:35 +0200 | [diff] [blame] | 211 | def test_rle(self): |
| 212 | # test repetition with a repetition longer than the limit of 255 |
| 213 | data = (b'a' * 100 + b'b' + b'c' * 300) |
| 214 | |
| 215 | encoded = binascii.rlecode_hqx(data) |
| 216 | self.assertEqual(encoded, |
| 217 | (b'a\x90d' # 'a' * 100 |
| 218 | b'b' # 'b' |
| 219 | b'c\x90\xff' # 'c' * 255 |
| 220 | b'c\x90-')) # 'c' * 45 |
| 221 | |
| 222 | decoded = binascii.rledecode_hqx(encoded) |
| 223 | self.assertEqual(decoded, data) |
| 224 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 225 | def test_hex(self): |
| 226 | # test hexlification |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 227 | s = b'{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000' |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 228 | t = binascii.b2a_hex(self.type2test(s)) |
| 229 | u = binascii.a2b_hex(self.type2test(t)) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 230 | self.assertEqual(s, u) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 231 | self.assertRaises(binascii.Error, binascii.a2b_hex, t[:-1]) |
| 232 | self.assertRaises(binascii.Error, binascii.a2b_hex, t[:-1] + b'q') |
Sergey Fedoseev | 6b5df90 | 2018-02-27 01:35:41 +0500 | [diff] [blame] | 233 | self.assertRaises(binascii.Error, binascii.a2b_hex, bytes([255, 255])) |
| 234 | self.assertRaises(binascii.Error, binascii.a2b_hex, b'0G') |
| 235 | self.assertRaises(binascii.Error, binascii.a2b_hex, b'0g') |
| 236 | self.assertRaises(binascii.Error, binascii.a2b_hex, b'G0') |
| 237 | self.assertRaises(binascii.Error, binascii.a2b_hex, b'g0') |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 238 | |
Zachary Ware | b176d40 | 2015-01-20 13:59:46 -0600 | [diff] [blame] | 239 | # Confirm that b2a_hex == hexlify and a2b_hex == unhexlify |
| 240 | self.assertEqual(binascii.hexlify(self.type2test(s)), t) |
| 241 | self.assertEqual(binascii.unhexlify(self.type2test(t)), u) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 242 | |
Gregory P. Smith | 0c2f930 | 2019-05-29 11:46:58 -0700 | [diff] [blame] | 243 | def test_hex_separator(self): |
| 244 | """Test that hexlify and b2a_hex are binary versions of bytes.hex.""" |
| 245 | # Logic of separators is tested in test_bytes.py. This checks that |
| 246 | # arg parsing works and exercises the direct to bytes object code |
| 247 | # path within pystrhex.c. |
| 248 | s = b'{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000' |
| 249 | self.assertEqual(binascii.hexlify(self.type2test(s)), s.hex().encode('ascii')) |
| 250 | expected8 = s.hex('.', 8).encode('ascii') |
| 251 | self.assertEqual(binascii.hexlify(self.type2test(s), '.', 8), expected8) |
| 252 | expected1 = s.hex(':').encode('ascii') |
| 253 | self.assertEqual(binascii.b2a_hex(self.type2test(s), ':'), expected1) |
| 254 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 255 | def test_qp(self): |
Serhiy Storchaka | e6265e9 | 2016-09-14 16:34:37 +0300 | [diff] [blame] | 256 | type2test = self.type2test |
| 257 | a2b_qp = binascii.a2b_qp |
| 258 | b2a_qp = binascii.b2a_qp |
| 259 | |
| 260 | a2b_qp(data=b"", header=False) # Keyword arguments allowed |
Martin Panter | bf19d16 | 2015-09-09 01:01:13 +0000 | [diff] [blame] | 261 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 262 | # A test for SF bug 534347 (segfaults without the proper fix) |
| 263 | try: |
Serhiy Storchaka | e6265e9 | 2016-09-14 16:34:37 +0300 | [diff] [blame] | 264 | a2b_qp(b"", **{1:1}) |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 265 | except TypeError: |
| 266 | pass |
Guido van Rossum | fdecda0 | 1999-10-19 19:08:13 +0000 | [diff] [blame] | 267 | else: |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 268 | self.fail("binascii.a2b_qp(**{1:1}) didn't raise TypeError") |
Martin Panter | bf19d16 | 2015-09-09 01:01:13 +0000 | [diff] [blame] | 269 | |
Serhiy Storchaka | e6265e9 | 2016-09-14 16:34:37 +0300 | [diff] [blame] | 270 | self.assertEqual(a2b_qp(type2test(b"=")), b"") |
| 271 | self.assertEqual(a2b_qp(type2test(b"= ")), b"= ") |
| 272 | self.assertEqual(a2b_qp(type2test(b"==")), b"=") |
| 273 | self.assertEqual(a2b_qp(type2test(b"=\nAB")), b"AB") |
| 274 | self.assertEqual(a2b_qp(type2test(b"=\r\nAB")), b"AB") |
| 275 | self.assertEqual(a2b_qp(type2test(b"=\rAB")), b"") # ? |
| 276 | self.assertEqual(a2b_qp(type2test(b"=\rAB\nCD")), b"CD") # ? |
| 277 | self.assertEqual(a2b_qp(type2test(b"=AB")), b"\xab") |
| 278 | self.assertEqual(a2b_qp(type2test(b"=ab")), b"\xab") |
| 279 | self.assertEqual(a2b_qp(type2test(b"=AX")), b"=AX") |
| 280 | self.assertEqual(a2b_qp(type2test(b"=XA")), b"=XA") |
| 281 | self.assertEqual(a2b_qp(type2test(b"=AB")[:-1]), b"=A") |
Roger E. Masse | 2a1c834 | 1997-01-16 16:44:09 +0000 | [diff] [blame] | 282 | |
Serhiy Storchaka | e6265e9 | 2016-09-14 16:34:37 +0300 | [diff] [blame] | 283 | self.assertEqual(a2b_qp(type2test(b'_')), b'_') |
| 284 | self.assertEqual(a2b_qp(type2test(b'_'), header=True), b' ') |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 285 | |
Serhiy Storchaka | e6265e9 | 2016-09-14 16:34:37 +0300 | [diff] [blame] | 286 | self.assertRaises(TypeError, b2a_qp, foo="bar") |
| 287 | self.assertEqual(a2b_qp(type2test(b"=00\r\n=00")), b"\x00\r\n\x00") |
| 288 | self.assertEqual(b2a_qp(type2test(b"\xff\r\n\xff\n\xff")), |
| 289 | b"=FF\r\n=FF\r\n=FF") |
| 290 | self.assertEqual(b2a_qp(type2test(b"0"*75+b"\xff\r\n\xff\r\n\xff")), |
| 291 | b"0"*75+b"=\r\n=FF\r\n=FF\r\n=FF") |
| 292 | |
| 293 | self.assertEqual(b2a_qp(type2test(b'\x7f')), b'=7F') |
| 294 | self.assertEqual(b2a_qp(type2test(b'=')), b'=3D') |
| 295 | |
| 296 | self.assertEqual(b2a_qp(type2test(b'_')), b'_') |
| 297 | self.assertEqual(b2a_qp(type2test(b'_'), header=True), b'=5F') |
| 298 | self.assertEqual(b2a_qp(type2test(b'x y'), header=True), b'x_y') |
| 299 | self.assertEqual(b2a_qp(type2test(b'x '), header=True), b'x=20') |
| 300 | self.assertEqual(b2a_qp(type2test(b'x y'), header=True, quotetabs=True), |
| 301 | b'x=20y') |
| 302 | self.assertEqual(b2a_qp(type2test(b'x\ty'), header=True), b'x\ty') |
| 303 | |
| 304 | self.assertEqual(b2a_qp(type2test(b' ')), b'=20') |
| 305 | self.assertEqual(b2a_qp(type2test(b'\t')), b'=09') |
| 306 | self.assertEqual(b2a_qp(type2test(b' x')), b' x') |
| 307 | self.assertEqual(b2a_qp(type2test(b'\tx')), b'\tx') |
| 308 | self.assertEqual(b2a_qp(type2test(b' x')[:-1]), b'=20') |
| 309 | self.assertEqual(b2a_qp(type2test(b'\tx')[:-1]), b'=09') |
| 310 | self.assertEqual(b2a_qp(type2test(b'\0')), b'=00') |
| 311 | |
| 312 | self.assertEqual(b2a_qp(type2test(b'\0\n')), b'=00\n') |
| 313 | self.assertEqual(b2a_qp(type2test(b'\0\n'), quotetabs=True), b'=00\n') |
| 314 | |
| 315 | self.assertEqual(b2a_qp(type2test(b'x y\tz')), b'x y\tz') |
| 316 | self.assertEqual(b2a_qp(type2test(b'x y\tz'), quotetabs=True), |
| 317 | b'x=20y=09z') |
| 318 | self.assertEqual(b2a_qp(type2test(b'x y\tz'), istext=False), |
| 319 | b'x y\tz') |
| 320 | self.assertEqual(b2a_qp(type2test(b'x \ny\t\n')), |
| 321 | b'x=20\ny=09\n') |
| 322 | self.assertEqual(b2a_qp(type2test(b'x \ny\t\n'), quotetabs=True), |
| 323 | b'x=20\ny=09\n') |
| 324 | self.assertEqual(b2a_qp(type2test(b'x \ny\t\n'), istext=False), |
| 325 | b'x =0Ay\t=0A') |
| 326 | self.assertEqual(b2a_qp(type2test(b'x \ry\t\r')), |
| 327 | b'x \ry\t\r') |
| 328 | self.assertEqual(b2a_qp(type2test(b'x \ry\t\r'), quotetabs=True), |
| 329 | b'x=20\ry=09\r') |
| 330 | self.assertEqual(b2a_qp(type2test(b'x \ry\t\r'), istext=False), |
| 331 | b'x =0Dy\t=0D') |
| 332 | self.assertEqual(b2a_qp(type2test(b'x \r\ny\t\r\n')), |
| 333 | b'x=20\r\ny=09\r\n') |
| 334 | self.assertEqual(b2a_qp(type2test(b'x \r\ny\t\r\n'), quotetabs=True), |
| 335 | b'x=20\r\ny=09\r\n') |
| 336 | self.assertEqual(b2a_qp(type2test(b'x \r\ny\t\r\n'), istext=False), |
| 337 | b'x =0D=0Ay\t=0D=0A') |
| 338 | |
| 339 | self.assertEqual(b2a_qp(type2test(b'x \r\n')[:-1]), b'x \r') |
| 340 | self.assertEqual(b2a_qp(type2test(b'x\t\r\n')[:-1]), b'x\t\r') |
| 341 | self.assertEqual(b2a_qp(type2test(b'x \r\n')[:-1], quotetabs=True), |
| 342 | b'x=20\r') |
| 343 | self.assertEqual(b2a_qp(type2test(b'x\t\r\n')[:-1], quotetabs=True), |
| 344 | b'x=09\r') |
| 345 | self.assertEqual(b2a_qp(type2test(b'x \r\n')[:-1], istext=False), |
| 346 | b'x =0D') |
| 347 | self.assertEqual(b2a_qp(type2test(b'x\t\r\n')[:-1], istext=False), |
| 348 | b'x\t=0D') |
| 349 | |
| 350 | self.assertEqual(b2a_qp(type2test(b'.')), b'=2E') |
| 351 | self.assertEqual(b2a_qp(type2test(b'.\n')), b'=2E\n') |
| 352 | self.assertEqual(b2a_qp(type2test(b'.\r')), b'=2E\r') |
| 353 | self.assertEqual(b2a_qp(type2test(b'.\0')), b'=2E=00') |
| 354 | self.assertEqual(b2a_qp(type2test(b'a.\n')), b'a.\n') |
| 355 | self.assertEqual(b2a_qp(type2test(b'.a')[:-1]), b'=2E') |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 356 | |
Raymond Hettinger | 658717e | 2004-09-06 22:58:37 +0000 | [diff] [blame] | 357 | def test_empty_string(self): |
| 358 | # A test for SF bug #1022953. Make sure SystemError is not raised. |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 359 | empty = self.type2test(b'') |
| 360 | for func in all_functions: |
| 361 | if func == 'crc_hqx': |
| 362 | # crc_hqx needs 2 arguments |
| 363 | binascii.crc_hqx(empty, 0) |
| 364 | continue |
| 365 | f = getattr(binascii, func) |
Guido van Rossum | 0e225aa | 2007-05-22 20:24:57 +0000 | [diff] [blame] | 366 | try: |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 367 | f(empty) |
| 368 | except Exception as err: |
| 369 | self.fail("{}({!r}) raises {!r}".format(func, empty, err)) |
Martin v. Löwis | 15b16a3 | 2008-12-02 06:00:15 +0000 | [diff] [blame] | 370 | |
Antoine Pitrou | 0831676 | 2011-12-20 13:58:41 +0100 | [diff] [blame] | 371 | def test_unicode_b2a(self): |
| 372 | # Unicode strings are not accepted by b2a_* functions. |
| 373 | for func in set(all_functions) - set(a2b_functions) | {'rledecode_hqx'}: |
Florent Xicluna | f1046ca | 2010-07-27 21:20:15 +0000 | [diff] [blame] | 374 | try: |
| 375 | self.assertRaises(TypeError, getattr(binascii, func), "test") |
| 376 | except Exception as err: |
| 377 | self.fail('{}("test") raises {!r}'.format(func, err)) |
| 378 | # crc_hqx needs 2 arguments |
| 379 | self.assertRaises(TypeError, binascii.crc_hqx, "test", 0) |
Raymond Hettinger | 658717e | 2004-09-06 22:58:37 +0000 | [diff] [blame] | 380 | |
Antoine Pitrou | 0831676 | 2011-12-20 13:58:41 +0100 | [diff] [blame] | 381 | def test_unicode_a2b(self): |
| 382 | # Unicode strings are accepted by a2b_* functions. |
| 383 | MAX_ALL = 45 |
| 384 | raw = self.rawdata[:MAX_ALL] |
| 385 | for fa, fb in zip(a2b_functions, b2a_functions): |
| 386 | if fa == 'rledecode_hqx': |
| 387 | # Takes non-ASCII data |
| 388 | continue |
| 389 | a2b = getattr(binascii, fa) |
| 390 | b2a = getattr(binascii, fb) |
| 391 | try: |
| 392 | a = b2a(self.type2test(raw)) |
| 393 | binary_res = a2b(a) |
| 394 | a = a.decode('ascii') |
| 395 | res = a2b(a) |
| 396 | except Exception as err: |
| 397 | self.fail("{}/{} conversion raises {!r}".format(fb, fa, err)) |
| 398 | if fb == 'b2a_hqx': |
| 399 | # b2a_hqx returns a tuple |
| 400 | res, _ = res |
| 401 | binary_res, _ = binary_res |
| 402 | self.assertEqual(res, raw, "{}/{} conversion: " |
| 403 | "{!r} != {!r}".format(fb, fa, res, raw)) |
| 404 | self.assertEqual(res, binary_res) |
| 405 | self.assertIsInstance(res, bytes) |
| 406 | # non-ASCII string |
| 407 | self.assertRaises(ValueError, a2b, "\x80") |
| 408 | |
Victor Stinner | e84c976 | 2015-10-11 11:01:02 +0200 | [diff] [blame] | 409 | def test_b2a_base64_newline(self): |
| 410 | # Issue #25357: test newline parameter |
| 411 | b = self.type2test(b'hello') |
| 412 | self.assertEqual(binascii.b2a_base64(b), |
| 413 | b'aGVsbG8=\n') |
| 414 | self.assertEqual(binascii.b2a_base64(b, newline=True), |
| 415 | b'aGVsbG8=\n') |
| 416 | self.assertEqual(binascii.b2a_base64(b, newline=False), |
| 417 | b'aGVsbG8=') |
| 418 | |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 419 | |
| 420 | class ArrayBinASCIITest(BinASCIITest): |
| 421 | def type2test(self, s): |
| 422 | return array.array('B', list(s)) |
| 423 | |
| 424 | |
Antoine Pitrou | 747e8b3 | 2010-01-16 17:55:52 +0000 | [diff] [blame] | 425 | class BytearrayBinASCIITest(BinASCIITest): |
| 426 | type2test = bytearray |
| 427 | |
| 428 | |
Antoine Pitrou | 6d4b00c | 2010-01-14 16:33:34 +0000 | [diff] [blame] | 429 | class MemoryviewBinASCIITest(BinASCIITest): |
| 430 | type2test = memoryview |
| 431 | |
| 432 | |
Walter Dörwald | cd1e8a9 | 2004-03-15 12:07:38 +0000 | [diff] [blame] | 433 | if __name__ == "__main__": |
Zachary Ware | 38c707e | 2015-04-13 15:00:43 -0500 | [diff] [blame] | 434 | unittest.main() |