AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python...

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / email / test / test_email_renamed.py

# Copyright (C) 2001-2007 Python Software Foundation\r
# Contact: email-sig@python.org\r
# email package unit tests\r
\r
import os\r
import sys\r
import time\r
import base64\r
import difflib\r
import unittest\r
import warnings\r
from cStringIO import StringIO\r
\r
import email\r
\r
from email.charset import Charset\r
from email.header import Header, decode_header, make_header\r
from email.parser import Parser, HeaderParser\r
from email.generator import Generator, DecodedGenerator\r
from email.message import Message\r
from email.mime.application import MIMEApplication\r
from email.mime.audio import MIMEAudio\r
from email.mime.text import MIMEText\r
from email.mime.image import MIMEImage\r
from email.mime.base import MIMEBase\r
from email.mime.message import MIMEMessage\r
from email.mime.multipart import MIMEMultipart\r
from email import utils\r
from email import errors\r
from email import encoders\r
from email import iterators\r
from email import base64mime\r
from email import quoprimime\r
\r
from test.test_support import findfile, run_unittest\r
from email.test import __file__ as landmark\r
\r
\r
NL = '\n'\r
EMPTYSTRING = ''\r
SPACE = ' '\r
\r
\r
\r
def openfile(filename, mode='r'):\r
    path = os.path.join(os.path.dirname(landmark), 'data', filename)\r
    return open(path, mode)\r
\r
\r
\r
# Base test class\r
class TestEmailBase(unittest.TestCase):\r
    def ndiffAssertEqual(self, first, second):\r
        """Like assertEqual except use ndiff for readable output."""\r
        if first != second:\r
            sfirst = str(first)\r
            ssecond = str(second)\r
            diff = difflib.ndiff(sfirst.splitlines(), ssecond.splitlines())\r
            fp = StringIO()\r
            print >> fp, NL, NL.join(diff)\r
            raise self.failureException, fp.getvalue()\r
\r
    def _msgobj(self, filename):\r
        fp = openfile(findfile(filename))\r
        try:\r
            msg = email.message_from_file(fp)\r
        finally:\r
            fp.close()\r
        return msg\r
\r
\r
\r
# Test various aspects of the Message class's API\r
class TestMessageAPI(TestEmailBase):\r
    def test_get_all(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_20.txt')\r
        eq(msg.get_all('cc'), ['ccc@zzz.org', 'ddd@zzz.org', 'eee@zzz.org'])\r
        eq(msg.get_all('xx', 'n/a'), 'n/a')\r
\r
    def test_getset_charset(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        eq(msg.get_charset(), None)\r
        charset = Charset('iso-8859-1')\r
        msg.set_charset(charset)\r
        eq(msg['mime-version'], '1.0')\r
        eq(msg.get_content_type(), 'text/plain')\r
        eq(msg['content-type'], 'text/plain; charset="iso-8859-1"')\r
        eq(msg.get_param('charset'), 'iso-8859-1')\r
        eq(msg['content-transfer-encoding'], 'quoted-printable')\r
        eq(msg.get_charset().input_charset, 'iso-8859-1')\r
        # Remove the charset\r
        msg.set_charset(None)\r
        eq(msg.get_charset(), None)\r
        eq(msg['content-type'], 'text/plain')\r
        # Try adding a charset when there's already MIME headers present\r
        msg = Message()\r
        msg['MIME-Version'] = '2.0'\r
        msg['Content-Type'] = 'text/x-weird'\r
        msg['Content-Transfer-Encoding'] = 'quinted-puntable'\r
        msg.set_charset(charset)\r
        eq(msg['mime-version'], '2.0')\r
        eq(msg['content-type'], 'text/x-weird; charset="iso-8859-1"')\r
        eq(msg['content-transfer-encoding'], 'quinted-puntable')\r
\r
    def test_set_charset_from_string(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.set_charset('us-ascii')\r
        eq(msg.get_charset().input_charset, 'us-ascii')\r
        eq(msg['content-type'], 'text/plain; charset="us-ascii"')\r
\r
    def test_set_payload_with_charset(self):\r
        msg = Message()\r
        charset = Charset('iso-8859-1')\r
        msg.set_payload('This is a string payload', charset)\r
        self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')\r
\r
    def test_get_charsets(self):\r
        eq = self.assertEqual\r
\r
        msg = self._msgobj('msg_08.txt')\r
        charsets = msg.get_charsets()\r
        eq(charsets, [None, 'us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])\r
\r
        msg = self._msgobj('msg_09.txt')\r
        charsets = msg.get_charsets('dingbat')\r
        eq(charsets, ['dingbat', 'us-ascii', 'iso-8859-1', 'dingbat',\r
                      'koi8-r'])\r
\r
        msg = self._msgobj('msg_12.txt')\r
        charsets = msg.get_charsets()\r
        eq(charsets, [None, 'us-ascii', 'iso-8859-1', None, 'iso-8859-2',\r
                      'iso-8859-3', 'us-ascii', 'koi8-r'])\r
\r
    def test_get_filename(self):\r
        eq = self.assertEqual\r
\r
        msg = self._msgobj('msg_04.txt')\r
        filenames = [p.get_filename() for p in msg.get_payload()]\r
        eq(filenames, ['msg.txt', 'msg.txt'])\r
\r
        msg = self._msgobj('msg_07.txt')\r
        subpart = msg.get_payload(1)\r
        eq(subpart.get_filename(), 'dingusfish.gif')\r
\r
    def test_get_filename_with_name_parameter(self):\r
        eq = self.assertEqual\r
\r
        msg = self._msgobj('msg_44.txt')\r
        filenames = [p.get_filename() for p in msg.get_payload()]\r
        eq(filenames, ['msg.txt', 'msg.txt'])\r
\r
    def test_get_boundary(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_07.txt')\r
        # No quotes!\r
        eq(msg.get_boundary(), 'BOUNDARY')\r
\r
    def test_set_boundary(self):\r
        eq = self.assertEqual\r
        # This one has no existing boundary parameter, but the Content-Type:\r
        # header appears fifth.\r
        msg = self._msgobj('msg_01.txt')\r
        msg.set_boundary('BOUNDARY')\r
        header, value = msg.items()[4]\r
        eq(header.lower(), 'content-type')\r
        eq(value, 'text/plain; charset="us-ascii"; boundary="BOUNDARY"')\r
        # This one has a Content-Type: header, with a boundary, stuck in the\r
        # middle of its headers.  Make sure the order is preserved; it should\r
        # be fifth.\r
        msg = self._msgobj('msg_04.txt')\r
        msg.set_boundary('BOUNDARY')\r
        header, value = msg.items()[4]\r
        eq(header.lower(), 'content-type')\r
        eq(value, 'multipart/mixed; boundary="BOUNDARY"')\r
        # And this one has no Content-Type: header at all.\r
        msg = self._msgobj('msg_03.txt')\r
        self.assertRaises(errors.HeaderParseError,\r
                          msg.set_boundary, 'BOUNDARY')\r
\r
    def test_get_decoded_payload(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_10.txt')\r
        # The outer message is a multipart\r
        eq(msg.get_payload(decode=True), None)\r
        # Subpart 1 is 7bit encoded\r
        eq(msg.get_payload(0).get_payload(decode=True),\r
           'This is a 7bit encoded message.\n')\r
        # Subpart 2 is quopri\r
        eq(msg.get_payload(1).get_payload(decode=True),\r
           '\xa1This is a Quoted Printable encoded message!\n')\r
        # Subpart 3 is base64\r
        eq(msg.get_payload(2).get_payload(decode=True),\r
           'This is a Base64 encoded message.')\r
        # Subpart 4 is base64 with a trailing newline, which\r
        # used to be stripped (issue 7143).\r
        eq(msg.get_payload(3).get_payload(decode=True),\r
           'This is a Base64 encoded message.\n')\r
        # Subpart 5 has no Content-Transfer-Encoding: header.\r
        eq(msg.get_payload(4).get_payload(decode=True),\r
           'This has no Content-Transfer-Encoding: header.\n')\r
\r
    def test_get_decoded_uu_payload(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.set_payload('begin 666 -\n+:&5L;&\\@=V]R;&0 \n \nend\n')\r
        for cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):\r
            msg['content-transfer-encoding'] = cte\r
            eq(msg.get_payload(decode=True), 'hello world')\r
        # Now try some bogus data\r
        msg.set_payload('foo')\r
        eq(msg.get_payload(decode=True), 'foo')\r
\r
    def test_decoded_generator(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_07.txt')\r
        fp = openfile('msg_17.txt')\r
        try:\r
            text = fp.read()\r
        finally:\r
            fp.close()\r
        s = StringIO()\r
        g = DecodedGenerator(s)\r
        g.flatten(msg)\r
        eq(s.getvalue(), text)\r
\r
    def test__contains__(self):\r
        msg = Message()\r
        msg['From'] = 'Me'\r
        msg['to'] = 'You'\r
        # Check for case insensitivity\r
        self.assertTrue('from' in msg)\r
        self.assertTrue('From' in msg)\r
        self.assertTrue('FROM' in msg)\r
        self.assertTrue('to' in msg)\r
        self.assertTrue('To' in msg)\r
        self.assertTrue('TO' in msg)\r
\r
    def test_as_string(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_01.txt')\r
        fp = openfile('msg_01.txt')\r
        try:\r
            # BAW 30-Mar-2009 Evil be here.  So, the generator is broken with\r
            # respect to long line breaking.  It's also not idempotent when a\r
            # header from a parsed message is continued with tabs rather than\r
            # spaces.  Before we fixed bug 1974 it was reversedly broken,\r
            # i.e. headers that were continued with spaces got continued with\r
            # tabs.  For Python 2.x there's really no good fix and in Python\r
            # 3.x all this stuff is re-written to be right(er).  Chris Withers\r
            # convinced me that using space as the default continuation\r
            # character is less bad for more applications.\r
            text = fp.read().replace('\t', ' ')\r
        finally:\r
            fp.close()\r
        self.ndiffAssertEqual(text, msg.as_string())\r
        fullrepr = str(msg)\r
        lines = fullrepr.split('\n')\r
        self.assertTrue(lines[0].startswith('From '))\r
        eq(text, NL.join(lines[1:]))\r
\r
    def test_bad_param(self):\r
        msg = email.message_from_string("Content-Type: blarg; baz; boo\n")\r
        self.assertEqual(msg.get_param('baz'), '')\r
\r
    def test_missing_filename(self):\r
        msg = email.message_from_string("From: foo\n")\r
        self.assertEqual(msg.get_filename(), None)\r
\r
    def test_bogus_filename(self):\r
        msg = email.message_from_string(\r
        "Content-Disposition: blarg; filename\n")\r
        self.assertEqual(msg.get_filename(), '')\r
\r
    def test_missing_boundary(self):\r
        msg = email.message_from_string("From: foo\n")\r
        self.assertEqual(msg.get_boundary(), None)\r
\r
    def test_get_params(self):\r
        eq = self.assertEqual\r
        msg = email.message_from_string(\r
            'X-Header: foo=one; bar=two; baz=three\n')\r
        eq(msg.get_params(header='x-header'),\r
           [('foo', 'one'), ('bar', 'two'), ('baz', 'three')])\r
        msg = email.message_from_string(\r
            'X-Header: foo; bar=one; baz=two\n')\r
        eq(msg.get_params(header='x-header'),\r
           [('foo', ''), ('bar', 'one'), ('baz', 'two')])\r
        eq(msg.get_params(), None)\r
        msg = email.message_from_string(\r
            'X-Header: foo; bar="one"; baz=two\n')\r
        eq(msg.get_params(header='x-header'),\r
           [('foo', ''), ('bar', 'one'), ('baz', 'two')])\r
\r
    def test_get_param_liberal(self):\r
        msg = Message()\r
        msg['Content-Type'] = 'Content-Type: Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"'\r
        self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')\r
\r
    def test_get_param(self):\r
        eq = self.assertEqual\r
        msg = email.message_from_string(\r
            "X-Header: foo=one; bar=two; baz=three\n")\r
        eq(msg.get_param('bar', header='x-header'), 'two')\r
        eq(msg.get_param('quuz', header='x-header'), None)\r
        eq(msg.get_param('quuz'), None)\r
        msg = email.message_from_string(\r
            'X-Header: foo; bar="one"; baz=two\n')\r
        eq(msg.get_param('foo', header='x-header'), '')\r
        eq(msg.get_param('bar', header='x-header'), 'one')\r
        eq(msg.get_param('baz', header='x-header'), 'two')\r
        # XXX: We are not RFC-2045 compliant!  We cannot parse:\r
        # msg["Content-Type"] = 'text/plain; weird="hey; dolly? [you] @ <\\"home\\">?"'\r
        # msg.get_param("weird")\r
        # yet.\r
\r
    def test_get_param_funky_continuation_lines(self):\r
        msg = self._msgobj('msg_22.txt')\r
        self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')\r
\r
    def test_get_param_with_semis_in_quotes(self):\r
        msg = email.message_from_string(\r
            'Content-Type: image/pjpeg; name="Jim&amp;&amp;Jill"\n')\r
        self.assertEqual(msg.get_param('name'), 'Jim&amp;&amp;Jill')\r
        self.assertEqual(msg.get_param('name', unquote=False),\r
                         '"Jim&amp;&amp;Jill"')\r
\r
    def test_has_key(self):\r
        msg = email.message_from_string('Header: exists')\r
        self.assertTrue(msg.has_key('header'))\r
        self.assertTrue(msg.has_key('Header'))\r
        self.assertTrue(msg.has_key('HEADER'))\r
        self.assertFalse(msg.has_key('headeri'))\r
\r
    def test_set_param(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.set_param('charset', 'iso-2022-jp')\r
        eq(msg.get_param('charset'), 'iso-2022-jp')\r
        msg.set_param('importance', 'high value')\r
        eq(msg.get_param('importance'), 'high value')\r
        eq(msg.get_param('importance', unquote=False), '"high value"')\r
        eq(msg.get_params(), [('text/plain', ''),\r
                              ('charset', 'iso-2022-jp'),\r
                              ('importance', 'high value')])\r
        eq(msg.get_params(unquote=False), [('text/plain', ''),\r
                                       ('charset', '"iso-2022-jp"'),\r
                                       ('importance', '"high value"')])\r
        msg.set_param('charset', 'iso-9999-xx', header='X-Jimmy')\r
        eq(msg.get_param('charset', header='X-Jimmy'), 'iso-9999-xx')\r
\r
    def test_del_param(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_05.txt')\r
        eq(msg.get_params(),\r
           [('multipart/report', ''), ('report-type', 'delivery-status'),\r
            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])\r
        old_val = msg.get_param("report-type")\r
        msg.del_param("report-type")\r
        eq(msg.get_params(),\r
           [('multipart/report', ''),\r
            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])\r
        msg.set_param("report-type", old_val)\r
        eq(msg.get_params(),\r
           [('multipart/report', ''),\r
            ('boundary', 'D1690A7AC1.996856090/mail.example.com'),\r
            ('report-type', old_val)])\r
\r
    def test_del_param_on_other_header(self):\r
        msg = Message()\r
        msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')\r
        msg.del_param('filename', 'content-disposition')\r
        self.assertEqual(msg['content-disposition'], 'attachment')\r
\r
    def test_set_type(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        self.assertRaises(ValueError, msg.set_type, 'text')\r
        msg.set_type('text/plain')\r
        eq(msg['content-type'], 'text/plain')\r
        msg.set_param('charset', 'us-ascii')\r
        eq(msg['content-type'], 'text/plain; charset="us-ascii"')\r
        msg.set_type('text/html')\r
        eq(msg['content-type'], 'text/html; charset="us-ascii"')\r
\r
    def test_set_type_on_other_header(self):\r
        msg = Message()\r
        msg['X-Content-Type'] = 'text/plain'\r
        msg.set_type('application/octet-stream', 'X-Content-Type')\r
        self.assertEqual(msg['x-content-type'], 'application/octet-stream')\r
\r
    def test_get_content_type_missing(self):\r
        msg = Message()\r
        self.assertEqual(msg.get_content_type(), 'text/plain')\r
\r
    def test_get_content_type_missing_with_default_type(self):\r
        msg = Message()\r
        msg.set_default_type('message/rfc822')\r
        self.assertEqual(msg.get_content_type(), 'message/rfc822')\r
\r
    def test_get_content_type_from_message_implicit(self):\r
        msg = self._msgobj('msg_30.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_type(),\r
                         'message/rfc822')\r
\r
    def test_get_content_type_from_message_explicit(self):\r
        msg = self._msgobj('msg_28.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_type(),\r
                         'message/rfc822')\r
\r
    def test_get_content_type_from_message_text_plain_implicit(self):\r
        msg = self._msgobj('msg_03.txt')\r
        self.assertEqual(msg.get_content_type(), 'text/plain')\r
\r
    def test_get_content_type_from_message_text_plain_explicit(self):\r
        msg = self._msgobj('msg_01.txt')\r
        self.assertEqual(msg.get_content_type(), 'text/plain')\r
\r
    def test_get_content_maintype_missing(self):\r
        msg = Message()\r
        self.assertEqual(msg.get_content_maintype(), 'text')\r
\r
    def test_get_content_maintype_missing_with_default_type(self):\r
        msg = Message()\r
        msg.set_default_type('message/rfc822')\r
        self.assertEqual(msg.get_content_maintype(), 'message')\r
\r
    def test_get_content_maintype_from_message_implicit(self):\r
        msg = self._msgobj('msg_30.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')\r
\r
    def test_get_content_maintype_from_message_explicit(self):\r
        msg = self._msgobj('msg_28.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')\r
\r
    def test_get_content_maintype_from_message_text_plain_implicit(self):\r
        msg = self._msgobj('msg_03.txt')\r
        self.assertEqual(msg.get_content_maintype(), 'text')\r
\r
    def test_get_content_maintype_from_message_text_plain_explicit(self):\r
        msg = self._msgobj('msg_01.txt')\r
        self.assertEqual(msg.get_content_maintype(), 'text')\r
\r
    def test_get_content_subtype_missing(self):\r
        msg = Message()\r
        self.assertEqual(msg.get_content_subtype(), 'plain')\r
\r
    def test_get_content_subtype_missing_with_default_type(self):\r
        msg = Message()\r
        msg.set_default_type('message/rfc822')\r
        self.assertEqual(msg.get_content_subtype(), 'rfc822')\r
\r
    def test_get_content_subtype_from_message_implicit(self):\r
        msg = self._msgobj('msg_30.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')\r
\r
    def test_get_content_subtype_from_message_explicit(self):\r
        msg = self._msgobj('msg_28.txt')\r
        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')\r
\r
    def test_get_content_subtype_from_message_text_plain_implicit(self):\r
        msg = self._msgobj('msg_03.txt')\r
        self.assertEqual(msg.get_content_subtype(), 'plain')\r
\r
    def test_get_content_subtype_from_message_text_plain_explicit(self):\r
        msg = self._msgobj('msg_01.txt')\r
        self.assertEqual(msg.get_content_subtype(), 'plain')\r
\r
    def test_get_content_maintype_error(self):\r
        msg = Message()\r
        msg['Content-Type'] = 'no-slash-in-this-string'\r
        self.assertEqual(msg.get_content_maintype(), 'text')\r
\r
    def test_get_content_subtype_error(self):\r
        msg = Message()\r
        msg['Content-Type'] = 'no-slash-in-this-string'\r
        self.assertEqual(msg.get_content_subtype(), 'plain')\r
\r
    def test_replace_header(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.add_header('First', 'One')\r
        msg.add_header('Second', 'Two')\r
        msg.add_header('Third', 'Three')\r
        eq(msg.keys(), ['First', 'Second', 'Third'])\r
        eq(msg.values(), ['One', 'Two', 'Three'])\r
        msg.replace_header('Second', 'Twenty')\r
        eq(msg.keys(), ['First', 'Second', 'Third'])\r
        eq(msg.values(), ['One', 'Twenty', 'Three'])\r
        msg.add_header('First', 'Eleven')\r
        msg.replace_header('First', 'One Hundred')\r
        eq(msg.keys(), ['First', 'Second', 'Third', 'First'])\r
        eq(msg.values(), ['One Hundred', 'Twenty', 'Three', 'Eleven'])\r
        self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')\r
\r
    def test_broken_base64_payload(self):\r
        x = 'AwDp0P7//y6LwKEAcPa/6Q=9'\r
        msg = Message()\r
        msg['content-type'] = 'audio/x-midi'\r
        msg['content-transfer-encoding'] = 'base64'\r
        msg.set_payload(x)\r
        self.assertEqual(msg.get_payload(decode=True), x)\r
\r
\r
\r
# Test the email.encoders module\r
class TestEncoders(unittest.TestCase):\r
    def test_encode_empty_payload(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.set_charset('us-ascii')\r
        eq(msg['content-transfer-encoding'], '7bit')\r
\r
    def test_default_cte(self):\r
        eq = self.assertEqual\r
        msg = MIMEText('hello world')\r
        eq(msg['content-transfer-encoding'], '7bit')\r
\r
    def test_default_cte(self):\r
        eq = self.assertEqual\r
        # With no explicit _charset its us-ascii, and all are 7-bit\r
        msg = MIMEText('hello world')\r
        eq(msg['content-transfer-encoding'], '7bit')\r
        # Similar, but with 8-bit data\r
        msg = MIMEText('hello \xf8 world')\r
        eq(msg['content-transfer-encoding'], '8bit')\r
        # And now with a different charset\r
        msg = MIMEText('hello \xf8 world', _charset='iso-8859-1')\r
        eq(msg['content-transfer-encoding'], 'quoted-printable')\r
\r
\r
\r
# Test long header wrapping\r
class TestLongHeaders(TestEmailBase):\r
    def test_split_long_continuation(self):\r
        eq = self.ndiffAssertEqual\r
        msg = email.message_from_string("""\\r
Subject: bug demonstration\r
\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789\r
\tmore text\r
\r
test\r
""")\r
        sfp = StringIO()\r
        g = Generator(sfp)\r
        g.flatten(msg)\r
        eq(sfp.getvalue(), """\\r
Subject: bug demonstration\r
 12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789\r
 more text\r
\r
test\r
""")\r
\r
    def test_another_long_almost_unsplittable_header(self):\r
        eq = self.ndiffAssertEqual\r
        hstr = """\\r
bug demonstration\r
\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789\r
\tmore text"""\r
        h = Header(hstr, continuation_ws='\t')\r
        eq(h.encode(), """\\r
bug demonstration\r
\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789\r
\tmore text""")\r
        h = Header(hstr)\r
        eq(h.encode(), """\\r
bug demonstration\r
 12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789\r
 more text""")\r
\r
    def test_long_nonstring(self):\r
        eq = self.ndiffAssertEqual\r
        g = Charset("iso-8859-1")\r
        cz = Charset("iso-8859-2")\r
        utf8 = Charset("utf-8")\r
        g_head = "Die Mieter treten hier ein werden mit einem Foerderband komfortabel den Korridor entlang, an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, gegen die rotierenden Klingen bef\xf6rdert. "\r
        cz_head = "Finan\xe8ni metropole se hroutily pod tlakem jejich d\xf9vtipu.. "\r
        utf8_head = u"\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".encode("utf-8")\r
        h = Header(g_head, g, header_name='Subject')\r
        h.append(cz_head, cz)\r
        h.append(utf8_head, utf8)\r
        msg = Message()\r
        msg['Subject'] = h\r
        sfp = StringIO()\r
        g = Generator(sfp)\r
        g.flatten(msg)\r
        eq(sfp.getvalue(), """\\r
Subject: =?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerd?=\r
 =?iso-8859-1?q?erband_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndi?=\r
 =?iso-8859-1?q?schen_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Kling?=\r
 =?iso-8859-1?q?en_bef=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_met?=\r
 =?iso-8859-2?q?ropole_se_hroutily_pod_tlakem_jejich_d=F9vtipu=2E=2E_?=\r
 =?utf-8?b?5q2j56K644Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE?=\r
 =?utf-8?b?44G+44Gb44KT44CC5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB?=\r
 =?utf-8?b?44GC44Go44Gv44Gn44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CM?=\r
 =?utf-8?q?Wenn_ist_das_Nunstuck_git_und_Slotermeyer=3F_Ja!_Beiherhund_das?=\r
 =?utf-8?b?IE9kZXIgZGllIEZsaXBwZXJ3YWxkdCBnZXJzcHV0LuOAjeOBqOiogOOBow==?=\r
 =?utf-8?b?44Gm44GE44G+44GZ44CC?=\r
\r
""")\r
        eq(h.encode(), """\\r
=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerd?=\r
 =?iso-8859-1?q?erband_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndi?=\r
 =?iso-8859-1?q?schen_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Kling?=\r
 =?iso-8859-1?q?en_bef=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_met?=\r
 =?iso-8859-2?q?ropole_se_hroutily_pod_tlakem_jejich_d=F9vtipu=2E=2E_?=\r
 =?utf-8?b?5q2j56K644Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE?=\r
 =?utf-8?b?44G+44Gb44KT44CC5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB?=\r
 =?utf-8?b?44GC44Go44Gv44Gn44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CM?=\r
 =?utf-8?q?Wenn_ist_das_Nunstuck_git_und_Slotermeyer=3F_Ja!_Beiherhund_das?=\r
 =?utf-8?b?IE9kZXIgZGllIEZsaXBwZXJ3YWxkdCBnZXJzcHV0LuOAjeOBqOiogOOBow==?=\r
 =?utf-8?b?44Gm44GE44G+44GZ44CC?=""")\r
\r
    def test_long_header_encode(self):\r
        eq = self.ndiffAssertEqual\r
        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '\r
                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',\r
                   header_name='X-Foobar-Spoink-Defrobnit')\r
        eq(h.encode(), '''\\r
wasnipoop; giraffes="very-long-necked-animals";\r
 spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')\r
\r
    def test_long_header_encode_with_tab_continuation(self):\r
        eq = self.ndiffAssertEqual\r
        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '\r
                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',\r
                   header_name='X-Foobar-Spoink-Defrobnit',\r
                   continuation_ws='\t')\r
        eq(h.encode(), '''\\r
wasnipoop; giraffes="very-long-necked-animals";\r
\tspooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')\r
\r
    def test_header_splitter(self):\r
        eq = self.ndiffAssertEqual\r
        msg = MIMEText('')\r
        # It'd be great if we could use add_header() here, but that doesn't\r
        # guarantee an order of the parameters.\r
        msg['X-Foobar-Spoink-Defrobnit'] = (\r
            'wasnipoop; giraffes="very-long-necked-animals"; '\r
            'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')\r
        sfp = StringIO()\r
        g = Generator(sfp)\r
        g.flatten(msg)\r
        eq(sfp.getvalue(), '''\\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";\r
 spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"\r
\r
''')\r
\r
    def test_no_semis_header_splitter(self):\r
        eq = self.ndiffAssertEqual\r
        msg = Message()\r
        msg['From'] = 'test@dom.ain'\r
        msg['References'] = SPACE.join(['<%d@dom.ain>' % i for i in range(10)])\r
        msg.set_payload('Test')\r
        sfp = StringIO()\r
        g = Generator(sfp)\r
        g.flatten(msg)\r
        eq(sfp.getvalue(), """\\r
From: test@dom.ain\r
References: <0@dom.ain> <1@dom.ain> <2@dom.ain> <3@dom.ain> <4@dom.ain>\r
 <5@dom.ain> <6@dom.ain> <7@dom.ain> <8@dom.ain> <9@dom.ain>\r
\r
Test""")\r
\r
    def test_no_split_long_header(self):\r
        eq = self.ndiffAssertEqual\r
        hstr = 'References: ' + 'x' * 80\r
        h = Header(hstr, continuation_ws='\t')\r
        eq(h.encode(), """\\r
References: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx""")\r
\r
    def test_splitting_multiple_long_lines(self):\r
        eq = self.ndiffAssertEqual\r
        hstr = """\\r
from babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)\r
\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)\r
\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)\r
"""\r
        h = Header(hstr, continuation_ws='\t')\r
        eq(h.encode(), """\\r
from babylon.socal-raves.org (localhost [127.0.0.1]);\r
\tby babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;\r
\tfor <mailman-admin@babylon.socal-raves.org>;\r
\tSat, 2 Feb 2002 17:00:06 -0800 (PST)\r
\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);\r
\tby babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;\r
\tfor <mailman-admin@babylon.socal-raves.org>;\r
\tSat, 2 Feb 2002 17:00:06 -0800 (PST)\r
\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);\r
\tby babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;\r
\tfor <mailman-admin@babylon.socal-raves.org>;\r
\tSat, 2 Feb 2002 17:00:06 -0800 (PST)""")\r
\r
    def test_splitting_first_line_only_is_long(self):\r
        eq = self.ndiffAssertEqual\r
        hstr = """\\r
from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93] helo=cthulhu.gerg.ca)\r
\tby kronos.mems-exchange.org with esmtp (Exim 4.05)\r
\tid 17k4h5-00034i-00\r
\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400"""\r
        h = Header(hstr, maxlinelen=78, header_name='Received',\r
                   continuation_ws='\t')\r
        eq(h.encode(), """\\r
from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93]\r
\thelo=cthulhu.gerg.ca)\r
\tby kronos.mems-exchange.org with esmtp (Exim 4.05)\r
\tid 17k4h5-00034i-00\r
\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400""")\r
\r
    def test_long_8bit_header(self):\r
        eq = self.ndiffAssertEqual\r
        msg = Message()\r
        h = Header('Britische Regierung gibt', 'iso-8859-1',\r
                    header_name='Subject')\r
        h.append('gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte')\r
        msg['Subject'] = h\r
        eq(msg.as_string(), """\\r
Subject: =?iso-8859-1?q?Britische_Regierung_gibt?= =?iso-8859-1?q?gr=FCnes?=\r
 =?iso-8859-1?q?_Licht_f=FCr_Offshore-Windkraftprojekte?=\r
\r
""")\r
\r
    def test_long_8bit_header_no_charset(self):\r
        eq = self.ndiffAssertEqual\r
        msg = Message()\r
        msg['Reply-To'] = 'Britische Regierung gibt gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte <a-very-long-address@example.com>'\r
        eq(msg.as_string(), """\\r
Reply-To: Britische Regierung gibt gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte <a-very-long-address@example.com>\r
\r
""")\r
\r
    def test_long_to_header(self):\r
        eq = self.ndiffAssertEqual\r
        to = '"Someone Test #A" <someone@eecs.umich.edu>,<someone@eecs.umich.edu>,"Someone Test #B" <someone@umich.edu>, "Someone Test #C" <someone@eecs.umich.edu>, "Someone Test #D" <someone@eecs.umich.edu>'\r
        msg = Message()\r
        msg['To'] = to\r
        eq(msg.as_string(0), '''\\r
To: "Someone Test #A" <someone@eecs.umich.edu>, <someone@eecs.umich.edu>,\r
 "Someone Test #B" <someone@umich.edu>,\r
 "Someone Test #C" <someone@eecs.umich.edu>,\r
 "Someone Test #D" <someone@eecs.umich.edu>\r
\r
''')\r
\r
    def test_long_line_after_append(self):\r
        eq = self.ndiffAssertEqual\r
        s = 'This is an example of string which has almost the limit of header length.'\r
        h = Header(s)\r
        h.append('Add another line.')\r
        eq(h.encode(), """\\r
This is an example of string which has almost the limit of header length.\r
 Add another line.""")\r
\r
    def test_shorter_line_with_append(self):\r
        eq = self.ndiffAssertEqual\r
        s = 'This is a shorter line.'\r
        h = Header(s)\r
        h.append('Add another sentence. (Surprise?)')\r
        eq(h.encode(),\r
           'This is a shorter line. Add another sentence. (Surprise?)')\r
\r
    def test_long_field_name(self):\r
        eq = self.ndiffAssertEqual\r
        fn = 'X-Very-Very-Very-Long-Header-Name'\r
        gs = "Die Mieter treten hier ein werden mit einem Foerderband komfortabel den Korridor entlang, an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, gegen die rotierenden Klingen bef\xf6rdert. "\r
        h = Header(gs, 'iso-8859-1', header_name=fn)\r
        # BAW: this seems broken because the first line is too long\r
        eq(h.encode(), """\\r
=?iso-8859-1?q?Die_Mieter_treten_hier_?=\r
 =?iso-8859-1?q?ein_werden_mit_einem_Foerderband_komfortabel_den_Korridor_?=\r
 =?iso-8859-1?q?entlang=2C_an_s=FCdl=FCndischen_Wandgem=E4lden_vorbei=2C_g?=\r
 =?iso-8859-1?q?egen_die_rotierenden_Klingen_bef=F6rdert=2E_?=""")\r
\r
    def test_long_received_header(self):\r
        h = 'from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP; Wed, 05 Mar 2003 18:10:18 -0700'\r
        msg = Message()\r
        msg['Received-1'] = Header(h, continuation_ws='\t')\r
        msg['Received-2'] = h\r
        self.ndiffAssertEqual(msg.as_string(), """\\r
Received-1: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by\r
\throthgar.la.mastaler.com (tmda-ofmipd) with ESMTP;\r
\tWed, 05 Mar 2003 18:10:18 -0700\r
Received-2: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by\r
 hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;\r
 Wed, 05 Mar 2003 18:10:18 -0700\r
\r
""")\r
\r
    def test_string_headerinst_eq(self):\r
        h = '<15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David Bremner\'s message of "Thu, 6 Mar 2003 13:58:21 +0100")'\r
        msg = Message()\r
        msg['Received'] = Header(h, header_name='Received-1',\r
                                 continuation_ws='\t')\r
        msg['Received'] = h\r
        self.ndiffAssertEqual(msg.as_string(), """\\r
Received: <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de>\r
\t(David Bremner's message of "Thu, 6 Mar 2003 13:58:21 +0100")\r
Received: <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de>\r
 (David Bremner's message of "Thu, 6 Mar 2003 13:58:21 +0100")\r
\r
""")\r
\r
    def test_long_unbreakable_lines_with_continuation(self):\r
        eq = self.ndiffAssertEqual\r
        msg = Message()\r
        t = """\\r
 iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9\r
 locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp"""\r
        msg['Face-1'] = t\r
        msg['Face-2'] = Header(t, header_name='Face-2')\r
        eq(msg.as_string(), """\\r
Face-1: iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9\r
 locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp\r
Face-2: iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9\r
 locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp\r
\r
""")\r
\r
    def test_another_long_multiline_header(self):\r
        eq = self.ndiffAssertEqual\r
        m = '''\\r
Received: from siimage.com ([172.25.1.3]) by zima.siliconimage.com with Microsoft SMTPSVC(5.0.2195.4905);\r
 Wed, 16 Oct 2002 07:41:11 -0700'''\r
        msg = email.message_from_string(m)\r
        eq(msg.as_string(), '''\\r
Received: from siimage.com ([172.25.1.3]) by zima.siliconimage.com with\r
 Microsoft SMTPSVC(5.0.2195.4905); Wed, 16 Oct 2002 07:41:11 -0700\r
\r
''')\r
\r
    def test_long_lines_with_different_header(self):\r
        eq = self.ndiffAssertEqual\r
        h = """\\r
List-Unsubscribe: <https://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,\r
        <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>"""\r
        msg = Message()\r
        msg['List'] = h\r
        msg['List'] = Header(h, header_name='List')\r
        self.ndiffAssertEqual(msg.as_string(), """\\r
List: List-Unsubscribe: <https://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,\r
 <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>\r
List: List-Unsubscribe: <https://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,\r
 <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>\r
\r
""")\r
\r
\r
\r
# Test mangling of "From " lines in the body of a message\r
class TestFromMangling(unittest.TestCase):\r
    def setUp(self):\r
        self.msg = Message()\r
        self.msg['From'] = 'aaa@bbb.org'\r
        self.msg.set_payload("""\\r
From the desk of A.A.A.:\r
Blah blah blah\r
""")\r
\r
    def test_mangled_from(self):\r
        s = StringIO()\r
        g = Generator(s, mangle_from_=True)\r
        g.flatten(self.msg)\r
        self.assertEqual(s.getvalue(), """\\r
From: aaa@bbb.org\r
\r
>From the desk of A.A.A.:\r
Blah blah blah\r
""")\r
\r
    def test_dont_mangle_from(self):\r
        s = StringIO()\r
        g = Generator(s, mangle_from_=False)\r
        g.flatten(self.msg)\r
        self.assertEqual(s.getvalue(), """\\r
From: aaa@bbb.org\r
\r
From the desk of A.A.A.:\r
Blah blah blah\r
""")\r
\r
\r
\r
# Test the basic MIMEAudio class\r
class TestMIMEAudio(unittest.TestCase):\r
    def setUp(self):\r
        # Make sure we pick up the audiotest.au that lives in email/test/data.\r
        # In Python, there's an audiotest.au living in Lib/test but that isn't\r
        # included in some binary distros that don't include the test\r
        # package.  The trailing empty string on the .join() is significant\r
        # since findfile() will do a dirname().\r
        datadir = os.path.join(os.path.dirname(landmark), 'data', '')\r
        fp = open(findfile('audiotest.au', datadir), 'rb')\r
        try:\r
            self._audiodata = fp.read()\r
        finally:\r
            fp.close()\r
        self._au = MIMEAudio(self._audiodata)\r
\r
    def test_guess_minor_type(self):\r
        self.assertEqual(self._au.get_content_type(), 'audio/basic')\r
\r
    def test_encoding(self):\r
        payload = self._au.get_payload()\r
        self.assertEqual(base64.decodestring(payload), self._audiodata)\r
\r
    def test_checkSetMinor(self):\r
        au = MIMEAudio(self._audiodata, 'fish')\r
        self.assertEqual(au.get_content_type(), 'audio/fish')\r
\r
    def test_add_header(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        self._au.add_header('Content-Disposition', 'attachment',\r
                            filename='audiotest.au')\r
        eq(self._au['content-disposition'],\r
           'attachment; filename="audiotest.au"')\r
        eq(self._au.get_params(header='content-disposition'),\r
           [('attachment', ''), ('filename', 'audiotest.au')])\r
        eq(self._au.get_param('filename', header='content-disposition'),\r
           'audiotest.au')\r
        missing = []\r
        eq(self._au.get_param('attachment', header='content-disposition'), '')\r
        unless(self._au.get_param('foo', failobj=missing,\r
                                  header='content-disposition') is missing)\r
        # Try some missing stuff\r
        unless(self._au.get_param('foobar', missing) is missing)\r
        unless(self._au.get_param('attachment', missing,\r
                                  header='foobar') is missing)\r
\r
\r
\r
# Test the basic MIMEImage class\r
class TestMIMEImage(unittest.TestCase):\r
    def setUp(self):\r
        fp = openfile('PyBanner048.gif')\r
        try:\r
            self._imgdata = fp.read()\r
        finally:\r
            fp.close()\r
        self._im = MIMEImage(self._imgdata)\r
\r
    def test_guess_minor_type(self):\r
        self.assertEqual(self._im.get_content_type(), 'image/gif')\r
\r
    def test_encoding(self):\r
        payload = self._im.get_payload()\r
        self.assertEqual(base64.decodestring(payload), self._imgdata)\r
\r
    def test_checkSetMinor(self):\r
        im = MIMEImage(self._imgdata, 'fish')\r
        self.assertEqual(im.get_content_type(), 'image/fish')\r
\r
    def test_add_header(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        self._im.add_header('Content-Disposition', 'attachment',\r
                            filename='dingusfish.gif')\r
        eq(self._im['content-disposition'],\r
           'attachment; filename="dingusfish.gif"')\r
        eq(self._im.get_params(header='content-disposition'),\r
           [('attachment', ''), ('filename', 'dingusfish.gif')])\r
        eq(self._im.get_param('filename', header='content-disposition'),\r
           'dingusfish.gif')\r
        missing = []\r
        eq(self._im.get_param('attachment', header='content-disposition'), '')\r
        unless(self._im.get_param('foo', failobj=missing,\r
                                  header='content-disposition') is missing)\r
        # Try some missing stuff\r
        unless(self._im.get_param('foobar', missing) is missing)\r
        unless(self._im.get_param('attachment', missing,\r
                                  header='foobar') is missing)\r
\r
\r
\r
# Test the basic MIMEApplication class\r
class TestMIMEApplication(unittest.TestCase):\r
    def test_headers(self):\r
        eq = self.assertEqual\r
        msg = MIMEApplication('\xfa\xfb\xfc\xfd\xfe\xff')\r
        eq(msg.get_content_type(), 'application/octet-stream')\r
        eq(msg['content-transfer-encoding'], 'base64')\r
\r
    def test_body(self):\r
        eq = self.assertEqual\r
        bytes = '\xfa\xfb\xfc\xfd\xfe\xff'\r
        msg = MIMEApplication(bytes)\r
        eq(msg.get_payload(), '+vv8/f7/')\r
        eq(msg.get_payload(decode=True), bytes)\r
\r
\r
\r
# Test the basic MIMEText class\r
class TestMIMEText(unittest.TestCase):\r
    def setUp(self):\r
        self._msg = MIMEText('hello there')\r
\r
    def test_types(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        eq(self._msg.get_content_type(), 'text/plain')\r
        eq(self._msg.get_param('charset'), 'us-ascii')\r
        missing = []\r
        unless(self._msg.get_param('foobar', missing) is missing)\r
        unless(self._msg.get_param('charset', missing, header='foobar')\r
               is missing)\r
\r
    def test_payload(self):\r
        self.assertEqual(self._msg.get_payload(), 'hello there')\r
        self.assertTrue(not self._msg.is_multipart())\r
\r
    def test_charset(self):\r
        eq = self.assertEqual\r
        msg = MIMEText('hello there', _charset='us-ascii')\r
        eq(msg.get_charset().input_charset, 'us-ascii')\r
        eq(msg['content-type'], 'text/plain; charset="us-ascii"')\r
\r
\r
\r
# Test complicated multipart/* messages\r
class TestMultipart(TestEmailBase):\r
    def setUp(self):\r
        fp = openfile('PyBanner048.gif')\r
        try:\r
            data = fp.read()\r
        finally:\r
            fp.close()\r
\r
        container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')\r
        image = MIMEImage(data, name='dingusfish.gif')\r
        image.add_header('content-disposition', 'attachment',\r
                         filename='dingusfish.gif')\r
        intro = MIMEText('''\\r
Hi there,\r
\r
This is the dingus fish.\r
''')\r
        container.attach(intro)\r
        container.attach(image)\r
        container['From'] = 'Barry <barry@digicool.com>'\r
        container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'\r
        container['Subject'] = 'Here is your dingus fish'\r
\r
        now = 987809702.54848599\r
        timetuple = time.localtime(now)\r
        if timetuple[-1] == 0:\r
            tzsecs = time.timezone\r
        else:\r
            tzsecs = time.altzone\r
        if tzsecs > 0:\r
            sign = '-'\r
        else:\r
            sign = '+'\r
        tzoffset = ' %s%04d' % (sign, tzsecs // 36)\r
        container['Date'] = time.strftime(\r
            '%a, %d %b %Y %H:%M:%S',\r
            time.localtime(now)) + tzoffset\r
        self._msg = container\r
        self._im = image\r
        self._txt = intro\r
\r
    def test_hierarchy(self):\r
        # convenience\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        raises = self.assertRaises\r
        # tests\r
        m = self._msg\r
        unless(m.is_multipart())\r
        eq(m.get_content_type(), 'multipart/mixed')\r
        eq(len(m.get_payload()), 2)\r
        raises(IndexError, m.get_payload, 2)\r
        m0 = m.get_payload(0)\r
        m1 = m.get_payload(1)\r
        unless(m0 is self._txt)\r
        unless(m1 is self._im)\r
        eq(m.get_payload(), [m0, m1])\r
        unless(not m0.is_multipart())\r
        unless(not m1.is_multipart())\r
\r
    def test_empty_multipart_idempotent(self):\r
        text = """\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
\r
--BOUNDARY\r
\r
\r
--BOUNDARY--\r
"""\r
        msg = Parser().parsestr(text)\r
        self.ndiffAssertEqual(text, msg.as_string())\r
\r
    def test_no_parts_in_a_multipart_with_none_epilogue(self):\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.set_boundary('BOUNDARY')\r
        self.ndiffAssertEqual(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
\r
--BOUNDARY--''')\r
\r
    def test_no_parts_in_a_multipart_with_empty_epilogue(self):\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.preamble = ''\r
        outer.epilogue = ''\r
        outer.set_boundary('BOUNDARY')\r
        self.ndiffAssertEqual(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
\r
--BOUNDARY\r
\r
--BOUNDARY--\r
''')\r
\r
    def test_one_part_in_a_multipart(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.set_boundary('BOUNDARY')\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--''')\r
\r
    def test_seq_parts_in_a_multipart_with_empty_preamble(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.preamble = ''\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        outer.set_boundary('BOUNDARY')\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--''')\r
\r
\r
    def test_seq_parts_in_a_multipart_with_none_preamble(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.preamble = None\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        outer.set_boundary('BOUNDARY')\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--''')\r
\r
\r
    def test_seq_parts_in_a_multipart_with_none_epilogue(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.epilogue = None\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        outer.set_boundary('BOUNDARY')\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--''')\r
\r
\r
    def test_seq_parts_in_a_multipart_with_empty_epilogue(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.epilogue = ''\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        outer.set_boundary('BOUNDARY')\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--\r
''')\r
\r
\r
    def test_seq_parts_in_a_multipart_with_nl_epilogue(self):\r
        eq = self.ndiffAssertEqual\r
        outer = MIMEBase('multipart', 'mixed')\r
        outer['Subject'] = 'A subject'\r
        outer['To'] = 'aperson@dom.ain'\r
        outer['From'] = 'bperson@dom.ain'\r
        outer.epilogue = '\n'\r
        msg = MIMEText('hello world')\r
        outer.attach(msg)\r
        outer.set_boundary('BOUNDARY')\r
        eq(outer.as_string(), '''\\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
Subject: A subject\r
To: aperson@dom.ain\r
From: bperson@dom.ain\r
\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
hello world\r
--BOUNDARY--\r
\r
''')\r
\r
    def test_message_external_body(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_36.txt')\r
        eq(len(msg.get_payload()), 2)\r
        msg1 = msg.get_payload(1)\r
        eq(msg1.get_content_type(), 'multipart/alternative')\r
        eq(len(msg1.get_payload()), 2)\r
        for subpart in msg1.get_payload():\r
            eq(subpart.get_content_type(), 'message/external-body')\r
            eq(len(subpart.get_payload()), 1)\r
            subsubpart = subpart.get_payload(0)\r
            eq(subsubpart.get_content_type(), 'text/plain')\r
\r
    def test_double_boundary(self):\r
        # msg_37.txt is a multipart that contains two dash-boundary's in a\r
        # row.  Our interpretation of RFC 2046 calls for ignoring the second\r
        # and subsequent boundaries.\r
        msg = self._msgobj('msg_37.txt')\r
        self.assertEqual(len(msg.get_payload()), 3)\r
\r
    def test_nested_inner_contains_outer_boundary(self):\r
        eq = self.ndiffAssertEqual\r
        # msg_38.txt has an inner part that contains outer boundaries.  My\r
        # interpretation of RFC 2046 (based on sections 5.1 and 5.1.2) say\r
        # these are illegal and should be interpreted as unterminated inner\r
        # parts.\r
        msg = self._msgobj('msg_38.txt')\r
        sfp = StringIO()\r
        iterators._structure(msg, sfp)\r
        eq(sfp.getvalue(), """\\r
multipart/mixed\r
    multipart/mixed\r
        multipart/alternative\r
            text/plain\r
        text/plain\r
    text/plain\r
    text/plain\r
""")\r
\r
    def test_nested_with_same_boundary(self):\r
        eq = self.ndiffAssertEqual\r
        # msg 39.txt is similarly evil in that it's got inner parts that use\r
        # the same boundary as outer parts.  Again, I believe the way this is\r
        # parsed is closest to the spirit of RFC 2046\r
        msg = self._msgobj('msg_39.txt')\r
        sfp = StringIO()\r
        iterators._structure(msg, sfp)\r
        eq(sfp.getvalue(), """\\r
multipart/mixed\r
    multipart/mixed\r
        multipart/alternative\r
        application/octet-stream\r
        application/octet-stream\r
    text/plain\r
""")\r
\r
    def test_boundary_in_non_multipart(self):\r
        msg = self._msgobj('msg_40.txt')\r
        self.assertEqual(msg.as_string(), '''\\r
MIME-Version: 1.0\r
Content-Type: text/html; boundary="--961284236552522269"\r
\r
----961284236552522269\r
Content-Type: text/html;\r
Content-Transfer-Encoding: 7Bit\r
\r
<html></html>\r
\r
----961284236552522269--\r
''')\r
\r
    def test_boundary_with_leading_space(self):\r
        eq = self.assertEqual\r
        msg = email.message_from_string('''\\r
MIME-Version: 1.0\r
Content-Type: multipart/mixed; boundary="    XXXX"\r
\r
--    XXXX\r
Content-Type: text/plain\r
\r
\r
--    XXXX\r
Content-Type: text/plain\r
\r
--    XXXX--\r
''')\r
        self.assertTrue(msg.is_multipart())\r
        eq(msg.get_boundary(), '    XXXX')\r
        eq(len(msg.get_payload()), 2)\r
\r
    def test_boundary_without_trailing_newline(self):\r
        m = Parser().parsestr("""\\r
Content-Type: multipart/mixed; boundary="===============0012394164=="\r
MIME-Version: 1.0\r
\r
--===============0012394164==\r
Content-Type: image/file1.jpg\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: base64\r
\r
YXNkZg==\r
--===============0012394164==--""")\r
        self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')\r
\r
\r
\r
# Test some badly formatted messages\r
class TestNonConformant(TestEmailBase):\r
    def test_parse_missing_minor_type(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_14.txt')\r
        eq(msg.get_content_type(), 'text/plain')\r
        eq(msg.get_content_maintype(), 'text')\r
        eq(msg.get_content_subtype(), 'plain')\r
\r
    def test_same_boundary_inner_outer(self):\r
        unless = self.assertTrue\r
        msg = self._msgobj('msg_15.txt')\r
        # XXX We can probably eventually do better\r
        inner = msg.get_payload(0)\r
        unless(hasattr(inner, 'defects'))\r
        self.assertEqual(len(inner.defects), 1)\r
        unless(isinstance(inner.defects[0],\r
                          errors.StartBoundaryNotFoundDefect))\r
\r
    def test_multipart_no_boundary(self):\r
        unless = self.assertTrue\r
        msg = self._msgobj('msg_25.txt')\r
        unless(isinstance(msg.get_payload(), str))\r
        self.assertEqual(len(msg.defects), 2)\r
        unless(isinstance(msg.defects[0], errors.NoBoundaryInMultipartDefect))\r
        unless(isinstance(msg.defects[1],\r
                          errors.MultipartInvariantViolationDefect))\r
\r
    def test_invalid_content_type(self):\r
        eq = self.assertEqual\r
        neq = self.ndiffAssertEqual\r
        msg = Message()\r
        # RFC 2045, $5.2 says invalid yields text/plain\r
        msg['Content-Type'] = 'text'\r
        eq(msg.get_content_maintype(), 'text')\r
        eq(msg.get_content_subtype(), 'plain')\r
        eq(msg.get_content_type(), 'text/plain')\r
        # Clear the old value and try something /really/ invalid\r
        del msg['content-type']\r
        msg['Content-Type'] = 'foo'\r
        eq(msg.get_content_maintype(), 'text')\r
        eq(msg.get_content_subtype(), 'plain')\r
        eq(msg.get_content_type(), 'text/plain')\r
        # Still, make sure that the message is idempotently generated\r
        s = StringIO()\r
        g = Generator(s)\r
        g.flatten(msg)\r
        neq(s.getvalue(), 'Content-Type: foo\n\n')\r
\r
    def test_no_start_boundary(self):\r
        eq = self.ndiffAssertEqual\r
        msg = self._msgobj('msg_31.txt')\r
        eq(msg.get_payload(), """\\r
--BOUNDARY\r
Content-Type: text/plain\r
\r
message 1\r
\r
--BOUNDARY\r
Content-Type: text/plain\r
\r
message 2\r
\r
--BOUNDARY--\r
""")\r
\r
    def test_no_separating_blank_line(self):\r
        eq = self.ndiffAssertEqual\r
        msg = self._msgobj('msg_35.txt')\r
        eq(msg.as_string(), """\\r
From: aperson@dom.ain\r
To: bperson@dom.ain\r
Subject: here's something interesting\r
\r
counter to RFC 2822, there's no separating newline here\r
""")\r
\r
    def test_lying_multipart(self):\r
        unless = self.assertTrue\r
        msg = self._msgobj('msg_41.txt')\r
        unless(hasattr(msg, 'defects'))\r
        self.assertEqual(len(msg.defects), 2)\r
        unless(isinstance(msg.defects[0], errors.NoBoundaryInMultipartDefect))\r
        unless(isinstance(msg.defects[1],\r
                          errors.MultipartInvariantViolationDefect))\r
\r
    def test_missing_start_boundary(self):\r
        outer = self._msgobj('msg_42.txt')\r
        # The message structure is:\r
        #\r
        # multipart/mixed\r
        #    text/plain\r
        #    message/rfc822\r
        #        multipart/mixed [*]\r
        #\r
        # [*] This message is missing its start boundary\r
        bad = outer.get_payload(1).get_payload(0)\r
        self.assertEqual(len(bad.defects), 1)\r
        self.assertTrue(isinstance(bad.defects[0],\r
                                   errors.StartBoundaryNotFoundDefect))\r
\r
    def test_first_line_is_continuation_header(self):\r
        eq = self.assertEqual\r
        m = ' Line 1\nLine 2\nLine 3'\r
        msg = email.message_from_string(m)\r
        eq(msg.keys(), [])\r
        eq(msg.get_payload(), 'Line 2\nLine 3')\r
        eq(len(msg.defects), 1)\r
        self.assertTrue(isinstance(msg.defects[0],\r
                                   errors.FirstHeaderLineIsContinuationDefect))\r
        eq(msg.defects[0].line, ' Line 1\n')\r
\r
\r
\r
# Test RFC 2047 header encoding and decoding\r
class TestRFC2047(unittest.TestCase):\r
    def test_rfc2047_multiline(self):\r
        eq = self.assertEqual\r
        s = """Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz\r
 foo bar =?mac-iceland?q?r=8Aksm=9Arg=8Cs?="""\r
        dh = decode_header(s)\r
        eq(dh, [\r
            ('Re:', None),\r
            ('r\x8aksm\x9arg\x8cs', 'mac-iceland'),\r
            ('baz foo bar', None),\r
            ('r\x8aksm\x9arg\x8cs', 'mac-iceland')])\r
        eq(str(make_header(dh)),\r
           """Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz foo bar\r
 =?mac-iceland?q?r=8Aksm=9Arg=8Cs?=""")\r
\r
    def test_whitespace_eater_unicode(self):\r
        eq = self.assertEqual\r
        s = '=?ISO-8859-1?Q?Andr=E9?= Pirard <pirard@dom.ain>'\r
        dh = decode_header(s)\r
        eq(dh, [('Andr\xe9', 'iso-8859-1'), ('Pirard <pirard@dom.ain>', None)])\r
        hu = unicode(make_header(dh)).encode('latin-1')\r
        eq(hu, 'Andr\xe9 Pirard <pirard@dom.ain>')\r
\r
    def test_whitespace_eater_unicode_2(self):\r
        eq = self.assertEqual\r
        s = 'The =?iso-8859-1?b?cXVpY2sgYnJvd24gZm94?= jumped over the =?iso-8859-1?b?bGF6eSBkb2c=?='\r
        dh = decode_header(s)\r
        eq(dh, [('The', None), ('quick brown fox', 'iso-8859-1'),\r
                ('jumped over the', None), ('lazy dog', 'iso-8859-1')])\r
        hu = make_header(dh).__unicode__()\r
        eq(hu, u'The quick brown fox jumped over the lazy dog')\r
\r
    def test_rfc2047_missing_whitespace(self):\r
        s = 'Sm=?ISO-8859-1?B?9g==?=rg=?ISO-8859-1?B?5Q==?=sbord'\r
        dh = decode_header(s)\r
        self.assertEqual(dh, [(s, None)])\r
\r
    def test_rfc2047_with_whitespace(self):\r
        s = 'Sm =?ISO-8859-1?B?9g==?= rg =?ISO-8859-1?B?5Q==?= sbord'\r
        dh = decode_header(s)\r
        self.assertEqual(dh, [('Sm', None), ('\xf6', 'iso-8859-1'),\r
                              ('rg', None), ('\xe5', 'iso-8859-1'),\r
                              ('sbord', None)])\r
\r
\r
\r
# Test the MIMEMessage class\r
class TestMIMEMessage(TestEmailBase):\r
    def setUp(self):\r
        fp = openfile('msg_11.txt')\r
        try:\r
            self._text = fp.read()\r
        finally:\r
            fp.close()\r
\r
    def test_type_error(self):\r
        self.assertRaises(TypeError, MIMEMessage, 'a plain string')\r
\r
    def test_valid_argument(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        subject = 'A sub-message'\r
        m = Message()\r
        m['Subject'] = subject\r
        r = MIMEMessage(m)\r
        eq(r.get_content_type(), 'message/rfc822')\r
        payload = r.get_payload()\r
        unless(isinstance(payload, list))\r
        eq(len(payload), 1)\r
        subpart = payload[0]\r
        unless(subpart is m)\r
        eq(subpart['subject'], subject)\r
\r
    def test_bad_multipart(self):\r
        eq = self.assertEqual\r
        msg1 = Message()\r
        msg1['Subject'] = 'subpart 1'\r
        msg2 = Message()\r
        msg2['Subject'] = 'subpart 2'\r
        r = MIMEMessage(msg1)\r
        self.assertRaises(errors.MultipartConversionError, r.attach, msg2)\r
\r
    def test_generate(self):\r
        # First craft the message to be encapsulated\r
        m = Message()\r
        m['Subject'] = 'An enclosed message'\r
        m.set_payload('Here is the body of the message.\n')\r
        r = MIMEMessage(m)\r
        r['Subject'] = 'The enclosing message'\r
        s = StringIO()\r
        g = Generator(s)\r
        g.flatten(r)\r
        self.assertEqual(s.getvalue(), """\\r
Content-Type: message/rfc822\r
MIME-Version: 1.0\r
Subject: The enclosing message\r
\r
Subject: An enclosed message\r
\r
Here is the body of the message.\r
""")\r
\r
    def test_parse_message_rfc822(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        msg = self._msgobj('msg_11.txt')\r
        eq(msg.get_content_type(), 'message/rfc822')\r
        payload = msg.get_payload()\r
        unless(isinstance(payload, list))\r
        eq(len(payload), 1)\r
        submsg = payload[0]\r
        self.assertTrue(isinstance(submsg, Message))\r
        eq(submsg['subject'], 'An enclosed message')\r
        eq(submsg.get_payload(), 'Here is the body of the message.\n')\r
\r
    def test_dsn(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        # msg 16 is a Delivery Status Notification, see RFC 1894\r
        msg = self._msgobj('msg_16.txt')\r
        eq(msg.get_content_type(), 'multipart/report')\r
        unless(msg.is_multipart())\r
        eq(len(msg.get_payload()), 3)\r
        # Subpart 1 is a text/plain, human readable section\r
        subpart = msg.get_payload(0)\r
        eq(subpart.get_content_type(), 'text/plain')\r
        eq(subpart.get_payload(), """\\r
This report relates to a message you sent with the following header fields:\r
\r
  Message-id: <002001c144a6$8752e060$56104586@oxy.edu>\r
  Date: Sun, 23 Sep 2001 20:10:55 -0700\r
  From: "Ian T. Henry" <henryi@oxy.edu>\r
  To: SoCal Raves <scr@socal-raves.org>\r
  Subject: [scr] yeah for Ians!!\r
\r
Your message cannot be delivered to the following recipients:\r
\r
  Recipient address: jangel1@cougar.noc.ucla.edu\r
  Reason: recipient reached disk quota\r
\r
""")\r
        # Subpart 2 contains the machine parsable DSN information.  It\r
        # consists of two blocks of headers, represented by two nested Message\r
        # objects.\r
        subpart = msg.get_payload(1)\r
        eq(subpart.get_content_type(), 'message/delivery-status')\r
        eq(len(subpart.get_payload()), 2)\r
        # message/delivery-status should treat each block as a bunch of\r
        # headers, i.e. a bunch of Message objects.\r
        dsn1 = subpart.get_payload(0)\r
        unless(isinstance(dsn1, Message))\r
        eq(dsn1['original-envelope-id'], '0GK500B4HD0888@cougar.noc.ucla.edu')\r
        eq(dsn1.get_param('dns', header='reporting-mta'), '')\r
        # Try a missing one <wink>\r
        eq(dsn1.get_param('nsd', header='reporting-mta'), None)\r
        dsn2 = subpart.get_payload(1)\r
        unless(isinstance(dsn2, Message))\r
        eq(dsn2['action'], 'failed')\r
        eq(dsn2.get_params(header='original-recipient'),\r
           [('rfc822', ''), ('jangel1@cougar.noc.ucla.edu', '')])\r
        eq(dsn2.get_param('rfc822', header='final-recipient'), '')\r
        # Subpart 3 is the original message\r
        subpart = msg.get_payload(2)\r
        eq(subpart.get_content_type(), 'message/rfc822')\r
        payload = subpart.get_payload()\r
        unless(isinstance(payload, list))\r
        eq(len(payload), 1)\r
        subsubpart = payload[0]\r
        unless(isinstance(subsubpart, Message))\r
        eq(subsubpart.get_content_type(), 'text/plain')\r
        eq(subsubpart['message-id'],\r
           '<002001c144a6$8752e060$56104586@oxy.edu>')\r
\r
    def test_epilogue(self):\r
        eq = self.ndiffAssertEqual\r
        fp = openfile('msg_21.txt')\r
        try:\r
            text = fp.read()\r
        finally:\r
            fp.close()\r
        msg = Message()\r
        msg['From'] = 'aperson@dom.ain'\r
        msg['To'] = 'bperson@dom.ain'\r
        msg['Subject'] = 'Test'\r
        msg.preamble = 'MIME message'\r
        msg.epilogue = 'End of MIME message\n'\r
        msg1 = MIMEText('One')\r
        msg2 = MIMEText('Two')\r
        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')\r
        msg.attach(msg1)\r
        msg.attach(msg2)\r
        sfp = StringIO()\r
        g = Generator(sfp)\r
        g.flatten(msg)\r
        eq(sfp.getvalue(), text)\r
\r
    def test_no_nl_preamble(self):\r
        eq = self.ndiffAssertEqual\r
        msg = Message()\r
        msg['From'] = 'aperson@dom.ain'\r
        msg['To'] = 'bperson@dom.ain'\r
        msg['Subject'] = 'Test'\r
        msg.preamble = 'MIME message'\r
        msg.epilogue = ''\r
        msg1 = MIMEText('One')\r
        msg2 = MIMEText('Two')\r
        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')\r
        msg.attach(msg1)\r
        msg.attach(msg2)\r
        eq(msg.as_string(), """\\r
From: aperson@dom.ain\r
To: bperson@dom.ain\r
Subject: Test\r
Content-Type: multipart/mixed; boundary="BOUNDARY"\r
\r
MIME message\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
One\r
--BOUNDARY\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
Two\r
--BOUNDARY--\r
""")\r
\r
    def test_default_type(self):\r
        eq = self.assertEqual\r
        fp = openfile('msg_30.txt')\r
        try:\r
            msg = email.message_from_file(fp)\r
        finally:\r
            fp.close()\r
        container1 = msg.get_payload(0)\r
        eq(container1.get_default_type(), 'message/rfc822')\r
        eq(container1.get_content_type(), 'message/rfc822')\r
        container2 = msg.get_payload(1)\r
        eq(container2.get_default_type(), 'message/rfc822')\r
        eq(container2.get_content_type(), 'message/rfc822')\r
        container1a = container1.get_payload(0)\r
        eq(container1a.get_default_type(), 'text/plain')\r
        eq(container1a.get_content_type(), 'text/plain')\r
        container2a = container2.get_payload(0)\r
        eq(container2a.get_default_type(), 'text/plain')\r
        eq(container2a.get_content_type(), 'text/plain')\r
\r
    def test_default_type_with_explicit_container_type(self):\r
        eq = self.assertEqual\r
        fp = openfile('msg_28.txt')\r
        try:\r
            msg = email.message_from_file(fp)\r
        finally:\r
            fp.close()\r
        container1 = msg.get_payload(0)\r
        eq(container1.get_default_type(), 'message/rfc822')\r
        eq(container1.get_content_type(), 'message/rfc822')\r
        container2 = msg.get_payload(1)\r
        eq(container2.get_default_type(), 'message/rfc822')\r
        eq(container2.get_content_type(), 'message/rfc822')\r
        container1a = container1.get_payload(0)\r
        eq(container1a.get_default_type(), 'text/plain')\r
        eq(container1a.get_content_type(), 'text/plain')\r
        container2a = container2.get_payload(0)\r
        eq(container2a.get_default_type(), 'text/plain')\r
        eq(container2a.get_content_type(), 'text/plain')\r
\r
    def test_default_type_non_parsed(self):\r
        eq = self.assertEqual\r
        neq = self.ndiffAssertEqual\r
        # Set up container\r
        container = MIMEMultipart('digest', 'BOUNDARY')\r
        container.epilogue = ''\r
        # Set up subparts\r
        subpart1a = MIMEText('message 1\n')\r
        subpart2a = MIMEText('message 2\n')\r
        subpart1 = MIMEMessage(subpart1a)\r
        subpart2 = MIMEMessage(subpart2a)\r
        container.attach(subpart1)\r
        container.attach(subpart2)\r
        eq(subpart1.get_content_type(), 'message/rfc822')\r
        eq(subpart1.get_default_type(), 'message/rfc822')\r
        eq(subpart2.get_content_type(), 'message/rfc822')\r
        eq(subpart2.get_default_type(), 'message/rfc822')\r
        neq(container.as_string(0), '''\\r
Content-Type: multipart/digest; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
\r
--BOUNDARY\r
Content-Type: message/rfc822\r
MIME-Version: 1.0\r
\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
message 1\r
\r
--BOUNDARY\r
Content-Type: message/rfc822\r
MIME-Version: 1.0\r
\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
message 2\r
\r
--BOUNDARY--\r
''')\r
        del subpart1['content-type']\r
        del subpart1['mime-version']\r
        del subpart2['content-type']\r
        del subpart2['mime-version']\r
        eq(subpart1.get_content_type(), 'message/rfc822')\r
        eq(subpart1.get_default_type(), 'message/rfc822')\r
        eq(subpart2.get_content_type(), 'message/rfc822')\r
        eq(subpart2.get_default_type(), 'message/rfc822')\r
        neq(container.as_string(0), '''\\r
Content-Type: multipart/digest; boundary="BOUNDARY"\r
MIME-Version: 1.0\r
\r
--BOUNDARY\r
\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
message 1\r
\r
--BOUNDARY\r
\r
Content-Type: text/plain; charset="us-ascii"\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
\r
message 2\r
\r
--BOUNDARY--\r
''')\r
\r
    def test_mime_attachments_in_constructor(self):\r
        eq = self.assertEqual\r
        text1 = MIMEText('')\r
        text2 = MIMEText('')\r
        msg = MIMEMultipart(_subparts=(text1, text2))\r
        eq(len(msg.get_payload()), 2)\r
        eq(msg.get_payload(0), text1)\r
        eq(msg.get_payload(1), text2)\r
\r
\r
\r
# A general test of parser->model->generator idempotency.  IOW, read a message\r
# in, parse it into a message object tree, then without touching the tree,\r
# regenerate the plain text.  The original text and the transformed text\r
# should be identical.  Note: that we ignore the Unix-From since that may\r
# contain a changed date.\r
class TestIdempotent(TestEmailBase):\r
    def _msgobj(self, filename):\r
        fp = openfile(filename)\r
        try:\r
            data = fp.read()\r
        finally:\r
            fp.close()\r
        msg = email.message_from_string(data)\r
        return msg, data\r
\r
    def _idempotent(self, msg, text):\r
        eq = self.ndiffAssertEqual\r
        s = StringIO()\r
        g = Generator(s, maxheaderlen=0)\r
        g.flatten(msg)\r
        eq(text, s.getvalue())\r
\r
    def test_parse_text_message(self):\r
        eq = self.assertEqual\r
        msg, text = self._msgobj('msg_01.txt')\r
        eq(msg.get_content_type(), 'text/plain')\r
        eq(msg.get_content_maintype(), 'text')\r
        eq(msg.get_content_subtype(), 'plain')\r
        eq(msg.get_params()[1], ('charset', 'us-ascii'))\r
        eq(msg.get_param('charset'), 'us-ascii')\r
        eq(msg.preamble, None)\r
        eq(msg.epilogue, None)\r
        self._idempotent(msg, text)\r
\r
    def test_parse_untyped_message(self):\r
        eq = self.assertEqual\r
        msg, text = self._msgobj('msg_03.txt')\r
        eq(msg.get_content_type(), 'text/plain')\r
        eq(msg.get_params(), None)\r
        eq(msg.get_param('charset'), None)\r
        self._idempotent(msg, text)\r
\r
    def test_simple_multipart(self):\r
        msg, text = self._msgobj('msg_04.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_MIME_digest(self):\r
        msg, text = self._msgobj('msg_02.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_long_header(self):\r
        msg, text = self._msgobj('msg_27.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_MIME_digest_with_part_headers(self):\r
        msg, text = self._msgobj('msg_28.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_mixed_with_image(self):\r
        msg, text = self._msgobj('msg_06.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_multipart_report(self):\r
        msg, text = self._msgobj('msg_05.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_dsn(self):\r
        msg, text = self._msgobj('msg_16.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_preamble_epilogue(self):\r
        msg, text = self._msgobj('msg_21.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_multipart_one_part(self):\r
        msg, text = self._msgobj('msg_23.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_multipart_no_parts(self):\r
        msg, text = self._msgobj('msg_24.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_no_start_boundary(self):\r
        msg, text = self._msgobj('msg_31.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_rfc2231_charset(self):\r
        msg, text = self._msgobj('msg_32.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_more_rfc2231_parameters(self):\r
        msg, text = self._msgobj('msg_33.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_text_plain_in_a_multipart_digest(self):\r
        msg, text = self._msgobj('msg_34.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_nested_multipart_mixeds(self):\r
        msg, text = self._msgobj('msg_12a.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_message_external_body_idempotent(self):\r
        msg, text = self._msgobj('msg_36.txt')\r
        self._idempotent(msg, text)\r
\r
    def test_content_type(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        # Get a message object and reset the seek pointer for other tests\r
        msg, text = self._msgobj('msg_05.txt')\r
        eq(msg.get_content_type(), 'multipart/report')\r
        # Test the Content-Type: parameters\r
        params = {}\r
        for pk, pv in msg.get_params():\r
            params[pk] = pv\r
        eq(params['report-type'], 'delivery-status')\r
        eq(params['boundary'], 'D1690A7AC1.996856090/mail.example.com')\r
        eq(msg.preamble, 'This is a MIME-encapsulated message.\n')\r
        eq(msg.epilogue, '\n')\r
        eq(len(msg.get_payload()), 3)\r
        # Make sure the subparts are what we expect\r
        msg1 = msg.get_payload(0)\r
        eq(msg1.get_content_type(), 'text/plain')\r
        eq(msg1.get_payload(), 'Yadda yadda yadda\n')\r
        msg2 = msg.get_payload(1)\r
        eq(msg2.get_content_type(), 'text/plain')\r
        eq(msg2.get_payload(), 'Yadda yadda yadda\n')\r
        msg3 = msg.get_payload(2)\r
        eq(msg3.get_content_type(), 'message/rfc822')\r
        self.assertTrue(isinstance(msg3, Message))\r
        payload = msg3.get_payload()\r
        unless(isinstance(payload, list))\r
        eq(len(payload), 1)\r
        msg4 = payload[0]\r
        unless(isinstance(msg4, Message))\r
        eq(msg4.get_payload(), 'Yadda yadda yadda\n')\r
\r
    def test_parser(self):\r
        eq = self.assertEqual\r
        unless = self.assertTrue\r
        msg, text = self._msgobj('msg_06.txt')\r
        # Check some of the outer headers\r
        eq(msg.get_content_type(), 'message/rfc822')\r
        # Make sure the payload is a list of exactly one sub-Message, and that\r
        # that submessage has a type of text/plain\r
        payload = msg.get_payload()\r
        unless(isinstance(payload, list))\r
        eq(len(payload), 1)\r
        msg1 = payload[0]\r
        self.assertTrue(isinstance(msg1, Message))\r
        eq(msg1.get_content_type(), 'text/plain')\r
        self.assertTrue(isinstance(msg1.get_payload(), str))\r
        eq(msg1.get_payload(), '\n')\r
\r
\r
\r
# Test various other bits of the package's functionality\r
class TestMiscellaneous(TestEmailBase):\r
    def test_message_from_string(self):\r
        fp = openfile('msg_01.txt')\r
        try:\r
            text = fp.read()\r
        finally:\r
            fp.close()\r
        msg = email.message_from_string(text)\r
        s = StringIO()\r
        # Don't wrap/continue long headers since we're trying to test\r
        # idempotency.\r
        g = Generator(s, maxheaderlen=0)\r
        g.flatten(msg)\r
        self.assertEqual(text, s.getvalue())\r
\r
    def test_message_from_file(self):\r
        fp = openfile('msg_01.txt')\r
        try:\r
            text = fp.read()\r
            fp.seek(0)\r
            msg = email.message_from_file(fp)\r
            s = StringIO()\r
            # Don't wrap/continue long headers since we're trying to test\r
            # idempotency.\r
            g = Generator(s, maxheaderlen=0)\r
            g.flatten(msg)\r
            self.assertEqual(text, s.getvalue())\r
        finally:\r
            fp.close()\r
\r
    def test_message_from_string_with_class(self):\r
        unless = self.assertTrue\r
        fp = openfile('msg_01.txt')\r
        try:\r
            text = fp.read()\r
        finally:\r
            fp.close()\r
        # Create a subclass\r
        class MyMessage(Message):\r
            pass\r
\r
        msg = email.message_from_string(text, MyMessage)\r
        unless(isinstance(msg, MyMessage))\r
        # Try something more complicated\r
        fp = openfile('msg_02.txt')\r
        try:\r
            text = fp.read()\r
        finally:\r
            fp.close()\r
        msg = email.message_from_string(text, MyMessage)\r
        for subpart in msg.walk():\r
            unless(isinstance(subpart, MyMessage))\r
\r
    def test_message_from_file_with_class(self):\r
        unless = self.assertTrue\r
        # Create a subclass\r
        class MyMessage(Message):\r
            pass\r
\r
        fp = openfile('msg_01.txt')\r
        try:\r
            msg = email.message_from_file(fp, MyMessage)\r
        finally:\r
            fp.close()\r
        unless(isinstance(msg, MyMessage))\r
        # Try something more complicated\r
        fp = openfile('msg_02.txt')\r
        try:\r
            msg = email.message_from_file(fp, MyMessage)\r
        finally:\r
            fp.close()\r
        for subpart in msg.walk():\r
            unless(isinstance(subpart, MyMessage))\r
\r
    def test__all__(self):\r
        module = __import__('email')\r
        # Can't use sorted() here due to Python 2.3 compatibility\r
        all = module.__all__[:]\r
        all.sort()\r
        self.assertEqual(all, [\r
            # Old names\r
            'Charset', 'Encoders', 'Errors', 'Generator',\r
            'Header', 'Iterators', 'MIMEAudio', 'MIMEBase',\r
            'MIMEImage', 'MIMEMessage', 'MIMEMultipart',\r
            'MIMENonMultipart', 'MIMEText', 'Message',\r
            'Parser', 'Utils', 'base64MIME',\r
            # new names\r
            'base64mime', 'charset', 'encoders', 'errors', 'generator',\r
            'header', 'iterators', 'message', 'message_from_file',\r
            'message_from_string', 'mime', 'parser',\r
            'quopriMIME', 'quoprimime', 'utils',\r
            ])\r
\r
    def test_formatdate(self):\r
        now = time.time()\r
        self.assertEqual(utils.parsedate(utils.formatdate(now))[:6],\r
                         time.gmtime(now)[:6])\r
\r
    def test_formatdate_localtime(self):\r
        now = time.time()\r
        self.assertEqual(\r
            utils.parsedate(utils.formatdate(now, localtime=True))[:6],\r
            time.localtime(now)[:6])\r
\r
    def test_formatdate_usegmt(self):\r
        now = time.time()\r
        self.assertEqual(\r
            utils.formatdate(now, localtime=False),\r
            time.strftime('%a, %d %b %Y %H:%M:%S -0000', time.gmtime(now)))\r
        self.assertEqual(\r
            utils.formatdate(now, localtime=False, usegmt=True),\r
            time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(now)))\r
\r
    def test_parsedate_none(self):\r
        self.assertEqual(utils.parsedate(''), None)\r
\r
    def test_parsedate_compact(self):\r
        # The FWS after the comma is optional\r
        self.assertEqual(utils.parsedate('Wed,3 Apr 2002 14:58:26 +0800'),\r
                         utils.parsedate('Wed, 3 Apr 2002 14:58:26 +0800'))\r
\r
    def test_parsedate_no_dayofweek(self):\r
        eq = self.assertEqual\r
        eq(utils.parsedate_tz('25 Feb 2003 13:47:26 -0800'),\r
           (2003, 2, 25, 13, 47, 26, 0, 1, -1, -28800))\r
\r
    def test_parsedate_compact_no_dayofweek(self):\r
        eq = self.assertEqual\r
        eq(utils.parsedate_tz('5 Feb 2003 13:47:26 -0800'),\r
           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))\r
\r
    def test_parsedate_acceptable_to_time_functions(self):\r
        eq = self.assertEqual\r
        timetup = utils.parsedate('5 Feb 2003 13:47:26 -0800')\r
        t = int(time.mktime(timetup))\r
        eq(time.localtime(t)[:6], timetup[:6])\r
        eq(int(time.strftime('%Y', timetup)), 2003)\r
        timetup = utils.parsedate_tz('5 Feb 2003 13:47:26 -0800')\r
        t = int(time.mktime(timetup[:9]))\r
        eq(time.localtime(t)[:6], timetup[:6])\r
        eq(int(time.strftime('%Y', timetup[:9])), 2003)\r
\r
    def test_parseaddr_empty(self):\r
        self.assertEqual(utils.parseaddr('<>'), ('', ''))\r
        self.assertEqual(utils.formataddr(utils.parseaddr('<>')), '')\r
\r
    def test_noquote_dump(self):\r
        self.assertEqual(\r
            utils.formataddr(('A Silly Person', 'person@dom.ain')),\r
            'A Silly Person <person@dom.ain>')\r
\r
    def test_escape_dump(self):\r
        self.assertEqual(\r
            utils.formataddr(('A (Very) Silly Person', 'person@dom.ain')),\r
            r'"A \(Very\) Silly Person" <person@dom.ain>')\r
        a = r'A \(Special\) Person'\r
        b = 'person@dom.ain'\r
        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))\r
\r
    def test_escape_backslashes(self):\r
        self.assertEqual(\r
            utils.formataddr(('Arthur \Backslash\ Foobar', 'person@dom.ain')),\r
            r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>')\r
        a = r'Arthur \Backslash\ Foobar'\r
        b = 'person@dom.ain'\r
        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))\r
\r
    def test_name_with_dot(self):\r
        x = 'John X. Doe <jxd@example.com>'\r
        y = '"John X. Doe" <jxd@example.com>'\r
        a, b = ('John X. Doe', 'jxd@example.com')\r
        self.assertEqual(utils.parseaddr(x), (a, b))\r
        self.assertEqual(utils.parseaddr(y), (a, b))\r
        # formataddr() quotes the name if there's a dot in it\r
        self.assertEqual(utils.formataddr((a, b)), y)\r
\r
    def test_multiline_from_comment(self):\r
        x = """\\r
Foo\r
\tBar <foo@example.com>"""\r
        self.assertEqual(utils.parseaddr(x), ('Foo Bar', 'foo@example.com'))\r
\r
    def test_quote_dump(self):\r
        self.assertEqual(\r
            utils.formataddr(('A Silly; Person', 'person@dom.ain')),\r
            r'"A Silly; Person" <person@dom.ain>')\r
\r
    def test_fix_eols(self):\r
        eq = self.assertEqual\r
        eq(utils.fix_eols('hello'), 'hello')\r
        eq(utils.fix_eols('hello\n'), 'hello\r\n')\r
        eq(utils.fix_eols('hello\r'), 'hello\r\n')\r
        eq(utils.fix_eols('hello\r\n'), 'hello\r\n')\r
        eq(utils.fix_eols('hello\n\r'), 'hello\r\n\r\n')\r
\r
    def test_charset_richcomparisons(self):\r
        eq = self.assertEqual\r
        ne = self.assertNotEqual\r
        cset1 = Charset()\r
        cset2 = Charset()\r
        eq(cset1, 'us-ascii')\r
        eq(cset1, 'US-ASCII')\r
        eq(cset1, 'Us-AsCiI')\r
        eq('us-ascii', cset1)\r
        eq('US-ASCII', cset1)\r
        eq('Us-AsCiI', cset1)\r
        ne(cset1, 'usascii')\r
        ne(cset1, 'USASCII')\r
        ne(cset1, 'UsAsCiI')\r
        ne('usascii', cset1)\r
        ne('USASCII', cset1)\r
        ne('UsAsCiI', cset1)\r
        eq(cset1, cset2)\r
        eq(cset2, cset1)\r
\r
    def test_getaddresses(self):\r
        eq = self.assertEqual\r
        eq(utils.getaddresses(['aperson@dom.ain (Al Person)',\r
                               'Bud Person <bperson@dom.ain>']),\r
           [('Al Person', 'aperson@dom.ain'),\r
            ('Bud Person', 'bperson@dom.ain')])\r
\r
    def test_getaddresses_nasty(self):\r
        eq = self.assertEqual\r
        eq(utils.getaddresses(['foo: ;']), [('', '')])\r
        eq(utils.getaddresses(\r
           ['[]*-- =~$']),\r
           [('', ''), ('', ''), ('', '*--')])\r
        eq(utils.getaddresses(\r
           ['foo: ;', '"Jason R. Mastaler" <jason@dom.ain>']),\r
           [('', ''), ('Jason R. Mastaler', 'jason@dom.ain')])\r
\r
    def test_getaddresses_embedded_comment(self):\r
        """Test proper handling of a nested comment"""\r
        eq = self.assertEqual\r
        addrs = utils.getaddresses(['User ((nested comment)) <foo@bar.com>'])\r
        eq(addrs[0][1], 'foo@bar.com')\r
\r
    def test_utils_quote_unquote(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.add_header('content-disposition', 'attachment',\r
                       filename='foo\\wacky"name')\r
        eq(msg.get_filename(), 'foo\\wacky"name')\r
\r
    def test_get_body_encoding_with_bogus_charset(self):\r
        charset = Charset('not a charset')\r
        self.assertEqual(charset.get_body_encoding(), 'base64')\r
\r
    def test_get_body_encoding_with_uppercase_charset(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg['Content-Type'] = 'text/plain; charset=UTF-8'\r
        eq(msg['content-type'], 'text/plain; charset=UTF-8')\r
        charsets = msg.get_charsets()\r
        eq(len(charsets), 1)\r
        eq(charsets[0], 'utf-8')\r
        charset = Charset(charsets[0])\r
        eq(charset.get_body_encoding(), 'base64')\r
        msg.set_payload('hello world', charset=charset)\r
        eq(msg.get_payload(), 'aGVsbG8gd29ybGQ=\n')\r
        eq(msg.get_payload(decode=True), 'hello world')\r
        eq(msg['content-transfer-encoding'], 'base64')\r
        # Try another one\r
        msg = Message()\r
        msg['Content-Type'] = 'text/plain; charset="US-ASCII"'\r
        charsets = msg.get_charsets()\r
        eq(len(charsets), 1)\r
        eq(charsets[0], 'us-ascii')\r
        charset = Charset(charsets[0])\r
        eq(charset.get_body_encoding(), encoders.encode_7or8bit)\r
        msg.set_payload('hello world', charset=charset)\r
        eq(msg.get_payload(), 'hello world')\r
        eq(msg['content-transfer-encoding'], '7bit')\r
\r
    def test_charsets_case_insensitive(self):\r
        lc = Charset('us-ascii')\r
        uc = Charset('US-ASCII')\r
        self.assertEqual(lc.get_body_encoding(), uc.get_body_encoding())\r
\r
    def test_partial_falls_inside_message_delivery_status(self):\r
        eq = self.ndiffAssertEqual\r
        # The Parser interface provides chunks of data to FeedParser in 8192\r
        # byte gulps.  SF bug #1076485 found one of those chunks inside\r
        # message/delivery-status header block, which triggered an\r
        # unreadline() of NeedMoreData.\r
        msg = self._msgobj('msg_43.txt')\r
        sfp = StringIO()\r
        iterators._structure(msg, sfp)\r
        eq(sfp.getvalue(), """\\r
multipart/report\r
    text/plain\r
    message/delivery-status\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
        text/plain\r
    text/rfc822-headers\r
""")\r
\r
\r
\r
# Test the iterator/generators\r
class TestIterators(TestEmailBase):\r
    def test_body_line_iterator(self):\r
        eq = self.assertEqual\r
        neq = self.ndiffAssertEqual\r
        # First a simple non-multipart message\r
        msg = self._msgobj('msg_01.txt')\r
        it = iterators.body_line_iterator(msg)\r
        lines = list(it)\r
        eq(len(lines), 6)\r
        neq(EMPTYSTRING.join(lines), msg.get_payload())\r
        # Now a more complicated multipart\r
        msg = self._msgobj('msg_02.txt')\r
        it = iterators.body_line_iterator(msg)\r
        lines = list(it)\r
        eq(len(lines), 43)\r
        fp = openfile('msg_19.txt')\r
        try:\r
            neq(EMPTYSTRING.join(lines), fp.read())\r
        finally:\r
            fp.close()\r
\r
    def test_typed_subpart_iterator(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_04.txt')\r
        it = iterators.typed_subpart_iterator(msg, 'text')\r
        lines = []\r
        subparts = 0\r
        for subpart in it:\r
            subparts += 1\r
            lines.append(subpart.get_payload())\r
        eq(subparts, 2)\r
        eq(EMPTYSTRING.join(lines), """\\r
a simple kind of mirror\r
to reflect upon our own\r
a simple kind of mirror\r
to reflect upon our own\r
""")\r
\r
    def test_typed_subpart_iterator_default_type(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_03.txt')\r
        it = iterators.typed_subpart_iterator(msg, 'text', 'plain')\r
        lines = []\r
        subparts = 0\r
        for subpart in it:\r
            subparts += 1\r
            lines.append(subpart.get_payload())\r
        eq(subparts, 1)\r
        eq(EMPTYSTRING.join(lines), """\\r
\r
Hi,\r
\r
Do you like this message?\r
\r
-Me\r
""")\r
\r
\r
\r
class TestParsers(TestEmailBase):\r
    def test_header_parser(self):\r
        eq = self.assertEqual\r
        # Parse only the headers of a complex multipart MIME document\r
        fp = openfile('msg_02.txt')\r
        try:\r
            msg = HeaderParser().parse(fp)\r
        finally:\r
            fp.close()\r
        eq(msg['from'], 'ppp-request@zzz.org')\r
        eq(msg['to'], 'ppp@zzz.org')\r
        eq(msg.get_content_type(), 'multipart/mixed')\r
        self.assertFalse(msg.is_multipart())\r
        self.assertTrue(isinstance(msg.get_payload(), str))\r
\r
    def test_whitespace_continuation(self):\r
        eq = self.assertEqual\r
        # This message contains a line after the Subject: header that has only\r
        # whitespace, but it is not empty!\r
        msg = email.message_from_string("""\\r
From: aperson@dom.ain\r
To: bperson@dom.ain\r
Subject: the next line has a space on it\r
\x20\r
Date: Mon, 8 Apr 2002 15:09:19 -0400\r
Message-ID: spam\r
\r
Here's the message body\r
""")\r
        eq(msg['subject'], 'the next line has a space on it\n ')\r
        eq(msg['message-id'], 'spam')\r
        eq(msg.get_payload(), "Here's the message body\n")\r
\r
    def test_whitespace_continuation_last_header(self):\r
        eq = self.assertEqual\r
        # Like the previous test, but the subject line is the last\r
        # header.\r
        msg = email.message_from_string("""\\r
From: aperson@dom.ain\r
To: bperson@dom.ain\r
Date: Mon, 8 Apr 2002 15:09:19 -0400\r
Message-ID: spam\r
Subject: the next line has a space on it\r
\x20\r
\r
Here's the message body\r
""")\r
        eq(msg['subject'], 'the next line has a space on it\n ')\r
        eq(msg['message-id'], 'spam')\r
        eq(msg.get_payload(), "Here's the message body\n")\r
\r
    def test_crlf_separation(self):\r
        eq = self.assertEqual\r
        fp = openfile('msg_26.txt', mode='rb')\r
        try:\r
            msg = Parser().parse(fp)\r
        finally:\r
            fp.close()\r
        eq(len(msg.get_payload()), 2)\r
        part1 = msg.get_payload(0)\r
        eq(part1.get_content_type(), 'text/plain')\r
        eq(part1.get_payload(), 'Simple email with attachment.\r\n\r\n')\r
        part2 = msg.get_payload(1)\r
        eq(part2.get_content_type(), 'application/riscos')\r
\r
    def test_multipart_digest_with_extra_mime_headers(self):\r
        eq = self.assertEqual\r
        neq = self.ndiffAssertEqual\r
        fp = openfile('msg_28.txt')\r
        try:\r
            msg = email.message_from_file(fp)\r
        finally:\r
            fp.close()\r
        # Structure is:\r
        # multipart/digest\r
        #   message/rfc822\r
        #     text/plain\r
        #   message/rfc822\r
        #     text/plain\r
        eq(msg.is_multipart(), 1)\r
        eq(len(msg.get_payload()), 2)\r
        part1 = msg.get_payload(0)\r
        eq(part1.get_content_type(), 'message/rfc822')\r
        eq(part1.is_multipart(), 1)\r
        eq(len(part1.get_payload()), 1)\r
        part1a = part1.get_payload(0)\r
        eq(part1a.is_multipart(), 0)\r
        eq(part1a.get_content_type(), 'text/plain')\r
        neq(part1a.get_payload(), 'message 1\n')\r
        # next message/rfc822\r
        part2 = msg.get_payload(1)\r
        eq(part2.get_content_type(), 'message/rfc822')\r
        eq(part2.is_multipart(), 1)\r
        eq(len(part2.get_payload()), 1)\r
        part2a = part2.get_payload(0)\r
        eq(part2a.is_multipart(), 0)\r
        eq(part2a.get_content_type(), 'text/plain')\r
        neq(part2a.get_payload(), 'message 2\n')\r
\r
    def test_three_lines(self):\r
        # A bug report by Andrew McNamara\r
        lines = ['From: Andrew Person <aperson@dom.ain',\r
                 'Subject: Test',\r
                 'Date: Tue, 20 Aug 2002 16:43:45 +1000']\r
        msg = email.message_from_string(NL.join(lines))\r
        self.assertEqual(msg['date'], 'Tue, 20 Aug 2002 16:43:45 +1000')\r
\r
    def test_strip_line_feed_and_carriage_return_in_headers(self):\r
        eq = self.assertEqual\r
        # For [ 1002475 ] email message parser doesn't handle \r\n correctly\r
        value1 = 'text'\r
        value2 = 'more text'\r
        m = 'Header: %s\r\nNext-Header: %s\r\n\r\nBody\r\n\r\n' % (\r
            value1, value2)\r
        msg = email.message_from_string(m)\r
        eq(msg.get('Header'), value1)\r
        eq(msg.get('Next-Header'), value2)\r
\r
    def test_rfc2822_header_syntax(self):\r
        eq = self.assertEqual\r
        m = '>From: foo\nFrom: bar\n!"#QUX;~: zoo\n\nbody'\r
        msg = email.message_from_string(m)\r
        eq(len(msg.keys()), 3)\r
        keys = msg.keys()\r
        keys.sort()\r
        eq(keys, ['!"#QUX;~', '>From', 'From'])\r
        eq(msg.get_payload(), 'body')\r
\r
    def test_rfc2822_space_not_allowed_in_header(self):\r
        eq = self.assertEqual\r
        m = '>From foo@example.com 11:25:53\nFrom: bar\n!"#QUX;~: zoo\n\nbody'\r
        msg = email.message_from_string(m)\r
        eq(len(msg.keys()), 0)\r
\r
    def test_rfc2822_one_character_header(self):\r
        eq = self.assertEqual\r
        m = 'A: first header\nB: second header\nCC: third header\n\nbody'\r
        msg = email.message_from_string(m)\r
        headers = msg.keys()\r
        headers.sort()\r
        eq(headers, ['A', 'B', 'CC'])\r
        eq(msg.get_payload(), 'body')\r
\r
\r
\r
class TestBase64(unittest.TestCase):\r
    def test_len(self):\r
        eq = self.assertEqual\r
        eq(base64mime.base64_len('hello'),\r
           len(base64mime.encode('hello', eol='')))\r
        for size in range(15):\r
            if   size == 0 : bsize = 0\r
            elif size <= 3 : bsize = 4\r
            elif size <= 6 : bsize = 8\r
            elif size <= 9 : bsize = 12\r
            elif size <= 12: bsize = 16\r
            else           : bsize = 20\r
            eq(base64mime.base64_len('x'*size), bsize)\r
\r
    def test_decode(self):\r
        eq = self.assertEqual\r
        eq(base64mime.decode(''), '')\r
        eq(base64mime.decode('aGVsbG8='), 'hello')\r
        eq(base64mime.decode('aGVsbG8=', 'X'), 'hello')\r
        eq(base64mime.decode('aGVsbG8NCndvcmxk\n', 'X'), 'helloXworld')\r
\r
    def test_encode(self):\r
        eq = self.assertEqual\r
        eq(base64mime.encode(''), '')\r
        eq(base64mime.encode('hello'), 'aGVsbG8=\n')\r
        # Test the binary flag\r
        eq(base64mime.encode('hello\n'), 'aGVsbG8K\n')\r
        eq(base64mime.encode('hello\n', 0), 'aGVsbG8NCg==\n')\r
        # Test the maxlinelen arg\r
        eq(base64mime.encode('xxxx ' * 20, maxlinelen=40), """\\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
eHh4eCB4eHh4IA==\r
""")\r
        # Test the eol argument\r
        eq(base64mime.encode('xxxx ' * 20, maxlinelen=40, eol='\r\n'), """\\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r\r
eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r\r
eHh4eCB4eHh4IA==\r\r
""")\r
\r
    def test_header_encode(self):\r
        eq = self.assertEqual\r
        he = base64mime.header_encode\r
        eq(he('hello'), '=?iso-8859-1?b?aGVsbG8=?=')\r
        eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8NCndvcmxk?=')\r
        # Test the charset option\r
        eq(he('hello', charset='iso-8859-2'), '=?iso-8859-2?b?aGVsbG8=?=')\r
        # Test the keep_eols flag\r
        eq(he('hello\nworld', keep_eols=True),\r
           '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')\r
        # Test the maxlinelen argument\r
        eq(he('xxxx ' * 20, maxlinelen=40), """\\r
=?iso-8859-1?b?eHh4eCB4eHh4IHh4eHggeHg=?=\r
 =?iso-8859-1?b?eHggeHh4eCB4eHh4IHh4eHg=?=\r
 =?iso-8859-1?b?IHh4eHggeHh4eCB4eHh4IHg=?=\r
 =?iso-8859-1?b?eHh4IHh4eHggeHh4eCB4eHg=?=\r
 =?iso-8859-1?b?eCB4eHh4IHh4eHggeHh4eCA=?=\r
 =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""")\r
        # Test the eol argument\r
        eq(he('xxxx ' * 20, maxlinelen=40, eol='\r\n'), """\\r
=?iso-8859-1?b?eHh4eCB4eHh4IHh4eHggeHg=?=\r\r
 =?iso-8859-1?b?eHggeHh4eCB4eHh4IHh4eHg=?=\r\r
 =?iso-8859-1?b?IHh4eHggeHh4eCB4eHh4IHg=?=\r\r
 =?iso-8859-1?b?eHh4IHh4eHggeHh4eCB4eHg=?=\r\r
 =?iso-8859-1?b?eCB4eHh4IHh4eHggeHh4eCA=?=\r\r
 =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""")\r
\r
\r
\r
class TestQuopri(unittest.TestCase):\r
    def setUp(self):\r
        self.hlit = [chr(x) for x in range(ord('a'), ord('z')+1)] + \\r
                    [chr(x) for x in range(ord('A'), ord('Z')+1)] + \\r
                    [chr(x) for x in range(ord('0'), ord('9')+1)] + \\r
                    ['!', '*', '+', '-', '/', ' ']\r
        self.hnon = [chr(x) for x in range(256) if chr(x) not in self.hlit]\r
        assert len(self.hlit) + len(self.hnon) == 256\r
        self.blit = [chr(x) for x in range(ord(' '), ord('~')+1)] + ['\t']\r
        self.blit.remove('=')\r
        self.bnon = [chr(x) for x in range(256) if chr(x) not in self.blit]\r
        assert len(self.blit) + len(self.bnon) == 256\r
\r
    def test_header_quopri_check(self):\r
        for c in self.hlit:\r
            self.assertFalse(quoprimime.header_quopri_check(c))\r
        for c in self.hnon:\r
            self.assertTrue(quoprimime.header_quopri_check(c))\r
\r
    def test_body_quopri_check(self):\r
        for c in self.blit:\r
            self.assertFalse(quoprimime.body_quopri_check(c))\r
        for c in self.bnon:\r
            self.assertTrue(quoprimime.body_quopri_check(c))\r
\r
    def test_header_quopri_len(self):\r
        eq = self.assertEqual\r
        hql = quoprimime.header_quopri_len\r
        enc = quoprimime.header_encode\r
        for s in ('hello', 'h@e@l@l@o@'):\r
            # Empty charset and no line-endings.  7 == RFC chrome\r
            eq(hql(s), len(enc(s, charset='', eol=''))-7)\r
        for c in self.hlit:\r
            eq(hql(c), 1)\r
        for c in self.hnon:\r
            eq(hql(c), 3)\r
\r
    def test_body_quopri_len(self):\r
        eq = self.assertEqual\r
        bql = quoprimime.body_quopri_len\r
        for c in self.blit:\r
            eq(bql(c), 1)\r
        for c in self.bnon:\r
            eq(bql(c), 3)\r
\r
    def test_quote_unquote_idempotent(self):\r
        for x in range(256):\r
            c = chr(x)\r
            self.assertEqual(quoprimime.unquote(quoprimime.quote(c)), c)\r
\r
    def test_header_encode(self):\r
        eq = self.assertEqual\r
        he = quoprimime.header_encode\r
        eq(he('hello'), '=?iso-8859-1?q?hello?=')\r
        eq(he('hello\nworld'), '=?iso-8859-1?q?hello=0D=0Aworld?=')\r
        # Test the charset option\r
        eq(he('hello', charset='iso-8859-2'), '=?iso-8859-2?q?hello?=')\r
        # Test the keep_eols flag\r
        eq(he('hello\nworld', keep_eols=True), '=?iso-8859-1?q?hello=0Aworld?=')\r
        # Test a non-ASCII character\r
        eq(he('hello\xc7there'), '=?iso-8859-1?q?hello=C7there?=')\r
        # Test the maxlinelen argument\r
        eq(he('xxxx ' * 20, maxlinelen=40), """\\r
=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xx?=\r
 =?iso-8859-1?q?xx_xxxx_xxxx_xxxx_xxxx?=\r
 =?iso-8859-1?q?_xxxx_xxxx_xxxx_xxxx_x?=\r
 =?iso-8859-1?q?xxx_xxxx_xxxx_xxxx_xxx?=\r
 =?iso-8859-1?q?x_xxxx_xxxx_?=""")\r
        # Test the eol argument\r
        eq(he('xxxx ' * 20, maxlinelen=40, eol='\r\n'), """\\r
=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xx?=\r\r
 =?iso-8859-1?q?xx_xxxx_xxxx_xxxx_xxxx?=\r\r
 =?iso-8859-1?q?_xxxx_xxxx_xxxx_xxxx_x?=\r\r
 =?iso-8859-1?q?xxx_xxxx_xxxx_xxxx_xxx?=\r\r
 =?iso-8859-1?q?x_xxxx_xxxx_?=""")\r
\r
    def test_decode(self):\r
        eq = self.assertEqual\r
        eq(quoprimime.decode(''), '')\r
        eq(quoprimime.decode('hello'), 'hello')\r
        eq(quoprimime.decode('hello', 'X'), 'hello')\r
        eq(quoprimime.decode('hello\nworld', 'X'), 'helloXworld')\r
\r
    def test_encode(self):\r
        eq = self.assertEqual\r
        eq(quoprimime.encode(''), '')\r
        eq(quoprimime.encode('hello'), 'hello')\r
        # Test the binary flag\r
        eq(quoprimime.encode('hello\r\nworld'), 'hello\nworld')\r
        eq(quoprimime.encode('hello\r\nworld', 0), 'hello\nworld')\r
        # Test the maxlinelen arg\r
        eq(quoprimime.encode('xxxx ' * 20, maxlinelen=40), """\\r
xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=\r
 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=\r
x xxxx xxxx xxxx xxxx=20""")\r
        # Test the eol argument\r
        eq(quoprimime.encode('xxxx ' * 20, maxlinelen=40, eol='\r\n'), """\\r
xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=\r\r
 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=\r\r
x xxxx xxxx xxxx xxxx=20""")\r
        eq(quoprimime.encode("""\\r
one line\r
\r
two line"""), """\\r
one line\r
\r
two line""")\r
\r
\r
\r
# Test the Charset class\r
class TestCharset(unittest.TestCase):\r
    def tearDown(self):\r
        from email import charset as CharsetModule\r
        try:\r
            del CharsetModule.CHARSETS['fake']\r
        except KeyError:\r
            pass\r
\r
    def test_idempotent(self):\r
        eq = self.assertEqual\r
        # Make sure us-ascii = no Unicode conversion\r
        c = Charset('us-ascii')\r
        s = 'Hello World!'\r
        sp = c.to_splittable(s)\r
        eq(s, c.from_splittable(sp))\r
        # test 8-bit idempotency with us-ascii\r
        s = '\xa4\xa2\xa4\xa4\xa4\xa6\xa4\xa8\xa4\xaa'\r
        sp = c.to_splittable(s)\r
        eq(s, c.from_splittable(sp))\r
\r
    def test_body_encode(self):\r
        eq = self.assertEqual\r
        # Try a charset with QP body encoding\r
        c = Charset('iso-8859-1')\r
        eq('hello w=F6rld', c.body_encode('hello w\xf6rld'))\r
        # Try a charset with Base64 body encoding\r
        c = Charset('utf-8')\r
        eq('aGVsbG8gd29ybGQ=\n', c.body_encode('hello world'))\r
        # Try a charset with None body encoding\r
        c = Charset('us-ascii')\r
        eq('hello world', c.body_encode('hello world'))\r
        # Try the convert argument, where input codec != output codec\r
        c = Charset('euc-jp')\r
        # With apologies to Tokio Kikuchi ;)\r
        try:\r
            eq('\x1b$B5FCO;~IW\x1b(B',\r
               c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7'))\r
            eq('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7',\r
               c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7', False))\r
        except LookupError:\r
            # We probably don't have the Japanese codecs installed\r
            pass\r
        # Testing SF bug #625509, which we have to fake, since there are no\r
        # built-in encodings where the header encoding is QP but the body\r
        # encoding is not.\r
        from email import charset as CharsetModule\r
        CharsetModule.add_charset('fake', CharsetModule.QP, None)\r
        c = Charset('fake')\r
        eq('hello w\xf6rld', c.body_encode('hello w\xf6rld'))\r
\r
    def test_unicode_charset_name(self):\r
        charset = Charset(u'us-ascii')\r
        self.assertEqual(str(charset), 'us-ascii')\r
        self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')\r
\r
\r
\r
# Test multilingual MIME headers.\r
class TestHeader(TestEmailBase):\r
    def test_simple(self):\r
        eq = self.ndiffAssertEqual\r
        h = Header('Hello World!')\r
        eq(h.encode(), 'Hello World!')\r
        h.append(' Goodbye World!')\r
        eq(h.encode(), 'Hello World!  Goodbye World!')\r
\r
    def test_simple_surprise(self):\r
        eq = self.ndiffAssertEqual\r
        h = Header('Hello World!')\r
        eq(h.encode(), 'Hello World!')\r
        h.append('Goodbye World!')\r
        eq(h.encode(), 'Hello World! Goodbye World!')\r
\r
    def test_header_needs_no_decoding(self):\r
        h = 'no decoding needed'\r
        self.assertEqual(decode_header(h), [(h, None)])\r
\r
    def test_long(self):\r
        h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",\r
                   maxlinelen=76)\r
        for l in h.encode(splitchars=' ').split('\n '):\r
            self.assertTrue(len(l) <= 76)\r
\r
    def test_multilingual(self):\r
        eq = self.ndiffAssertEqual\r
        g = Charset("iso-8859-1")\r
        cz = Charset("iso-8859-2")\r
        utf8 = Charset("utf-8")\r
        g_head = "Die Mieter treten hier ein werden mit einem Foerderband komfortabel den Korridor entlang, an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, gegen die rotierenden Klingen bef\xf6rdert. "\r
        cz_head = "Finan\xe8ni metropole se hroutily pod tlakem jejich d\xf9vtipu.. "\r
        utf8_head = u"\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".encode("utf-8")\r
        h = Header(g_head, g)\r
        h.append(cz_head, cz)\r
        h.append(utf8_head, utf8)\r
        enc = h.encode()\r
        eq(enc, """\\r
=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderband_ko?=\r
 =?iso-8859-1?q?mfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen_Wan?=\r
 =?iso-8859-1?q?dgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef=F6?=\r
 =?iso-8859-1?q?rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hroutily?=\r
 =?iso-8859-2?q?_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=\r
 =?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC?=\r
 =?utf-8?b?5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn?=\r
 =?utf-8?b?44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFz?=\r
 =?utf-8?q?_Nunstuck_git_und_Slotermeyer=3F_Ja!_Beiherhund_das_Oder_die_Fl?=\r
 =?utf-8?b?aXBwZXJ3YWxkdCBnZXJzcHV0LuOAjeOBqOiogOOBo+OBpuOBhOOBvuOBmQ==?=\r
 =?utf-8?b?44CC?=""")\r
        eq(decode_header(enc),\r
           [(g_head, "iso-8859-1"), (cz_head, "iso-8859-2"),\r
            (utf8_head, "utf-8")])\r
        ustr = unicode(h)\r
        eq(ustr.encode('utf-8'),\r
           'Die Mieter treten hier ein werden mit einem Foerderband '\r
           'komfortabel den Korridor entlang, an s\xc3\xbcdl\xc3\xbcndischen '\r
           'Wandgem\xc3\xa4lden vorbei, gegen die rotierenden Klingen '\r
           'bef\xc3\xb6rdert. Finan\xc4\x8dni metropole se hroutily pod '\r
           'tlakem jejich d\xc5\xafvtipu.. \xe6\xad\xa3\xe7\xa2\xba\xe3\x81'\r
           '\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3'\r
           '\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3'\r
           '\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'\r
           '\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e'\r
           '\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3'\r
           '\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82'\r
           '\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b'\r
           '\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git '\r
           'und Slotermeyer? Ja! Beiherhund das Oder die Flipperwaldt '\r
           'gersput.\xe3\x80\x8d\xe3\x81\xa8\xe8\xa8\x80\xe3\x81\xa3\xe3\x81'\r
           '\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x99\xe3\x80\x82')\r
        # Test make_header()\r
        newh = make_header(decode_header(enc))\r
        eq(newh, enc)\r
\r
    def test_header_ctor_default_args(self):\r
        eq = self.ndiffAssertEqual\r
        h = Header()\r
        eq(h, '')\r
        h.append('foo', Charset('iso-8859-1'))\r
        eq(h, '=?iso-8859-1?q?foo?=')\r
\r
    def test_explicit_maxlinelen(self):\r
        eq = self.ndiffAssertEqual\r
        hstr = 'A very long line that must get split to something other than at the 76th character boundary to test the non-default behavior'\r
        h = Header(hstr)\r
        eq(h.encode(), '''\\r
A very long line that must get split to something other than at the 76th\r
 character boundary to test the non-default behavior''')\r
        h = Header(hstr, header_name='Subject')\r
        eq(h.encode(), '''\\r
A very long line that must get split to something other than at the\r
 76th character boundary to test the non-default behavior''')\r
        h = Header(hstr, maxlinelen=1024, header_name='Subject')\r
        eq(h.encode(), hstr)\r
\r
    def test_us_ascii_header(self):\r
        eq = self.assertEqual\r
        s = 'hello'\r
        x = decode_header(s)\r
        eq(x, [('hello', None)])\r
        h = make_header(x)\r
        eq(s, h.encode())\r
\r
    def test_string_charset(self):\r
        eq = self.assertEqual\r
        h = Header()\r
        h.append('hello', 'iso-8859-1')\r
        eq(h, '=?iso-8859-1?q?hello?=')\r
\r
##    def test_unicode_error(self):\r
##        raises = self.assertRaises\r
##        raises(UnicodeError, Header, u'[P\xf6stal]', 'us-ascii')\r
##        raises(UnicodeError, Header, '[P\xf6stal]', 'us-ascii')\r
##        h = Header()\r
##        raises(UnicodeError, h.append, u'[P\xf6stal]', 'us-ascii')\r
##        raises(UnicodeError, h.append, '[P\xf6stal]', 'us-ascii')\r
##        raises(UnicodeError, Header, u'\u83ca\u5730\u6642\u592b', 'iso-8859-1')\r
\r
    def test_utf8_shortest(self):\r
        eq = self.assertEqual\r
        h = Header(u'p\xf6stal', 'utf-8')\r
        eq(h.encode(), '=?utf-8?q?p=C3=B6stal?=')\r
        h = Header(u'\u83ca\u5730\u6642\u592b', 'utf-8')\r
        eq(h.encode(), '=?utf-8?b?6I+K5Zyw5pmC5aSr?=')\r
\r
    def test_bad_8bit_header(self):\r
        raises = self.assertRaises\r
        eq = self.assertEqual\r
        x = 'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'\r
        raises(UnicodeError, Header, x)\r
        h = Header()\r
        raises(UnicodeError, h.append, x)\r
        eq(str(Header(x, errors='replace')), x)\r
        h.append(x, errors='replace')\r
        eq(str(h), x)\r
\r
    def test_encoded_adjacent_nonencoded(self):\r
        eq = self.assertEqual\r
        h = Header()\r
        h.append('hello', 'iso-8859-1')\r
        h.append('world')\r
        s = h.encode()\r
        eq(s, '=?iso-8859-1?q?hello?= world')\r
        h = make_header(decode_header(s))\r
        eq(h.encode(), s)\r
\r
    def test_whitespace_eater(self):\r
        eq = self.assertEqual\r
        s = 'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztk=?= =?koi8-r?q?=CA?= zz.'\r
        parts = decode_header(s)\r
        eq(parts, [('Subject:', None), ('\xf0\xd2\xcf\xd7\xc5\xd2\xcb\xc1 \xce\xc1 \xc6\xc9\xce\xc1\xcc\xd8\xce\xd9\xca', 'koi8-r'), ('zz.', None)])\r
        hdr = make_header(parts)\r
        eq(hdr.encode(),\r
           'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztnK?= zz.')\r
\r
    def test_broken_base64_header(self):\r
        raises = self.assertRaises\r
        s = 'Subject: =?EUC-KR?B?CSixpLDtKSC/7Liuvsax4iC6uLmwMcijIKHaILzSwd/H0SC8+LCjwLsgv7W/+Mj3I ?='\r
        raises(errors.HeaderParseError, decode_header, s)\r
\r
\r
\r
# Test RFC 2231 header parameters (en/de)coding\r
class TestRFC2231(TestEmailBase):\r
    def test_get_param(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_29.txt')\r
        eq(msg.get_param('title'),\r
           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))\r
        eq(msg.get_param('title', unquote=False),\r
           ('us-ascii', 'en', '"This is even more ***fun*** isn\'t it!"'))\r
\r
    def test_set_param(self):\r
        eq = self.assertEqual\r
        msg = Message()\r
        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',\r
                      charset='us-ascii')\r
        eq(msg.get_param('title'),\r
           ('us-ascii', '', 'This is even more ***fun*** isn\'t it!'))\r
        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',\r
                      charset='us-ascii', language='en')\r
        eq(msg.get_param('title'),\r
           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))\r
        msg = self._msgobj('msg_01.txt')\r
        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',\r
                      charset='us-ascii', language='en')\r
        self.ndiffAssertEqual(msg.as_string(), """\\r
Return-Path: <bbb@zzz.org>\r
Delivered-To: bbb@zzz.org\r
Received: by mail.zzz.org (Postfix, from userid 889)\r
 id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
Message-ID: <15090.61304.110929.45684@aaa.zzz.org>\r
From: bbb@ddd.com (John X. Doe)\r
To: bbb@zzz.org\r
Subject: This is a test message\r
Date: Fri, 4 May 2001 14:05:44 -0400\r
Content-Type: text/plain; charset=us-ascii;\r
 title*="us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21"\r
\r
\r
Hi,\r
\r
Do you like this message?\r
\r
-Me\r
""")\r
\r
    def test_del_param(self):\r
        eq = self.ndiffAssertEqual\r
        msg = self._msgobj('msg_01.txt')\r
        msg.set_param('foo', 'bar', charset='us-ascii', language='en')\r
        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',\r
            charset='us-ascii', language='en')\r
        msg.del_param('foo', header='Content-Type')\r
        eq(msg.as_string(), """\\r
Return-Path: <bbb@zzz.org>\r
Delivered-To: bbb@zzz.org\r
Received: by mail.zzz.org (Postfix, from userid 889)\r
 id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)\r
MIME-Version: 1.0\r
Content-Transfer-Encoding: 7bit\r
Message-ID: <15090.61304.110929.45684@aaa.zzz.org>\r
From: bbb@ddd.com (John X. Doe)\r
To: bbb@zzz.org\r
Subject: This is a test message\r
Date: Fri, 4 May 2001 14:05:44 -0400\r
Content-Type: text/plain; charset="us-ascii";\r
 title*="us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21"\r
\r
\r
Hi,\r
\r
Do you like this message?\r
\r
-Me\r
""")\r
\r
    def test_rfc2231_get_content_charset(self):\r
        eq = self.assertEqual\r
        msg = self._msgobj('msg_32.txt')\r
        eq(msg.get_content_charset(), 'us-ascii')\r
\r
    def test_rfc2231_no_language_or_charset(self):\r
        m = '''\\r
Content-Transfer-Encoding: 8bit\r
Content-Disposition: inline; filename="file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm"\r
Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEM; NAME*1=P_nsmail.htm\r
\r
'''\r
        msg = email.message_from_string(m)\r
        param = msg.get_param('NAME')\r
        self.assertFalse(isinstance(param, tuple))\r
        self.assertEqual(\r
            param,\r
            'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')\r
\r
    def test_rfc2231_no_language_or_charset_in_filename(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0*="''This%20is%20even%20more%20";\r
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_filename(),\r
                         'This is even more ***fun*** is it not.pdf')\r
\r
    def test_rfc2231_no_language_or_charset_in_filename_encoded(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0*="''This%20is%20even%20more%20";\r
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_filename(),\r
                         'This is even more ***fun*** is it not.pdf')\r
\r
    def test_rfc2231_partly_encoded(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0="''This%20is%20even%20more%20";\r
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(\r
            msg.get_filename(),\r
            'This%20is%20even%20more%20***fun*** is it not.pdf')\r
\r
    def test_rfc2231_partly_nonencoded(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0="This%20is%20even%20more%20";\r
\tfilename*1="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(\r
            msg.get_filename(),\r
            'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20is it not.pdf')\r
\r
    def test_rfc2231_no_language_or_charset_in_boundary(self):\r
        m = '''\\r
Content-Type: multipart/alternative;\r
\tboundary*0*="''This%20is%20even%20more%20";\r
\tboundary*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tboundary*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_boundary(),\r
                         'This is even more ***fun*** is it not.pdf')\r
\r
    def test_rfc2231_no_language_or_charset_in_charset(self):\r
        # This is a nonsensical charset value, but tests the code anyway\r
        m = '''\\r
Content-Type: text/plain;\r
\tcharset*0*="This%20is%20even%20more%20";\r
\tcharset*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tcharset*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_content_charset(),\r
                         'this is even more ***fun*** is it not.pdf')\r
\r
    def test_rfc2231_bad_encoding_in_filename(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0*="bogus'xx'This%20is%20even%20more%20";\r
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2="is it not.pdf"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_filename(),\r
                         'This is even more ***fun*** is it not.pdf')\r
\r
    def test_rfc2231_bad_encoding_in_charset(self):\r
        m = """\\r
Content-Type: text/plain; charset*=bogus''utf-8%E2%80%9D\r
\r
"""\r
        msg = email.message_from_string(m)\r
        # This should return None because non-ascii characters in the charset\r
        # are not allowed.\r
        self.assertEqual(msg.get_content_charset(), None)\r
\r
    def test_rfc2231_bad_character_in_charset(self):\r
        m = """\\r
Content-Type: text/plain; charset*=ascii''utf-8%E2%80%9D\r
\r
"""\r
        msg = email.message_from_string(m)\r
        # This should return None because non-ascii characters in the charset\r
        # are not allowed.\r
        self.assertEqual(msg.get_content_charset(), None)\r
\r
    def test_rfc2231_bad_character_in_filename(self):\r
        m = '''\\r
Content-Disposition: inline;\r
\tfilename*0*="ascii'xx'This%20is%20even%20more%20";\r
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";\r
\tfilename*2*="is it not.pdf%E2"\r
\r
'''\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_filename(),\r
                         u'This is even more ***fun*** is it not.pdf\ufffd')\r
\r
    def test_rfc2231_unknown_encoding(self):\r
        m = """\\r
Content-Transfer-Encoding: 8bit\r
Content-Disposition: inline; filename*=X-UNKNOWN''myfile.txt\r
\r
"""\r
        msg = email.message_from_string(m)\r
        self.assertEqual(msg.get_filename(), 'myfile.txt')\r
\r
    def test_rfc2231_single_tick_in_filename_extended(self):\r
        eq = self.assertEqual\r
        m = """\\r
Content-Type: application/x-foo;\r
\tname*0*=\"Frank's\"; name*1*=\" Document\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        charset, language, s = msg.get_param('name')\r
        eq(charset, None)\r
        eq(language, None)\r
        eq(s, "Frank's Document")\r
\r
    def test_rfc2231_single_tick_in_filename(self):\r
        m = """\\r
Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        param = msg.get_param('name')\r
        self.assertFalse(isinstance(param, tuple))\r
        self.assertEqual(param, "Frank's Document")\r
\r
    def test_rfc2231_tick_attack_extended(self):\r
        eq = self.assertEqual\r
        m = """\\r
Content-Type: application/x-foo;\r
\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        charset, language, s = msg.get_param('name')\r
        eq(charset, 'us-ascii')\r
        eq(language, 'en-us')\r
        eq(s, "Frank's Document")\r
\r
    def test_rfc2231_tick_attack(self):\r
        m = """\\r
Content-Type: application/x-foo;\r
\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        param = msg.get_param('name')\r
        self.assertFalse(isinstance(param, tuple))\r
        self.assertEqual(param, "us-ascii'en-us'Frank's Document")\r
\r
    def test_rfc2231_no_extended_values(self):\r
        eq = self.assertEqual\r
        m = """\\r
Content-Type: application/x-foo; name=\"Frank's Document\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        eq(msg.get_param('name'), "Frank's Document")\r
\r
    def test_rfc2231_encoded_then_unencoded_segments(self):\r
        eq = self.assertEqual\r
        m = """\\r
Content-Type: application/x-foo;\r
\tname*0*=\"us-ascii'en-us'My\";\r
\tname*1=\" Document\";\r
\tname*2*=\" For You\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        charset, language, s = msg.get_param('name')\r
        eq(charset, 'us-ascii')\r
        eq(language, 'en-us')\r
        eq(s, 'My Document For You')\r
\r
    def test_rfc2231_unencoded_then_encoded_segments(self):\r
        eq = self.assertEqual\r
        m = """\\r
Content-Type: application/x-foo;\r
\tname*0=\"us-ascii'en-us'My\";\r
\tname*1*=\" Document\";\r
\tname*2*=\" For You\"\r
\r
"""\r
        msg = email.message_from_string(m)\r
        charset, language, s = msg.get_param('name')\r
        eq(charset, 'us-ascii')\r
        eq(language, 'en-us')\r
        eq(s, 'My Document For You')\r
\r
\r
\r
def _testclasses():\r
    mod = sys.modules[__name__]\r
    return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]\r
\r
\r
def suite():\r
    suite = unittest.TestSuite()\r
    for testclass in _testclasses():\r
        suite.addTest(unittest.makeSuite(testclass))\r
    return suite\r
\r
\r
def test_main():\r
    for testclass in _testclasses():\r
        run_unittest(testclass)\r
\r
\r
\r
if __name__ == '__main__':\r
    unittest.main(defaultTest='suite')\r