import unittest
from test import support
import base64
import binascii
import os
import sys
import subprocess



class LegacyBase64TestCase(unittest.TestCase):
    def test_encodebytes(self):
        eq = self.assertEqual
        eq(base64.encodebytes(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=\n")
        eq(base64.encodebytes(b"a"), b"YQ==\n")
        eq(base64.encodebytes(b"ab"), b"YWI=\n")
        eq(base64.encodebytes(b"abc"), b"YWJj\n")
        eq(base64.encodebytes(b""), b"")
        eq(base64.encodebytes(b"abcdefghijklmnopqrstuvwxyz"
                               b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               b"0123456789!@#0^&*();:<>,. []{}"),
           b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
           b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
           b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n")
        # Non-bytes
        eq(base64.encodebytes(bytearray(b'abc')), b'YWJj\n')
        self.assertRaises(TypeError, base64.encodebytes, "")

    def test_decodebytes(self):
        eq = self.assertEqual
        eq(base64.decodebytes(b"d3d3LnB5dGhvbi5vcmc=\n"), b"www.python.org")
        eq(base64.decodebytes(b"YQ==\n"), b"a")
        eq(base64.decodebytes(b"YWI=\n"), b"ab")
        eq(base64.decodebytes(b"YWJj\n"), b"abc")
        eq(base64.decodebytes(b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
                               b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
                               b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n"),
           b"abcdefghijklmnopqrstuvwxyz"
           b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
           b"0123456789!@#0^&*();:<>,. []{}")
        eq(base64.decodebytes(b''), b'')
        # Non-bytes
        eq(base64.decodebytes(bytearray(b'YWJj\n')), b'abc')
        self.assertRaises(TypeError, base64.decodebytes, "")

    def test_encode(self):
        eq = self.assertEqual
        from io import BytesIO, StringIO
        infp = BytesIO(b'abcdefghijklmnopqrstuvwxyz'
                       b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                       b'0123456789!@#0^&*();:<>,. []{}')
        outfp = BytesIO()
        base64.encode(infp, outfp)
        eq(outfp.getvalue(),
           b'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE'
           b'RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT'
           b'Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n')
        # Non-binary files
        self.assertRaises(TypeError, base64.encode, StringIO('abc'), BytesIO())
        self.assertRaises(TypeError, base64.encode, BytesIO(b'abc'), StringIO())
        self.assertRaises(TypeError, base64.encode, StringIO('abc'), StringIO())

    def test_decode(self):
        from io import BytesIO, StringIO
        infp = BytesIO(b'd3d3LnB5dGhvbi5vcmc=')
        outfp = BytesIO()
        base64.decode(infp, outfp)
        self.assertEqual(outfp.getvalue(), b'www.python.org')
        # Non-binary files
        self.assertRaises(TypeError, base64.encode, StringIO('YWJj\n'), BytesIO())
        self.assertRaises(TypeError, base64.encode, BytesIO(b'YWJj\n'), StringIO())
        self.assertRaises(TypeError, base64.encode, StringIO('YWJj\n'), StringIO())


class BaseXYTestCase(unittest.TestCase):
    def test_b64encode(self):
        eq = self.assertEqual
        # Test default alphabet
        eq(base64.b64encode(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=")
        eq(base64.b64encode(b'\x00'), b'AA==')
        eq(base64.b64encode(b"a"), b"YQ==")
        eq(base64.b64encode(b"ab"), b"YWI=")
        eq(base64.b64encode(b"abc"), b"YWJj")
        eq(base64.b64encode(b""), b"")
        eq(base64.b64encode(b"abcdefghijklmnopqrstuvwxyz"
                            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                            b"0123456789!@#0^&*();:<>,. []{}"),
           b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
           b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NT"
           b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==")
        # Test with arbitrary alternative characters
        eq(base64.b64encode(b'\xd3V\xbeo\xf7\x1d', altchars=b'*$'), b'01a*b$cd')
        # Non-bytes
        eq(base64.b64encode(bytearray(b'abcd')), b'YWJjZA==')
        eq(base64.b64encode(b'\xd3V\xbeo\xf7\x1d', altchars=bytearray(b'*$')),
           b'01a*b$cd')
        # Check if passing a str object raises an error
        self.assertRaises(TypeError, base64.b64encode, "")
        self.assertRaises(TypeError, base64.b64encode, b"", altchars="")
        # Test standard alphabet
        eq(base64.standard_b64encode(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=")
        eq(base64.standard_b64encode(b"a"), b"YQ==")
        eq(base64.standard_b64encode(b"ab"), b"YWI=")
        eq(base64.standard_b64encode(b"abc"), b"YWJj")
        eq(base64.standard_b64encode(b""), b"")
        eq(base64.standard_b64encode(b"abcdefghijklmnopqrstuvwxyz"
                                     b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                     b"0123456789!@#0^&*();:<>,. []{}"),
           b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
           b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NT"
           b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==")
        # Non-bytes
        eq(base64.standard_b64encode(bytearray(b'abcd')), b'YWJjZA==')
        # Check if passing a str object raises an error
        self.assertRaises(TypeError, base64.standard_b64encode, "")
        # Test with 'URL safe' alternative characters
        eq(base64.urlsafe_b64encode(b'\xd3V\xbeo\xf7\x1d'), b'01a-b_cd')
        # Non-bytes
        eq(base64.urlsafe_b64encode(bytearray(b'\xd3V\xbeo\xf7\x1d')), b'01a-b_cd')
        # Check if passing a str object raises an error
        self.assertRaises(TypeError, base64.urlsafe_b64encode, "")

    def test_b64decode(self):
        eq = self.assertEqual

        tests = {b"d3d3LnB5dGhvbi5vcmc=": b"www.python.org",
                 b'AA==': b'\x00',
                 b"YQ==": b"a",
                 b"YWI=": b"ab",
                 b"YWJj": b"abc",
                 b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
                 b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
                 b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==":

                 b"abcdefghijklmnopqrstuvwxyz"
                 b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                 b"0123456789!@#0^&*();:<>,. []{}",
                 b'': b'',
                 }
        for data, res in tests.items():
            eq(base64.b64decode(data), res)
            eq(base64.b64decode(data.decode('ascii')), res)
        # Non-bytes
        eq(base64.b64decode(bytearray(b"YWJj")), b"abc")

        # Test with arbitrary alternative characters
        tests_altchars = {(b'01a*b$cd', b'*$'): b'\xd3V\xbeo\xf7\x1d',
                          }
        for (data, altchars), res in tests_altchars.items():
            data_str = data.decode('ascii')
            altchars_str = altchars.decode('ascii')

            eq(base64.b64decode(data, altchars=altchars), res)
            eq(base64.b64decode(data_str, altchars=altchars), res)
            eq(base64.b64decode(data, altchars=altchars_str), res)
            eq(base64.b64decode(data_str, altchars=altchars_str), res)

        # Test standard alphabet
        for data, res in tests.items():
            eq(base64.standard_b64decode(data), res)
            eq(base64.standard_b64decode(data.decode('ascii')), res)
        # Non-bytes
        eq(base64.standard_b64decode(bytearray(b"YWJj")), b"abc")

        # Test with 'URL safe' alternative characters
        tests_urlsafe = {b'01a-b_cd': b'\xd3V\xbeo\xf7\x1d',
                         b'': b'',
                         }
        for data, res in tests_urlsafe.items():
            eq(base64.urlsafe_b64decode(data), res)
            eq(base64.urlsafe_b64decode(data.decode('ascii')), res)
        # Non-bytes
        eq(base64.urlsafe_b64decode(bytearray(b'01a-b_cd')), b'\xd3V\xbeo\xf7\x1d')

    def test_b64decode_padding_error(self):
        self.assertRaises(binascii.Error, base64.b64decode, b'abc')
        self.assertRaises(binascii.Error, base64.b64decode, 'abc')

    def test_b64decode_invalid_chars(self):
        # issue 1466065: Test some invalid characters.
        tests = ((b'%3d==', b'\xdd'),
                 (b'$3d==', b'\xdd'),
                 (b'[==', b''),
                 (b'YW]3=', b'am'),
                 (b'3{d==', b'\xdd'),
                 (b'3d}==', b'\xdd'),
                 (b'@@', b''),
                 (b'!', b''),
                 (b'YWJj\nYWI=', b'abcab'))
        for bstr, res in tests:
            self.assertEqual(base64.b64decode(bstr), res)
            self.assertEqual(base64.b64decode(bstr.decode('ascii')), res)
            with self.assertRaises(binascii.Error):
                base64.b64decode(bstr, validate=True)
            with self.assertRaises(binascii.Error):
                base64.b64decode(bstr.decode('ascii'), validate=True)

    def test_b32encode(self):
        eq = self.assertEqual
        eq(base64.b32encode(b''), b'')
        eq(base64.b32encode(b'\x00'), b'AA======')
        eq(base64.b32encode(b'a'), b'ME======')
        eq(base64.b32encode(b'ab'), b'MFRA====')
        eq(base64.b32encode(b'abc'), b'MFRGG===')
        eq(base64.b32encode(b'abcd'), b'MFRGGZA=')
        eq(base64.b32encode(b'abcde'), b'MFRGGZDF')
        # Non-bytes
        eq(base64.b32encode(bytearray(b'abcd')), b'MFRGGZA=')
        self.assertRaises(TypeError, base64.b32encode, "")

    def test_b32decode(self):
        eq = self.assertEqual
        tests = {b'': b'',
                 b'AA======': b'\x00',
                 b'ME======': b'a',
                 b'MFRA====': b'ab',
                 b'MFRGG===': b'abc',
                 b'MFRGGZA=': b'abcd',
                 b'MFRGGZDF': b'abcde',
                 }
        for data, res in tests.items():
            eq(base64.b32decode(data), res)
            eq(base64.b32decode(data.decode('ascii')), res)
        # Non-bytes
        eq(base64.b32decode(bytearray(b'MFRGG===')), b'abc')

    def test_b32decode_casefold(self):
        eq = self.assertEqual
        tests = {b'': b'',
                 b'ME======': b'a',
                 b'MFRA====': b'ab',
                 b'MFRGG===': b'abc',
                 b'MFRGGZA=': b'abcd',
                 b'MFRGGZDF': b'abcde',
                 # Lower cases
                 b'me======': b'a',
                 b'mfra====': b'ab',
                 b'mfrgg===': b'abc',
                 b'mfrggza=': b'abcd',
                 b'mfrggzdf': b'abcde',
                 }

        for data, res in tests.items():
            eq(base64.b32decode(data, True), res)
            eq(base64.b32decode(data.decode('ascii'), True), res)

        self.assertRaises(binascii.Error, base64.b32decode, b'me======')
        self.assertRaises(binascii.Error, base64.b32decode, 'me======')

        # Mapping zero and one
        eq(base64.b32decode(b'MLO23456'), b'b\xdd\xad\xf3\xbe')
        eq(base64.b32decode('MLO23456'), b'b\xdd\xad\xf3\xbe')

        map_tests = {(b'M1023456', b'L'): b'b\xdd\xad\xf3\xbe',
                     (b'M1023456', b'I'): b'b\x1d\xad\xf3\xbe',
                     }
        for (data, map01), res in map_tests.items():
            data_str = data.decode('ascii')
            map01_str = map01.decode('ascii')

            eq(base64.b32decode(data, map01=map01), res)
            eq(base64.b32decode(data_str, map01=map01), res)
            eq(base64.b32decode(data, map01=map01_str), res)
            eq(base64.b32decode(data_str, map01=map01_str), res)
            self.assertRaises(binascii.Error, base64.b32decode, data)
            self.assertRaises(binascii.Error, base64.b32decode, data_str)

    def test_b32decode_error(self):
        for data in [b'abc', b'ABCDEF==', b'==ABCDEF']:
            with self.assertRaises(binascii.Error):
                base64.b32decode(data)
            with self.assertRaises(binascii.Error):
                base64.b32decode(data.decode('ascii'))

    def test_b16encode(self):
        eq = self.assertEqual
        eq(base64.b16encode(b'\x01\x02\xab\xcd\xef'), b'0102ABCDEF')
        eq(base64.b16encode(b'\x00'), b'00')
        # Non-bytes
        eq(base64.b16encode(bytearray(b'\x01\x02\xab\xcd\xef')), b'0102ABCDEF')
        self.assertRaises(TypeError, base64.b16encode, "")

    def test_b16decode(self):
        eq = self.assertEqual
        eq(base64.b16decode(b'0102ABCDEF'), b'\x01\x02\xab\xcd\xef')
        eq(base64.b16decode('0102ABCDEF'), b'\x01\x02\xab\xcd\xef')
        eq(base64.b16decode(b'00'), b'\x00')
        eq(base64.b16decode('00'), b'\x00')
        # Lower case is not allowed without a flag
        self.assertRaises(binascii.Error, base64.b16decode, b'0102abcdef')
        self.assertRaises(binascii.Error, base64.b16decode, '0102abcdef')
        # Case fold
        eq(base64.b16decode(b'0102abcdef', True), b'\x01\x02\xab\xcd\xef')
        eq(base64.b16decode('0102abcdef', True), b'\x01\x02\xab\xcd\xef')
        # Non-bytes
        eq(base64.b16decode(bytearray(b"0102ABCDEF")), b'\x01\x02\xab\xcd\xef')

    def test_decode_nonascii_str(self):
        decode_funcs = (base64.b64decode,
                        base64.standard_b64decode,
                        base64.urlsafe_b64decode,
                        base64.b32decode,
                        base64.b16decode)
        for f in decode_funcs:
            self.assertRaises(ValueError, f, 'with non-ascii \xcb')

    def test_ErrorHeritage(self):
        self.assertTrue(issubclass(binascii.Error, ValueError))



class TestMain(unittest.TestCase):
    def tearDown(self):
        if os.path.exists(support.TESTFN):
            os.unlink(support.TESTFN)

    def get_output(self, *args, **options):
        args = (sys.executable, '-m', 'base64') + args
        return subprocess.check_output(args, **options)

    def test_encode_decode(self):
        output = self.get_output('-t')
        self.assertSequenceEqual(output.splitlines(), (
            b"b'Aladdin:open sesame'",
            br"b'QWxhZGRpbjpvcGVuIHNlc2FtZQ==\n'",
            b"b'Aladdin:open sesame'",
        ))

    def test_encode_file(self):
        with open(support.TESTFN, 'wb') as fp:
            fp.write(b'a\xffb\n')

        output = self.get_output('-e', support.TESTFN)
        self.assertEqual(output.rstrip(), b'Yf9iCg==')

        with open(support.TESTFN, 'rb') as fp:
            output = self.get_output('-e', stdin=fp)
        self.assertEqual(output.rstrip(), b'Yf9iCg==')

    def test_decode(self):
        with open(support.TESTFN, 'wb') as fp:
            fp.write(b'Yf9iCg==')
        output = self.get_output('-d', support.TESTFN)
        self.assertEqual(output.rstrip(), b'a\xffb')



def test_main():
    support.run_unittest(__name__)

if __name__ == '__main__':
    test_main()

[((349, 4, 349, 34), 'test.support.run_unittest', 'support.run_unittest', ({(349, 25, 349, 33): '__name__'}, {}), '(__name__)', False, 'from test import support\n'), ((49, 15, 51, 57), 'io.BytesIO', 'BytesIO', ({(49, 23, 51, 56): "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'"}, {}), "(\n    b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'\n    )", False, 'from io import BytesIO, StringIO\n'), ((52, 16, 52, 25), 'io.BytesIO', 'BytesIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((53, 8, 53, 34), 'base64.encode', 'base64.encode', ({(53, 22, 53, 26): 'infp', (53, 28, 53, 33): 'outfp'}, {}), '(infp, outfp)', False, 'import base64\n'), ((65, 15, 65, 47), 'io.BytesIO', 'BytesIO', ({(65, 23, 65, 46): "b'd3d3LnB5dGhvbi5vcmc='"}, {}), "(b'd3d3LnB5dGhvbi5vcmc=')", False, 'from io import BytesIO, StringIO\n'), ((66, 16, 66, 25), 'io.BytesIO', 'BytesIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((67, 8, 67, 34), 'base64.decode', 'base64.decode', ({(67, 22, 67, 26): 'infp', (67, 28, 67, 33): 'outfp'}, {}), '(infp, outfp)', False, 'import base64\n'), ((314, 11, 314, 41), 'os.path.exists', 'os.path.exists', ({(314, 26, 314, 40): 'support.TESTFN'}, {}), '(support.TESTFN)', False, 'import os\n'), ((319, 15, 319, 55), 'subprocess.check_output', 'subprocess.check_output', ({(319, 39, 319, 43): 'args'}, {}), '(args, **options)', False, 'import subprocess\n'), ((14, 11, 14, 48), 'base64.encodebytes', 'base64.encodebytes', ({(14, 30, 14, 47): "b'www.python.org'"}, {}), "(b'www.python.org')", False, 'import base64\n'), ((15, 11, 15, 35), 'base64.encodebytes', 'base64.encodebytes', ({(15, 30, 15, 34): "b'a'"}, {}), "(b'a')", False, 'import base64\n'), ((16, 11, 16, 36), 'base64.encodebytes', 'base64.encodebytes', ({(16, 30, 16, 35): "b'ab'"}, {}), "(b'ab')", False, 'import base64\n'), ((17, 11, 17, 37), 'base64.encodebytes', 'base64.encodebytes', ({(17, 30, 17, 36): "b'abc'"}, {}), "(b'abc')", False, 'import base64\n'), ((18, 11, 18, 34), 'base64.encodebytes', 'base64.encodebytes', ({(18, 30, 18, 33): "b''"}, {}), "(b'')", False, 'import base64\n'), ((19, 11, 21, 65), 'base64.encodebytes', 'base64.encodebytes', ({(19, 30, 21, 64): "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'"}, {}), "(\n    b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'\n    )", False, 'import base64\n'), ((31, 11, 31, 56), 'base64.decodebytes', 'base64.decodebytes', ({(31, 30, 31, 55): "b'd3d3LnB5dGhvbi5vcmc=\\n'"}, {}), "(b'd3d3LnB5dGhvbi5vcmc=\\n')", False, 'import base64\n'), ((32, 11, 32, 40), 'base64.decodebytes', 'base64.decodebytes', ({(32, 30, 32, 39): "b'YQ==\\n'"}, {}), "(b'YQ==\\n')", False, 'import base64\n'), ((33, 11, 33, 40), 'base64.decodebytes', 'base64.decodebytes', ({(33, 30, 33, 39): "b'YWI=\\n'"}, {}), "(b'YWI=\\n')", False, 'import base64\n'), ((34, 11, 34, 40), 'base64.decodebytes', 'base64.decodebytes', ({(34, 30, 34, 39): "b'YWJj\\n'"}, {}), "(b'YWJj\\n')", False, 'import base64\n'), ((35, 11, 37, 71), 'base64.decodebytes', 'base64.decodebytes', ({(35, 30, 37, 70): "b'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\\nNTY3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\\n'"}, {}), "(\n    b'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\\nNTY3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\\n'\n    )", False, 'import base64\n'), ((41, 11, 41, 34), 'base64.decodebytes', 'base64.decodebytes', ({(41, 30, 41, 33): "b''"}, {}), "(b'')", False, 'import base64\n'), ((59, 52, 59, 67), 'io.StringIO', 'StringIO', ({(59, 61, 59, 66): '"""abc"""'}, {}), "('abc')", False, 'from io import BytesIO, StringIO\n'), ((59, 69, 59, 78), 'io.BytesIO', 'BytesIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((60, 52, 60, 67), 'io.BytesIO', 'BytesIO', ({(60, 60, 60, 66): "b'abc'"}, {}), "(b'abc')", False, 'from io import BytesIO, StringIO\n'), ((60, 69, 60, 79), 'io.StringIO', 'StringIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((61, 52, 61, 67), 'io.StringIO', 'StringIO', ({(61, 61, 61, 66): '"""abc"""'}, {}), "('abc')", False, 'from io import BytesIO, StringIO\n'), ((61, 69, 61, 79), 'io.StringIO', 'StringIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((70, 52, 70, 70), 'io.StringIO', 'StringIO', ({(70, 61, 70, 69): '"""YWJj\n"""'}, {}), "('YWJj\\n')", False, 'from io import BytesIO, StringIO\n'), ((70, 72, 70, 81), 'io.BytesIO', 'BytesIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((71, 52, 71, 70), 'io.BytesIO', 'BytesIO', ({(71, 60, 71, 69): "b'YWJj\\n'"}, {}), "(b'YWJj\\n')", False, 'from io import BytesIO, StringIO\n'), ((71, 72, 71, 82), 'io.StringIO', 'StringIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((72, 52, 72, 70), 'io.StringIO', 'StringIO', ({(72, 61, 72, 69): '"""YWJj\n"""'}, {}), "('YWJj\\n')", False, 'from io import BytesIO, StringIO\n'), ((72, 72, 72, 82), 'io.StringIO', 'StringIO', ({}, {}), '()', False, 'from io import BytesIO, StringIO\n'), ((79, 11, 79, 46), 'base64.b64encode', 'base64.b64encode', ({(79, 28, 79, 45): "b'www.python.org'"}, {}), "(b'www.python.org')", False, 'import base64\n'), ((80, 11, 80, 36), 'base64.b64encode', 'base64.b64encode', ({(80, 28, 80, 35): "b'\\x00'"}, {}), "(b'\\x00')", False, 'import base64\n'), ((81, 11, 81, 33), 'base64.b64encode', 'base64.b64encode', ({(81, 28, 81, 32): "b'a'"}, {}), "(b'a')", False, 'import base64\n'), ((82, 11, 82, 34), 'base64.b64encode', 'base64.b64encode', ({(82, 28, 82, 33): "b'ab'"}, {}), "(b'ab')", False, 'import base64\n'), ((83, 11, 83, 35), 'base64.b64encode', 'base64.b64encode', ({(83, 28, 83, 34): "b'abc'"}, {}), "(b'abc')", False, 'import base64\n'), ((84, 11, 84, 32), 'base64.b64encode', 'base64.b64encode', ({(84, 28, 84, 31): "b''"}, {}), "(b'')", False, 'import base64\n'), ((85, 11, 87, 62), 'base64.b64encode', 'base64.b64encode', ({(85, 28, 87, 61): "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'"}, {}), "(\n    b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'\n    )", False, 'import base64\n'), ((92, 11, 92, 66), 'base64.b64encode', 'base64.b64encode', (), '', False, 'import base64\n'), ((101, 11, 101, 55), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(101, 37, 101, 54): "b'www.python.org'"}, {}), "(b'www.python.org')", False, 'import base64\n'), ((102, 11, 102, 42), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(102, 37, 102, 41): "b'a'"}, {}), "(b'a')", False, 'import base64\n'), ((103, 11, 103, 43), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(103, 37, 103, 42): "b'ab'"}, {}), "(b'ab')", False, 'import base64\n'), ((104, 11, 104, 44), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(104, 37, 104, 43): "b'abc'"}, {}), "(b'abc')", False, 'import base64\n'), ((105, 11, 105, 41), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(105, 37, 105, 40): "b''"}, {}), "(b'')", False, 'import base64\n'), ((106, 11, 108, 71), 'base64.standard_b64encode', 'base64.standard_b64encode', ({(106, 37, 108, 70): "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'"}, {}), "(\n    b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'\n    )", False, 'import base64\n'), ((117, 11, 117, 58), 'base64.urlsafe_b64encode', 'base64.urlsafe_b64encode', ({(117, 36, 117, 57): "b'\\xd3V\\xbeo\\xf7\\x1d'"}, {}), "(b'\\xd3V\\xbeo\\xf7\\x1d')", False, 'import base64\n'), ((200, 11, 200, 32), 'base64.b32encode', 'base64.b32encode', ({(200, 28, 200, 31): "b''"}, {}), "(b'')", False, 'import base64\n'), ((201, 11, 201, 36), 'base64.b32encode', 'base64.b32encode', ({(201, 28, 201, 35): "b'\\x00'"}, {}), "(b'\\x00')", False, 'import base64\n'), ((202, 11, 202, 33), 'base64.b32encode', 'base64.b32encode', ({(202, 28, 202, 32): "b'a'"}, {}), "(b'a')", False, 'import base64\n'), ((203, 11, 203, 34), 'base64.b32encode', 'base64.b32encode', ({(203, 28, 203, 33): "b'ab'"}, {}), "(b'ab')", False, 'import base64\n'), ((204, 11, 204, 35), 'base64.b32encode', 'base64.b32encode', ({(204, 28, 204, 34): "b'abc'"}, {}), "(b'abc')", False, 'import base64\n'), ((205, 11, 205, 36), 'base64.b32encode', 'base64.b32encode', ({(205, 28, 205, 35): "b'abcd'"}, {}), "(b'abcd')", False, 'import base64\n'), ((206, 11, 206, 37), 'base64.b32encode', 'base64.b32encode', ({(206, 28, 206, 36): "b'abcde'"}, {}), "(b'abcde')", False, 'import base64\n'), ((251, 11, 251, 40), 'base64.b32decode', 'base64.b32decode', ({(251, 28, 251, 39): "b'MLO23456'"}, {}), "(b'MLO23456')", False, 'import base64\n'), ((252, 11, 252, 39), 'base64.b32decode', 'base64.b32decode', ({(252, 28, 252, 38): '"""MLO23456"""'}, {}), "('MLO23456')", False, 'import base64\n'), ((277, 11, 277, 52), 'base64.b16encode', 'base64.b16encode', ({(277, 28, 277, 51): "b'\\x01\\x02\\xab\\xcd\\xef'"}, {}), "(b'\\x01\\x02\\xab\\xcd\\xef')", False, 'import base64\n'), ((278, 11, 278, 36), 'base64.b16encode', 'base64.b16encode', ({(278, 28, 278, 35): "b'\\x00'"}, {}), "(b'\\x00')", False, 'import base64\n'), ((285, 11, 285, 42), 'base64.b16decode', 'base64.b16decode', ({(285, 28, 285, 41): "b'0102ABCDEF'"}, {}), "(b'0102ABCDEF')", False, 'import base64\n'), ((286, 11, 286, 41), 'base64.b16decode', 'base64.b16decode', ({(286, 28, 286, 40): '"""0102ABCDEF"""'}, {}), "('0102ABCDEF')", False, 'import base64\n'), ((287, 11, 287, 34), 'base64.b16decode', 'base64.b16decode', ({(287, 28, 287, 33): "b'00'"}, {}), "(b'00')", False, 'import base64\n'), ((288, 11, 288, 33), 'base64.b16decode', 'base64.b16decode', ({(288, 28, 288, 32): '"""00"""'}, {}), "('00')", False, 'import base64\n'), ((293, 11, 293, 48), 'base64.b16decode', 'base64.b16decode', ({(293, 28, 293, 41): "b'0102abcdef'", (293, 43, 293, 47): '(True)'}, {}), "(b'0102abcdef', True)", False, 'import base64\n'), ((294, 11, 294, 47), 'base64.b16decode', 'base64.b16decode', ({(294, 28, 294, 40): '"""0102abcdef"""', (294, 42, 294, 46): '(True)'}, {}), "('0102abcdef', True)", False, 'import base64\n'), ((315, 12, 315, 37), 'os.unlink', 'os.unlink', ({(315, 22, 315, 36): 'support.TESTFN'}, {}), '(support.TESTFN)', False, 'import os\n'), ((141, 15, 141, 37), 'base64.b64decode', 'base64.b64decode', ({(141, 32, 141, 36): 'data'}, {}), '(data)', False, 'import base64\n'), ((153, 15, 153, 56), 'base64.b64decode', 'base64.b64decode', (), '', False, 'import base64\n'), ((154, 15, 154, 60), 'base64.b64decode', 'base64.b64decode', (), '', False, 'import base64\n'), ((155, 15, 155, 60), 'base64.b64decode', 'base64.b64decode', (), '', False, 'import base64\n'), ((156, 15, 156, 64), 'base64.b64decode', 'base64.b64decode', (), '', False, 'import base64\n'), ((160, 15, 160, 46), 'base64.standard_b64decode', 'base64.standard_b64decode', ({(160, 41, 160, 45): 'data'}, {}), '(data)', False, 'import base64\n'), ((170, 15, 170, 45), 'base64.urlsafe_b64decode', 'base64.urlsafe_b64decode', ({(170, 40, 170, 44): 'data'}, {}), '(data)', False, 'import base64\n'), ((191, 29, 191, 51), 'base64.b64decode', 'base64.b64decode', ({(191, 46, 191, 50): 'bstr'}, {}), '(bstr)', False, 'import base64\n'), ((194, 16, 194, 53), 'base64.b64decode', 'base64.b64decode', (), '', False, 'import base64\n'), ((222, 15, 222, 37), 'base64.b32decode', 'base64.b32decode', ({(222, 32, 222, 36): 'data'}, {}), '(data)', False, 'import base64\n'), ((244, 15, 244, 43), 'base64.b32decode', 'base64.b32decode', ({(244, 32, 244, 36): 'data', (244, 38, 244, 42): '(True)'}, {}), '(data, True)', False, 'import base64\n'), ((261, 15, 261, 50), 'base64.b32decode', 'base64.b32decode', (), '', False, 'import base64\n'), ((262, 15, 262, 54), 'base64.b32decode', 'base64.b32decode', (), '', False, 'import base64\n'), ((263, 15, 263, 54), 'base64.b32decode', 'base64.b32decode', (), '', False, 'import base64\n'), ((264, 15, 264, 58), 'base64.b32decode', 'base64.b32decode', (), '', False, 'import base64\n'), ((271, 16, 271, 38), 'base64.b32decode', 'base64.b32decode', ({(271, 33, 271, 37): 'data'}, {}), '(data)', False, 'import base64\n')]