def test_get_all(self):

eq = self.assertEqual

msg = self._msgobj('msg_20.txt')

eq(msg.get_all('cc'), ['ccc@zzz.org', 'ddd@zzz.org', 'eee@zzz.org'])

eq(msg.get_all('xx', 'n/a'), 'n/a')

def test_getset_charset(self):

eq = self.assertEqual

msg = Message()

eq(msg.get_charset(), None)

charset = Charset('iso-8859-1')

msg.set_charset(charset)

eq(msg['mime-version'], '1.0')

eq(msg.get_content_type(), 'text/plain')

eq(msg['content-type'], 'text/plain; charset="iso-8859-1"')

eq(msg.get_param('charset'), 'iso-8859-1')

eq(msg['content-transfer-encoding'], 'quoted-printable')

eq(msg.get_charset().input_charset, 'iso-8859-1')

# Remove the charset

msg.set_charset(None)

eq(msg.get_charset(), None)

eq(msg['content-type'], 'text/plain')

# Try adding a charset when there's already MIME headers present

msg = Message()

msg['MIME-Version'] = '2.0'

msg['Content-Type'] = 'text/x-weird'

msg['Content-Transfer-Encoding'] = 'quinted-puntable'

msg.set_charset(charset)

eq(msg['mime-version'], '2.0')

eq(msg['content-type'], 'text/x-weird; charset="iso-8859-1"')

eq(msg['content-transfer-encoding'], 'quinted-puntable')

def test_set_charset_from_string(self):

eq = self.assertEqual

msg = Message()

msg.set_charset('us-ascii')

eq(msg.get_charset().input_charset, 'us-ascii')

eq(msg['content-type'], 'text/plain; charset="us-ascii"')

def test_set_payload_with_charset(self):

msg = Message()

charset = Charset('iso-8859-1')

msg.set_payload('This is a string payload', charset)

self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')

def test_set_payload_with_8bit_data_and_charset(self):

data = b'\xd0\x90\xd0\x91\xd0\x92'

charset = Charset('utf-8')

msg = Message()

msg.set_payload(data, charset)

self.assertEqual(msg['content-transfer-encoding'], 'base64')

self.assertEqual(msg.get_payload(decode=True), data)

self.assertEqual(msg.get_payload(), '0JDQkdCS\n')

def test_set_payload_with_non_ascii_and_charset_body_encoding_none(self):

data = b'\xd0\x90\xd0\x91\xd0\x92'

charset = Charset('utf-8')

charset.body_encoding = None # Disable base64 encoding

msg = Message()

msg.set_payload(data.decode('utf-8'), charset)

self.assertEqual(msg['content-transfer-encoding'], '8bit')

self.assertEqual(msg.get_payload(decode=True), data)

def test_set_payload_with_8bit_data_and_charset_body_encoding_none(self):

data = b'\xd0\x90\xd0\x91\xd0\x92'

charset = Charset('utf-8')

charset.body_encoding = None # Disable base64 encoding

msg = Message()

msg.set_payload(data, charset)

self.assertEqual(msg['content-transfer-encoding'], '8bit')

self.assertEqual(msg.get_payload(decode=True), data)

def test_set_payload_to_list(self):

msg = Message()

msg.set_payload([])

self.assertEqual(msg.get_payload(), [])

def test_attach_when_payload_is_string(self):

msg = Message()

msg['Content-Type'] = 'multipart/mixed'

msg.set_payload('string payload')

sub_msg = MIMEMessage(Message())

self.assertRaisesRegex(TypeError, "[Aa]ttach.*non-multipart",

msg.attach, sub_msg)

def test_get_charsets(self):

eq = self.assertEqual

msg = self._msgobj('msg_08.txt')

charsets = msg.get_charsets()

eq(charsets, [None, 'us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])

msg = self._msgobj('msg_09.txt')

charsets = msg.get_charsets('dingbat')

eq(charsets, ['dingbat', 'us-ascii', 'iso-8859-1', 'dingbat',

'koi8-r'])

msg = self._msgobj('msg_12.txt')

charsets = msg.get_charsets()

eq(charsets, [None, 'us-ascii', 'iso-8859-1', None, 'iso-8859-2',

'iso-8859-3', 'us-ascii', 'koi8-r'])

def test_get_filename(self):

eq = self.assertEqual

msg = self._msgobj('msg_04.txt')

filenames = [p.get_filename() for p in msg.get_payload()]

eq(filenames, ['msg.txt', 'msg.txt'])

msg = self._msgobj('msg_07.txt')

subpart = msg.get_payload(1)

eq(subpart.get_filename(), 'dingusfish.gif')

def test_get_filename_with_name_parameter(self):

eq = self.assertEqual

msg = self._msgobj('msg_44.txt')

filenames = [p.get_filename() for p in msg.get_payload()]

eq(filenames, ['msg.txt', 'msg.txt'])

def test_get_boundary(self):

eq = self.assertEqual

msg = self._msgobj('msg_07.txt')

# No quotes!

eq(msg.get_boundary(), 'BOUNDARY')

def test_set_boundary(self):

eq = self.assertEqual

# This one has no existing boundary parameter, but the Content-Type:

# header appears fifth.

msg = self._msgobj('msg_01.txt')

msg.set_boundary('BOUNDARY')

header, value = msg.items()[4]

eq(header.lower(), 'content-type')

eq(value, 'text/plain; charset="us-ascii"; boundary="BOUNDARY"')

# This one has a Content-Type: header, with a boundary, stuck in the

# middle of its headers. Make sure the order is preserved; it should

# be fifth.

msg = self._msgobj('msg_04.txt')

msg.set_boundary('BOUNDARY')

header, value = msg.items()[4]

eq(header.lower(), 'content-type')

eq(value, 'multipart/mixed; boundary="BOUNDARY"')

# And this one has no Content-Type: header at all.

msg = self._msgobj('msg_03.txt')

self.assertRaises(errors.HeaderParseError,

msg.set_boundary, 'BOUNDARY')

def test_make_boundary(self):

msg = MIMEMultipart('form-data')

# Note that when the boundary gets created is an implementation

# detail and might change.

self.assertEqual(msg.items()[0][1], 'multipart/form-data')

# Trigger creation of boundary

msg.as_string()

self.assertEqual(msg.items()[0][1][:33],

'multipart/form-data; boundary="==')

# XXX: there ought to be tests of the uniqueness of the boundary, too.

def test_message_rfc822_only(self):

# Issue 7970: message/rfc822 not in multipart parsed by

# HeaderParser caused an exception when flattened.

with openfile('msg_46.txt', encoding="utf-8") as fp:

msgdata = fp.read()

parser = HeaderParser()

msg = parser.parsestr(msgdata)

out = StringIO()

gen = Generator(out, True, 0)

gen.flatten(msg, False)

self.assertEqual(out.getvalue(), msgdata)

def test_byte_message_rfc822_only(self):

# Make sure new bytes header parser also passes this.

with openfile('msg_46.txt', encoding="utf-8") as fp:

msgdata = fp.read().encode('ascii')

parser = email.parser.BytesHeaderParser()

msg = parser.parsebytes(msgdata)

out = BytesIO()

gen = email.generator.BytesGenerator(out)

gen.flatten(msg)

self.assertEqual(out.getvalue(), msgdata)

def test_get_decoded_payload(self):

eq = self.assertEqual

msg = self._msgobj('msg_10.txt')

# The outer message is a multipart

eq(msg.get_payload(decode=True), None)

# Subpart 1 is 7bit encoded

eq(msg.get_payload(0).get_payload(decode=True),

b'This is a 7bit encoded message.\n')

# Subpart 2 is quopri

eq(msg.get_payload(1).get_payload(decode=True),

b'\xa1This is a Quoted Printable encoded message!\n')

# Subpart 3 is base64

eq(msg.get_payload(2).get_payload(decode=True),

b'This is a Base64 encoded message.')

# Subpart 4 is base64 with a trailing newline, which

# used to be stripped (issue 7143).

eq(msg.get_payload(3).get_payload(decode=True),

b'This is a Base64 encoded message.\n')

# Subpart 5 has no Content-Transfer-Encoding: header.

eq(msg.get_payload(4).get_payload(decode=True),

b'This has no Content-Transfer-Encoding: header.\n')

def test_get_decoded_uu_payload(self):

eq = self.assertEqual

msg = Message()

msg.set_payload('begin 666 -\n+:&5L;&\\@=V]R;&0 \n \nend\n')

for cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):

msg['content-transfer-encoding'] = cte

eq(msg.get_payload(decode=True), b'hello world')

# Now try some bogus data

msg.set_payload('foo')

eq(msg.get_payload(decode=True), b'foo')

def test_get_payload_n_raises_on_non_multipart(self):

msg = Message()

self.assertRaises(TypeError, msg.get_payload, 1)

def test_decoded_generator(self):

eq = self.assertEqual

msg = self._msgobj('msg_07.txt')

with openfile('msg_17.txt', encoding="utf-8") as fp:

text = fp.read()

s = StringIO()

g = DecodedGenerator(s)

g.flatten(msg)

eq(s.getvalue(), text)

def test__contains__(self):

msg = Message()

msg['From'] = 'Me'

msg['to'] = 'You'

# Check for case insensitivity

self.assertIn('from', msg)

self.assertIn('From', msg)

self.assertIn('FROM', msg)

self.assertIn('to', msg)

self.assertIn('To', msg)

self.assertIn('TO', msg)

def test_as_string(self):

msg = self._msgobj('msg_01.txt')

with openfile('msg_01.txt', encoding="utf-8") as fp:

text = fp.read()

self.assertEqual(text, str(msg))

fullrepr = msg.as_string(unixfrom=True)

lines = fullrepr.split('\n')

self.assertTrue(lines[0].startswith('From '))

self.assertEqual(text, NL.join(lines[1:]))

def test_as_string_policy(self):

msg = self._msgobj('msg_01.txt')

newpolicy = msg.policy.clone(linesep='\r\n')

fullrepr = msg.as_string(policy=newpolicy)

s = StringIO()

g = Generator(s, policy=newpolicy)

g.flatten(msg)

self.assertEqual(fullrepr, s.getvalue())

def test_nonascii_as_string_without_cte(self):

m = textwrap.dedent("""\

""")

source = m.encode('iso-8859-1')

expected = textwrap.dedent("""\

""")

msg = email.message_from_bytes(source)

self.assertEqual(msg.as_string(), expected)

def test_nonascii_as_string_without_content_type_and_cte(self):

m = textwrap.dedent("""\

""")

source = m.encode('iso-8859-1')

expected = source.decode('ascii', 'replace')

msg = email.message_from_bytes(source)

self.assertEqual(msg.as_string(), expected)

def test_as_bytes(self):

msg = self._msgobj('msg_01.txt')

with openfile('msg_01.txt', encoding="utf-8") as fp:

data = fp.read().encode('ascii')

self.assertEqual(data, bytes(msg))

fullrepr = msg.as_bytes(unixfrom=True)

lines = fullrepr.split(b'\n')

self.assertTrue(lines[0].startswith(b'From '))

self.assertEqual(data, b'\n'.join(lines[1:]))

def test_as_bytes_policy(self):

msg = self._msgobj('msg_01.txt')

newpolicy = msg.policy.clone(linesep='\r\n')

fullrepr = msg.as_bytes(policy=newpolicy)

s = BytesIO()

g = BytesGenerator(s,policy=newpolicy)

g.flatten(msg)

self.assertEqual(fullrepr, s.getvalue())

# test_headerregistry.TestContentTypeHeader.bad_params

def test_bad_param(self):

msg = email.message_from_string("Content-Type: blarg; baz; boo\n")

self.assertEqual(msg.get_param('baz'), '')

def test_missing_filename(self):

msg = email.message_from_string("From: foo\n")

self.assertEqual(msg.get_filename(), None)

def test_bogus_filename(self):

msg = email.message_from_string(

"Content-Disposition: blarg; filename\n")

self.assertEqual(msg.get_filename(), '')

def test_missing_boundary(self):

msg = email.message_from_string("From: foo\n")

self.assertEqual(msg.get_boundary(), None)

def test_get_params(self):

eq = self.assertEqual

msg = email.message_from_string(

'X-Header: foo=one; bar=two; baz=three\n')

eq(msg.get_params(header='x-header'),

[('foo', 'one'), ('bar', 'two'), ('baz', 'three')])

msg = email.message_from_string(

'X-Header: foo; bar=one; baz=two\n')

eq(msg.get_params(header='x-header'),

[('foo', ''), ('bar', 'one'), ('baz', 'two')])

eq(msg.get_params(), None)

msg = email.message_from_string(

'X-Header: foo; bar="one"; baz=two\n')

eq(msg.get_params(header='x-header'),

[('foo', ''), ('bar', 'one'), ('baz', 'two')])

# test_headerregistry.TestContentTypeHeader.spaces_around_param_equals

def test_get_param_liberal(self):

msg = Message()

msg['Content-Type'] = 'Content-Type: Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"'

self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')

def test_get_param(self):

eq = self.assertEqual

msg = email.message_from_string(

"X-Header: foo=one; bar=two; baz=three\n")

eq(msg.get_param('bar', header='x-header'), 'two')

eq(msg.get_param('quuz', header='x-header'), None)

eq(msg.get_param('quuz'), None)

msg = email.message_from_string(

'X-Header: foo; bar="one"; baz=two\n')

eq(msg.get_param('foo', header='x-header'), '')

eq(msg.get_param('bar', header='x-header'), 'one')

eq(msg.get_param('baz', header='x-header'), 'two')

# XXX: We are not RFC-2045 compliant! We cannot parse:

# msg["Content-Type"] = 'text/plain; weird="hey; dolly? [you] @ <\\"home\\">?"'

# msg.get_param("weird")

# yet.

# test_headerregistry.TestContentTypeHeader.spaces_around_semis

def test_get_param_funky_continuation_lines(self):

msg = self._msgobj('msg_22.txt')

self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')

# test_headerregistry.TestContentTypeHeader.semis_inside_quotes

def test_get_param_with_semis_in_quotes(self):

msg = email.message_from_string(

'Content-Type: image/pjpeg; name="Jim&amp;&amp;Jill"\n')

self.assertEqual(msg.get_param('name'), 'Jim&amp;&amp;Jill')

self.assertEqual(msg.get_param('name', unquote=False),

'"Jim&amp;&amp;Jill"')

# test_headerregistry.TestContentTypeHeader.quotes_inside_rfc2231_value

def test_get_param_with_quotes(self):

msg = email.message_from_string(

'Content-Type: foo; bar*0="baz\\"foobar"; bar*1="\\"baz"')

self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')

msg = email.message_from_string(

"Content-Type: foo; bar*0=\"baz\\\"foobar\"; bar*1=\"\\\"baz\"")

self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')

def test_field_containment(self):

msg = email.message_from_string('Header: exists')

self.assertIn('header', msg)

self.assertIn('Header', msg)

self.assertIn('HEADER', msg)

self.assertNotIn('headerx', msg)

def test_set_param(self):

eq = self.assertEqual

msg = Message()

msg.set_param('charset', 'iso-2022-jp')

eq(msg.get_param('charset'), 'iso-2022-jp')

msg.set_param('importance', 'high value')

eq(msg.get_param('importance'), 'high value')

eq(msg.get_param('importance', unquote=False), '"high value"')

eq(msg.get_params(), [('text/plain', ''),

('charset', 'iso-2022-jp'),

('importance', 'high value')])

eq(msg.get_params(unquote=False), [('text/plain', ''),

('charset', '"iso-2022-jp"'),

('importance', '"high value"')])

msg.set_param('charset', 'iso-9999-xx', header='X-Jimmy')

eq(msg.get_param('charset', header='X-Jimmy'), 'iso-9999-xx')

def test_del_param(self):

eq = self.assertEqual

msg = self._msgobj('msg_05.txt')

eq(msg.get_params(),

[('multipart/report', ''), ('report-type', 'delivery-status'),

('boundary', 'D1690A7AC1.996856090/mail.example.com')])

old_val = msg.get_param("report-type")

msg.del_param("report-type")

eq(msg.get_params(),

[('multipart/report', ''),

('boundary', 'D1690A7AC1.996856090/mail.example.com')])

msg.set_param("report-type", old_val)

eq(msg.get_params(),

[('multipart/report', ''),

('boundary', 'D1690A7AC1.996856090/mail.example.com'),

('report-type', old_val)])

def test_del_param_on_other_header(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')

msg.del_param('filename', 'content-disposition')

self.assertEqual(msg['content-disposition'], 'attachment')

def test_del_param_on_nonexistent_header(self):

msg = Message()

# Deleting param on empty msg should not raise exception.

msg.del_param('filename', 'content-disposition')

def test_del_nonexistent_param(self):

msg = Message()

msg.add_header('Content-Type', 'text/plain', charset='utf-8')

existing_header = msg['Content-Type']

msg.del_param('foobar', header='Content-Type')

self.assertEqual(msg['Content-Type'], existing_header)

def test_set_type(self):

eq = self.assertEqual

msg = Message()

self.assertRaises(ValueError, msg.set_type, 'text')

msg.set_type('text/plain')

eq(msg['content-type'], 'text/plain')

msg.set_param('charset', 'us-ascii')

eq(msg['content-type'], 'text/plain; charset="us-ascii"')

msg.set_type('text/html')

eq(msg['content-type'], 'text/html; charset="us-ascii"')

def test_set_type_on_other_header(self):

msg = Message()

msg['X-Content-Type'] = 'text/plain'

msg.set_type('application/octet-stream', 'X-Content-Type')

self.assertEqual(msg['x-content-type'], 'application/octet-stream')

def test_get_content_type_missing(self):

msg = Message()

self.assertEqual(msg.get_content_type(), 'text/plain')

def test_get_content_type_missing_with_default_type(self):

msg = Message()

msg.set_default_type('message/rfc822')

self.assertEqual(msg.get_content_type(), 'message/rfc822')

def test_get_content_type_from_message_implicit(self):

msg = self._msgobj('msg_30.txt')

self.assertEqual(msg.get_payload(0).get_content_type(),

'message/rfc822')

def test_get_content_type_from_message_explicit(self):

msg = self._msgobj('msg_28.txt')

self.assertEqual(msg.get_payload(0).get_content_type(),

'message/rfc822')

def test_get_content_type_from_message_text_plain_implicit(self):

msg = self._msgobj('msg_03.txt')

self.assertEqual(msg.get_content_type(), 'text/plain')

def test_get_content_type_from_message_text_plain_explicit(self):

msg = self._msgobj('msg_01.txt')

self.assertEqual(msg.get_content_type(), 'text/plain')

def test_get_content_maintype_missing(self):

msg = Message()

self.assertEqual(msg.get_content_maintype(), 'text')

def test_get_content_maintype_missing_with_default_type(self):

msg = Message()

msg.set_default_type('message/rfc822')

self.assertEqual(msg.get_content_maintype(), 'message')

def test_get_content_maintype_from_message_implicit(self):

msg = self._msgobj('msg_30.txt')

self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')

def test_get_content_maintype_from_message_explicit(self):

msg = self._msgobj('msg_28.txt')

self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')

def test_get_content_maintype_from_message_text_plain_implicit(self):

msg = self._msgobj('msg_03.txt')

self.assertEqual(msg.get_content_maintype(), 'text')

def test_get_content_maintype_from_message_text_plain_explicit(self):

msg = self._msgobj('msg_01.txt')

self.assertEqual(msg.get_content_maintype(), 'text')

def test_get_content_subtype_missing(self):

msg = Message()

self.assertEqual(msg.get_content_subtype(), 'plain')

def test_get_content_subtype_missing_with_default_type(self):

msg = Message()

msg.set_default_type('message/rfc822')

self.assertEqual(msg.get_content_subtype(), 'rfc822')

def test_get_content_subtype_from_message_implicit(self):

msg = self._msgobj('msg_30.txt')

self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')

def test_get_content_subtype_from_message_explicit(self):

msg = self._msgobj('msg_28.txt')

self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')

def test_get_content_subtype_from_message_text_plain_implicit(self):

msg = self._msgobj('msg_03.txt')

self.assertEqual(msg.get_content_subtype(), 'plain')

def test_get_content_subtype_from_message_text_plain_explicit(self):

msg = self._msgobj('msg_01.txt')

self.assertEqual(msg.get_content_subtype(), 'plain')

def test_get_content_maintype_error(self):

msg = Message()

msg['Content-Type'] = 'no-slash-in-this-string'

self.assertEqual(msg.get_content_maintype(), 'text')

def test_get_content_subtype_error(self):

msg = Message()

msg['Content-Type'] = 'no-slash-in-this-string'

self.assertEqual(msg.get_content_subtype(), 'plain')

def test_replace_header(self):

eq = self.assertEqual

msg = Message()

msg.add_header('First', 'One')

msg.add_header('Second', 'Two')

msg.add_header('Third', 'Three')

eq(msg.keys(), ['First', 'Second', 'Third'])

eq(msg.values(), ['One', 'Two', 'Three'])

msg.replace_header('Second', 'Twenty')

eq(msg.keys(), ['First', 'Second', 'Third'])

eq(msg.values(), ['One', 'Twenty', 'Three'])

msg.add_header('First', 'Eleven')

msg.replace_header('First', 'One Hundred')

eq(msg.keys(), ['First', 'Second', 'Third', 'First'])

eq(msg.values(), ['One Hundred', 'Twenty', 'Three', 'Eleven'])

self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')

def test_get_content_disposition(self):

msg = Message()

self.assertIsNone(msg.get_content_disposition())

msg.add_header('Content-Disposition', 'attachment',

filename='random.avi')

self.assertEqual(msg.get_content_disposition(), 'attachment')

msg.replace_header('Content-Disposition', 'inline')

self.assertEqual(msg.get_content_disposition(), 'inline')

msg.replace_header('Content-Disposition', 'InlinE')

self.assertEqual(msg.get_content_disposition(), 'inline')

# test_defect_handling:test_invalid_chars_in_base64_payload

def test_broken_base64_payload(self):

x = 'AwDp0P7//y6LwKEAcPa/6Q=9'

msg = Message()

msg['content-type'] = 'audio/x-midi'

msg['content-transfer-encoding'] = 'base64'

msg.set_payload(x)

self.assertEqual(msg.get_payload(decode=True),

(b'\x03\x00\xe9\xd0\xfe\xff\xff.\x8b\xc0'

b'\xa1\x00p\xf6\xbf\xe9\x0f'))

self.assertIsInstance(msg.defects[0],

errors.InvalidBase64CharactersDefect)

def test_broken_unicode_payload(self):

# This test improves coverage but is not a compliance test.

# The behavior in this situation is currently undefined by the API.

x = 'this is a br\xf6ken thing to do'

msg = Message()

msg['content-type'] = 'text/plain'

msg['content-transfer-encoding'] = '8bit'

msg.set_payload(x)

self.assertEqual(msg.get_payload(decode=True),

bytes(x, 'raw-unicode-escape'))

def test_questionable_bytes_payload(self):

# This test improves coverage but is not a compliance test,

# since it involves poking inside the black box.

x = 'this is a quéstionable thing to do'.encode('utf-8')

msg = Message()

msg['content-type'] = 'text/plain; charset="utf-8"'

msg['content-transfer-encoding'] = '8bit'

msg._payload = x

self.assertEqual(msg.get_payload(decode=True), x)

# Issue 1078919

def test_ascii_add_header(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment',

filename='bud.gif')

self.assertEqual('attachment; filename="bud.gif"',

msg['Content-Disposition'])

def test_noascii_add_header(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment',

filename="Fußballer.ppt")

self.assertEqual(

'attachment; filename*=utf-8\'\'Fu%C3%9Fballer.ppt',

msg['Content-Disposition'])

def test_nonascii_add_header_via_triple(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment',

filename=('iso-8859-1', '', 'Fußballer.ppt'))

self.assertEqual(

'attachment; filename*=iso-8859-1\'\'Fu%DFballer.ppt',

msg['Content-Disposition'])

def test_ascii_add_header_with_tspecial(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment',

filename="windows [filename].ppt")

self.assertEqual(

'attachment; filename="windows [filename].ppt"',

msg['Content-Disposition'])

def test_nonascii_add_header_with_tspecial(self):

msg = Message()

msg.add_header('Content-Disposition', 'attachment',

filename="Fußballer [filename].ppt")

self.assertEqual(

"attachment; filename*=utf-8''Fu%C3%9Fballer%20%5Bfilename%5D.ppt",

msg['Content-Disposition'])

def test_binary_quopri_payload(self):

for charset in ('latin-1', 'ascii'):

msg = Message()

msg['content-type'] = 'text/plain; charset=%s' % charset

msg['content-transfer-encoding'] = 'quoted-printable'

msg.set_payload(b'foo=e6=96=87bar')

self.assertEqual(

msg.get_payload(decode=True),

b'foo\xe6\x96\x87bar',

'get_payload returns wrong result with charset %s.' % charset)

def test_binary_base64_payload(self):

for charset in ('latin-1', 'ascii'):

msg = Message()

msg['content-type'] = 'text/plain; charset=%s' % charset

msg['content-transfer-encoding'] = 'base64'

msg.set_payload(b'Zm9v5paHYmFy')

self.assertEqual(

msg.get_payload(decode=True),

b'foo\xe6\x96\x87bar',

'get_payload returns wrong result with charset %s.' % charset)

def test_binary_uuencode_payload(self):

for charset in ('latin-1', 'ascii'):

for encoding in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):

msg = Message()

msg['content-type'] = 'text/plain; charset=%s' % charset

msg['content-transfer-encoding'] = encoding

msg.set_payload(b"begin 666 -\n)9F]OYI:'8F%R\n \nend\n")

self.assertEqual(

msg.get_payload(decode=True),

b'foo\xe6\x96\x87bar',

str(('get_payload returns wrong result ',

'with charset {0} and encoding {1}.')).\

format(charset, encoding))

def test_add_header_with_name_only_param(self):

msg = Message()

msg.add_header('Content-Disposition', 'inline', foo_bar=None)

self.assertEqual("inline; foo-bar", msg['Content-Disposition'])

def test_add_header_with_no_value(self):

msg = Message()

msg.add_header('X-Status', None)

self.assertEqual('', msg['X-Status'])

# Issue 5871: reject an attempt to embed a header inside a header value

# (header injection attack).

def test_embedded_header_via_Header_rejected(self):

msg = Message()

msg['Dummy'] = Header('dummy\nX-Injected-Header: test')

self.assertRaises(errors.HeaderParseError, msg.as_string)

def test_embedded_header_via_string_rejected(self):

msg = Message()

msg['Dummy'] = 'dummy\nX-Injected-Header: test'

self.assertRaises(errors.HeaderParseError, msg.as_string)

def test_unicode_header_defaults_to_utf8_encoding(self):

# Issue 14291

m = MIMEText('abc\n')

m['Subject'] = 'É test'

self.assertEqual(str(m),textwrap.dedent("""\

"""))

def test_unicode_body_defaults_to_utf8_encoding(self):

# Issue 14291

m = MIMEText('É testabc\n')

self.assertEqual(str(m),textwrap.dedent("""\

def test_EncodersEncode_base64(self):

with openfile('python.gif', 'rb') as fp:

bindata = fp.read()

mimed = email.mime.image.MIMEImage(bindata)

base64ed = mimed.get_payload()

# the transfer-encoded body lines should all be <=76 characters

lines = base64ed.split('\n')

self.assertLessEqual(max([ len(x) for x in lines ]), 76)

def test_encode_empty_payload(self):

eq = self.assertEqual

msg = Message()

msg.set_charset('us-ascii')

eq(msg['content-transfer-encoding'], '7bit')

def test_default_cte(self):

eq = self.assertEqual

# 7bit data and the default us-ascii _charset

msg = MIMEText('hello world')

eq(msg['content-transfer-encoding'], '7bit')

# Similar, but with 8bit data

msg = MIMEText('hello \xf8 world')

eq(msg['content-transfer-encoding'], 'base64')

# And now with a different charset

msg = MIMEText('hello \xf8 world', _charset='iso-8859-1')

eq(msg['content-transfer-encoding'], 'quoted-printable')

def test_encode7or8bit(self):

# Make sure a charset whose input character set is 8bit but

# whose output character set is 7bit gets a transfer-encoding

# of 7bit.

eq = self.assertEqual

msg = MIMEText('文\n', _charset='euc-jp')

eq(msg['content-transfer-encoding'], '7bit')

eq(msg.as_string(), textwrap.dedent("""\

"""))

def test_qp_encode_latin1(self):

msg = MIMEText('\xe1\xf6\n', 'text', 'ISO-8859-1')

self.assertEqual(str(msg), textwrap.dedent("""\

"""))

def test_qp_encode_non_latin1(self):

# Issue 16948

msg = MIMEText('\u017c\n', 'text', 'ISO-8859-2')

self.assertEqual(str(msg), textwrap.dedent("""\

maxDiff = None

def test_split_long_continuation(self):

eq = self.ndiffAssertEqual

msg = email.message_from_string("""\

""")

sfp = StringIO()

g = Generator(sfp)

g.flatten(msg)

eq(sfp.getvalue(), """\

""")

def test_another_long_almost_unsplittable_header(self):

eq = self.ndiffAssertEqual

hstr = """\

h = Header(hstr, continuation_ws='\t')

eq(h.encode(), """\

\tmore text""")

h = Header(hstr.replace('\t', ' '))

eq(h.encode(), """\

more text""")

def test_long_nonstring(self):

eq = self.ndiffAssertEqual

g = Charset("iso-8859-1")

cz = Charset("iso-8859-2")

utf8 = Charset("utf-8")

g_head = (b'Die Mieter treten hier ein werden mit einem Foerderband '

b'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '

b'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '

b'bef\xf6rdert. ')

cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '

b'd\xf9vtipu.. ')

utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'

'\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'

'\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'

'\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'

'\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '

'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '

'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'

'\u3044\u307e\u3059\u3002')

h = Header(g_head, g, header_name='Subject')

h.append(cz_head, cz)

h.append(utf8_head, utf8)

msg = Message()

msg['Subject'] = h

sfp = StringIO()

g = Generator(sfp)

g.flatten(msg)

eq(sfp.getvalue(), """\

""")

eq(h.encode(maxlinelen=76), """\

=?utf-8?b?44Go6KiA44Gj44Gm44GE44G+44GZ44CC?=""")

def test_long_header_encode(self):

eq = self.ndiffAssertEqual

h = Header('wasnipoop; giraffes="very-long-necked-animals"; '

'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',

header_name='X-Foobar-Spoink-Defrobnit')

eq(h.encode(), '''\

spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')

def test_long_header_encode_with_tab_continuation_is_just_a_hint(self):

eq = self.ndiffAssertEqual

h = Header('wasnipoop; giraffes="very-long-necked-animals"; '

'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',

header_name='X-Foobar-Spoink-Defrobnit',

continuation_ws='\t')

eq(h.encode(), '''\

spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')

def test_long_header_encode_with_tab_continuation(self):

eq = self.ndiffAssertEqual

h = Header('wasnipoop; giraffes="very-long-necked-animals";\t'

'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',

header_name='X-Foobar-Spoink-Defrobnit',

continuation_ws='\t')

eq(h.encode(), '''\

\tspooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')

def test_header_encode_with_different_output_charset(self):

h = Header('文', 'euc-jp')

self.assertEqual(h.encode(), "=?iso-2022-jp?b?GyRCSjgbKEI=?=")

def test_long_header_encode_with_different_output_charset(self):

h = Header(b'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5\xa4\xec\xa4'

b'\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2\xf1\xbc\xd4'

b'\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3\xa4\xc6\xa4'

b'\xa4\xa4\xde\xa4\xb9'.decode('euc-jp'), 'euc-jp')

res = """\