An extensive test suite for the email package.

Lib/test/test_email.py

+# Copyright (C) 2001 Python Software Foundation
+# email package unit tests
+
+import os
+import time
+import unittest
+import base64
+from cStringIO import StringIO
+from types import StringType
+
+import email
+
+from email.Parser import Parser
+from email.Generator import Generator, DecodedGenerator
+from email.Message import Message
+from email.Text import Text
+from email.Image import Image
+from email.MIMEBase import MIMEBase
+from email.MessageRFC822 import MessageRFC822
+from email import Utils
+from email import Errors
+from email import Encoders
+from email import Iterators
+
+import test.regrtest
+
+NL = '\n'
+EMPTYSTRING = ''
+
+
+
+def openfile(filename):
+    path = os.path.join(os.path.dirname(test.regrtest.__file__),
+                        'data', filename)
+    return open(path)
+
+
+
+# Base test class
+class TestEmailBase(unittest.TestCase):
+    def _msgobj(self, filename):
+        fp = openfile(filename)
+        try:
+            msgobj = email.message_from_file(fp)
+        finally:
+            fp.close()
+        return msgobj
+
+
+
+# Test various aspects of the Message class's API
+class TestMessageAPI(TestEmailBase):
+    def test_get_charsets(self):
+        eq = self.assertEqual
+        
+        msgobj = self._msgobj('msg_08.txt')
+        charsets = msgobj.get_charsets()
+        eq(charsets, ['us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])
+
+        msgobj = self._msgobj('msg_09.txt')
+        charsets = msgobj.get_charsets('dingbat')
+        eq(charsets, ['us-ascii', 'iso-8859-1', 'dingbat', 'koi8-r'])
+
+        msgobj = self._msgobj('msg_12.txt')
+        charsets = msgobj.get_charsets()
+        eq(charsets, ['us-ascii', 'iso-8859-1', 'iso-8859-2', 'iso-8859-3',
+                      'us-ascii', 'koi8-r'])
+
+    def test_get_filename(self):
+        eq = self.assertEqual
+
+        msgobj = self._msgobj('msg_04.txt')
+        filenames = [p.get_filename() for p in msgobj.get_payload()]
+        eq(filenames, ['msg.txt', 'msg.txt'])
+
+        msgobj = self._msgobj('msg_07.txt')
+        subpart = msgobj.get_payload(1)
+        eq(subpart.get_filename(), 'dingusfish.gif')
+
+    def test_get_boundary(self):
+        eq = self.assertEqual
+        msgobj = self._msgobj('msg_07.txt')
+        # No quotes!
+        eq(msgobj.get_boundary(), 'BOUNDARY')
+
+    def test_set_boundary(self):
+        eq = self.assertEqual
+        # This one has no existing boundary parameter, but the Content-Type:
+        # header appears fifth.
+        msgobj = self._msgobj('msg_01.txt')
+        msgobj.set_boundary('BOUNDARY')
+        header, value = msgobj.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'text/plain; charset=us-ascii; boundary="BOUNDARY"')
+        # This one has a Content-Type: header, with a boundary, stuck in the
+        # middle of its headers.  Make sure the order is preserved; it should
+        # be fifth.
+        msgobj = self._msgobj('msg_04.txt')
+        msgobj.set_boundary('BOUNDARY')
+        header, value = msgobj.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'multipart/mixed; boundary="BOUNDARY"')
+        # And this one has no Content-Type: header at all.
+        msgobj = self._msgobj('msg_03.txt')
+        self.assertRaises(Errors.HeaderParseError,
+                          msgobj.set_boundary, 'BOUNDARY')
+
+    def test_get_decoded_payload(self):
+        eq = self.assertEqual
+        msgobj = self._msgobj('msg_10.txt')
+        # The outer message is a multipart
+        eq(msgobj.get_payload(decode=1), None)
+        # Subpart 1 is 7bit encoded
+        eq(msgobj.get_payload(0).get_payload(decode=1),
+           'This is a 7bit encoded message.\n')
+        # Subpart 2 is quopri
+        eq(msgobj.get_payload(1).get_payload(decode=1),
+           '\xa1This is a Quoted Printable encoded message!\n')
+        # Subpart 3 is base64
+        eq(msgobj.get_payload(2).get_payload(decode=1),
+           'This is a Base64 encoded message.')
+        # Subpart 4 has no Content-Transfer-Encoding: header.
+        eq(msgobj.get_payload(3).get_payload(decode=1),
+           'This has no Content-Transfer-Encoding: header.\n')
+
+    def test_decoded_generator(self):
+        eq = self.assertEqual
+        msgobj = self._msgobj('msg_07.txt')
+        s = StringIO()
+        g = DecodedGenerator(s)
+        g(msgobj)
+        eq(s.getvalue(), '''\
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+Hi there,
+
+This is the dingus fish.
+
+[Non-text (image/gif) part of message omitted, filename dingusfish.gif]
+''')        
+
+    def test__contains__(self):
+        msg = Message()
+        msg['From'] = 'Me'
+        msg['to'] = 'You'
+        # Check for case insensitivity
+        self.failUnless('from' in msg)
+        self.failUnless('From' in msg)
+        self.failUnless('FROM' in msg)
+        self.failUnless('to' in msg)
+        self.failUnless('To' in msg)
+        self.failUnless('TO' in msg)
+
+    def test_as_string(self):
+        eq = self.assertEqual
+        msgobj = self._msgobj('msg_01.txt')
+        fp = openfile('msg_01.txt')
+        try:
+            text = fp.read()
+        finally:
+            fp.close()
+        eq(text, msgobj.as_string())
+        fullrepr = str(msgobj)
+        lines = fullrepr.split('\n')
+        self.failUnless(lines[0].startswith('From '))
+        eq(text, NL.join(lines[1:]))
+
+    def test_bad_param(self):
+        msg = email.message_from_string("""\
+From: foo
+Content-Type: blarg; baz; boo
+
+""")
+        self.assertEqual(msg.get_param('baz'), '')
+
+    def test_missing_filename(self):
+        msg = email.message_from_string("""\
+From: foo
+
+""")
+        self.assertEqual(msg.get_filename(), None)
+
+    def test_bogus_filename(self):
+        msg = email.message_from_string("""\
+From: foo
+Content-Disposition: blarg; filename
+
+""")
+        self.assertEqual(msg.get_filename(), '')
+        
+    def test_missing_boundary(self):
+        msg = email.message_from_string("""\
+From: foo
+
+""")
+        self.assertEqual(msg.get_boundary(), None)
+
+
+
+# Test the email.Encoders module
+class TestEncoders(unittest.TestCase):
+    def test_encode_noop(self):
+        eq = self.assertEqual
+        msg = Text('hello world', _encoder=Encoders.encode_noop)
+        eq(msg.get_payload(), 'hello world\n')
+        eq(msg['content-transfer-encoding'], None)
+
+    def test_encode_7bit(self):
+        eq = self.assertEqual
+        msg = Text('hello world', _encoder=Encoders.encode_7or8bit)
+        eq(msg.get_payload(), 'hello world\n')
+        eq(msg['content-transfer-encoding'], '7bit')
+        msg = Text('hello \x7f world', _encoder=Encoders.encode_7or8bit)
+        eq(msg.get_payload(), 'hello \x7f world\n')
+        eq(msg['content-transfer-encoding'], '7bit')
+
+    def test_encode_8bit(self):
+        eq = self.assertEqual
+        msg = Text('hello \x80 world', _encoder=Encoders.encode_7or8bit)
+        eq(msg.get_payload(), 'hello \x80 world\n')
+        eq(msg['content-transfer-encoding'], '8bit')
+
+    def test_encode_base64(self):
+        eq = self.assertEqual
+        msg = Text('hello world', _encoder=Encoders.encode_base64)
+        eq(msg.get_payload(), 'aGVsbG8gd29ybGQK\n')
+        eq(msg['content-transfer-encoding'], 'base64')
+
+    def test_encode_quoted_printable(self):
+        eq = self.assertEqual
+        msg = Text('hello world', _encoder=Encoders.encode_quopri)
+        eq(msg.get_payload(), 'hello=20world\n')
+        eq(msg['content-transfer-encoding'], 'quoted-printable')
+
+
+
+class TestLongHeaders(unittest.TestCase):
+    def test_header_splitter(self):
+        msg = Text('')
+        # It'd be great if we could use add_header() here, but that doesn't
+        # guarantee an order of the parameters.
+        msg['X-Foobar-Spoink-Defrobnit'] = (
+            'wasnipoop; giraffes="very-long-necked-animals"; '
+            'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g(msg)
+        self.assertEqual(sfp.getvalue(), '''\
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
+	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
+
+''')
+
+
+
+class TestFromMangling(unittest.TestCase):
+    def setUp(self):
+        self.msg = Message()
+        self.msg['From'] = 'aaa@bbb.org'
+        self.msg.add_payload("""\
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_mangled_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=1)
+        g(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+>From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_dont_mangle_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=0)
+        g(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+
+
+# Test the basic Image class
+class TestImage(unittest.TestCase):
+    def setUp(self):
+        fp = openfile('PyBanner048.gif')
+        try:
+            self._imgdata = fp.read()
+        finally:
+            fp.close()
+        self._im = Image(self._imgdata)
+
+    def test_guess_minor_type(self):
+        self.assertEqual(self._im.get_type(), 'image/gif')
+
+    def test_encoding(self):
+        payload = self._im.get_payload()
+        self.assertEqual(base64.decodestring(payload), self._imgdata)
+
+    def checkSetMinor(self):
+        im = Image(self._imgdata, 'fish')
+        self.assertEqual(im.get_type(), 'image/fish')
+
+    def test_custom_encoder(self):
+        eq = self.assertEqual
+        def encoder(msg):
+            orig = msg.get_payload()
+            msg.set_payload(0)
+            msg['Content-Transfer-Encoding'] = 'broken64'
+        im = Image(self._imgdata, _encoder=encoder)
+        eq(im.get_payload(), 0)
+        eq(im['content-transfer-encoding'], 'broken64')
+
+    def test_add_header(self):
+        eq = self.assertEqual
+        unless = self.failUnless
+        self._im.add_header('Content-Disposition', 'attachment',
+                            filename='dingusfish.gif')
+        eq(self._im['content-disposition'],
+           'attachment; filename="dingusfish.gif"')
+        eq(self._im.get_params(header='content-disposition'),
+           ['filename="dingusfish.gif"'])
+        eq(self._im.get_param('filename', header='content-disposition'),
+           'dingusfish.gif')
+        missing = []
+        unless(self._im.get_param('attachment', missing,
+                                  header='content-disposition') is missing)
+        # Try some missing stuff
+        unless(self._im.get_param('foobar', missing) is missing)
+        unless(self._im.get_param('attachment', missing,
+                                  header='foobar') is missing)
+
+
+
+# Test the basic Text class
+class TestText(unittest.TestCase):
+    def setUp(self):
+        self._msg = Text('hello there')
+
+    def test_types(self):
+        eq = self.assertEqual
+        unless = self.failUnless
+        eq(self._msg.get_type(), 'text/plain')
+        eq(self._msg.get_param('charset'), 'us-ascii')
+        missing = []
+        unless(self._msg.get_param('foobar', missing) is missing)
+        unless(self._msg.get_param('charset', missing, header='foobar')
+               is missing)
+
+    def test_payload(self):
+        self.assertEqual(self._msg.get_payload(), 'hello there\n')
+        self.failUnless(not self._msg.is_multipart())
+
+
+
+class TestMultipartMixed(unittest.TestCase):
+    def setUp(self):
+        fp = openfile('PyBanner048.gif')
+        try:
+            data = fp.read()
+        finally:
+            fp.close()
+
+        container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')
+        image = Image(data, name='dingusfish.gif')
+        image.add_header('content-disposition', 'attachment',
+                         filename='dingusfish.gif')
+        intro = Text('''\
+Hi there,
+
+This is the dingus fish.
+''')
+        container.add_payload(intro)
+        container.add_payload(image)
+        container['From'] = 'Barry <barry@digicool.com>'
+        container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'
+        container['Subject'] = 'Here is your dingus fish'
+        
+        now = 987809702.54848599
+        timetuple = time.localtime(now)
+        if timetuple[-1] == 0:
+            tzsecs = time.timezone
+        else:
+            tzsecs = time.altzone
+        if tzsecs > 0:
+            sign = '-'
+        else:
+            sign = '+'
+        tzoffset = ' %s%04d' % (sign, tzsecs / 36)
+        container['Date'] = time.strftime(
+            '%a, %d %b %Y %H:%M:%S',
+            time.localtime(now)) + tzoffset
+        self._msg = container
+        self._im = image
+        self._txt = intro
+
+    def test_hierarchy(self):
+        # convenience
+        eq = self.assertEqual
+        unless = self.failUnless
+        raises = self.assertRaises
+        # tests
+        m = self._msg
+        unless(m.is_multipart())
+        eq(m.get_type(), 'multipart/mixed')
+        eq(len(m.get_payload()), 2)
+        raises(IndexError, m.get_payload, 2)
+        m0 = m.get_payload(0)
+        m1 = m.get_payload(1)
+        unless(m0 is self._txt)
+        unless(m1 is self._im)
+        eq(m.get_payload(), [m0, m1])
+        unless(not m0.is_multipart())
+        unless(not m1.is_multipart())
+
+
+
+class TestNonConformant(TestEmailBase):
+    def test_parse_missing_minor_type(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_14.txt')
+        eq(msg.get_type(), 'text')
+        eq(msg.get_main_type(), 'text')
+        self.failUnless(msg.get_subtype() is None)
+
+    def test_bogus_boundary(self):
+        fp = openfile('msg_15.txt')
+        try:
+            data = fp.read()
+        finally:
+            fp.close()
+        p = Parser()
+        # Note, under a future non-strict parsing mode, this would parse the
+        # message into the intended message tree.
+        self.assertRaises(Errors.BoundaryError, p.parsestr, data)
+
+
+
+class TestRFC2047(unittest.TestCase):
+    def test_iso_8859_1(self):
+        eq = self.assertEqual
+        s = '=?iso-8859-1?q?this=20is=20some=20text?='
+        eq(Utils.decode(s), 'this is some text')
+        s = '=?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?='
+        eq(Utils.decode(s), u'Keld_J\xf8rn_Simonsen')
+        s = '=?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=' \
+            '=?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?='
+        eq(Utils.decode(s), 'If you can read this you understand the example.')
+        s = '=?iso-8859-8?b?7eXs+SDv4SDp7Oj08A==?='
+        eq(Utils.decode(s),
+           u'\u05dd\u05d5\u05dc\u05e9 \u05df\u05d1 \u05d9\u05dc\u05d8\u05e4\u05e0')
+        s = '=?iso-8859-1?q?this=20is?= =?iso-8859-1?q?some=20text?='
+        eq(Utils.decode(s), u'this is some text')
+
+    def test_encode_header(self):
+        eq = self.assertEqual
+        s = 'this is some text'
+        eq(Utils.encode(s), '=?iso-8859-1?q?this=20is=20some=20text?=')
+        s = 'Keld_J\xf8rn_Simonsen'
+        eq(Utils.encode(s), '=?iso-8859-1?q?Keld_J=F8rn_Simonsen?=')
+        s1 = 'If you can read this yo'
+        s2 = 'u understand the example.'
+        eq(Utils.encode(s1, encoding='b'),
+           '=?iso-8859-1?b?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=')
+        eq(Utils.encode(s2, charset='iso-8859-2', encoding='b'),
+           '=?iso-8859-2?b?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=')
+
+
+
+class TestMessageRFC822(unittest.TestCase):
+    def setUp(self):
+        fp = openfile('msg_11.txt')
+        self._text = fp.read()
+        fp.close()
+
+    def test_type_error(self):
+        self.assertRaises(TypeError, MessageRFC822, 'a plain string')
+
+    def test_valid_argument(self):
+        eq = self.assertEqual
+        subject = 'A sub-message'
+        m = Message()
+        m['Subject'] = subject
+        r = MessageRFC822(m)
+        eq(r.get_type(), 'message/rfc822')
+        self.failUnless(r.get_payload() is m)
+        eq(r.get_payload()['subject'], subject)
+
+    def test_generate(self):
+        # First craft the message to be encapsulated
+        m = Message()
+        m['Subject'] = 'An enclosed message'
+        m.add_payload('Here is the body of the message.\n')
+        r = MessageRFC822(m)
+        r['Subject'] = 'The enclosing message'
+        s = StringIO()
+        g = Generator(s)
+        g(r)
+        self.assertEqual(s.getvalue(), self._text)
+
+
+
+class TestIdempotent(unittest.TestCase):
+    def _msgobj(self, filename):
+        fp = openfile(filename)
+        try:
+            data = fp.read()
+        finally:
+            fp.close()
+        msgobj = email.message_from_string(data)
+        return msgobj, data
+
+    def _idempotent(self, msg, text):
+        eq = self.assertEquals
+        s = StringIO()
+        g = Generator(s, maxheaderlen=0)
+        g(msg)
+        eq(text, s.getvalue())
+
+    def test_parse_text_message(self):
+        eq = self.assertEquals
+        msg, text = self._msgobj('msg_01.txt')
+        eq(msg.get_type(), 'text/plain')
+        eq(msg.get_main_type(), 'text')
+        eq(msg.get_subtype(), 'plain')
+        eq(msg.get_params(), ['charset=us-ascii'])
+        eq(msg.get_param('charset'), 'us-ascii')
+        eq(msg.preamble, None)
+        eq(msg.epilogue, None)
+        self._idempotent(msg, text)
+
+    def test_parse_untyped_message(self):
+        eq = self.assertEquals
+        msg, text = self._msgobj('msg_03.txt')
+        eq(msg.get_type(), None)
+        eq(msg.get_params(), None)
+        eq(msg.get_param('charset'), None)
+        self._idempotent(msg, text)
+
+    def test_simple_multipart(self):
+        msg, text = self._msgobj('msg_04.txt')
+        self._idempotent(msg, text)
+
+    def test_MIME_digest(self):
+        msg, text = self._msgobj('msg_02.txt')
+        self._idempotent(msg, text)
+
+    def test_mixed_with_image(self):
+        msg, text = self._msgobj('msg_06.txt')
+        self._idempotent(msg, text)
+    
+    def test_multipart_report(self):
+        msg, text = self._msgobj('msg_05.txt')
+        self._idempotent(msg, text)
+        
+    def test_content_type(self):
+        eq = self.assertEquals
+        # Get a message object and reset the seek pointer for other tests
+        msg, text = self._msgobj('msg_05.txt')
+        eq(msg.get_type(), 'multipart/report')
+        # Test the Content-Type: parameters
+        params = {}
+        for p in msg.get_params():
+            pk, pv = p.split('=', 1)
+            params[pk] = pv
+        eq(params['report-type'], 'delivery-status')
+        eq(params['boundary'], '"D1690A7AC1.996856090/mail.example.com"')
+        eq(msg.preamble, 'This is a MIME-encapsulated message.\n\n')
+        eq(msg.epilogue, '\n\n')
+        eq(len(msg.get_payload()), 3)
+        # Make sure the subparts are what we expect
+        msg1 = msg.get_payload(0)
+        eq(msg1.get_type(), 'text/plain')
+        eq(msg1.get_payload(), 'Yadda yadda yadda\n')
+        msg2 = msg.get_payload(1)
+        eq(msg2.get_type(), None)
+        eq(msg2.get_payload(), 'Yadda yadda yadda\n')
+        msg3 = msg.get_payload(2)
+        eq(msg3.get_type(), 'message/rfc822')
+        self.failUnless(isinstance(msg3, Message))
+        msg4 = msg3.get_payload()
+        self.failUnless(isinstance(msg4, Message))
+        eq(msg4.get_payload(), 'Yadda yadda yadda\n')
+
+    def test_parser(self):
+        eq = self.assertEquals
+        msg, text = self._msgobj('msg_06.txt')
+        # Check some of the outer headers
+        eq(msg.get_type(), 'message/rfc822')
+        # Make sure there's exactly one thing in the payload and that's a
+        # sub-Message object of type text/plain
+        msg1 = msg.get_payload()
+        self.failUnless(isinstance(msg1, Message))
+        eq(msg1.get_type(), 'text/plain')
+        self.failUnless(isinstance(msg1.get_payload(), StringType))
+        eq(msg1.get_payload(), '\n')
+        
+
+
+class TestMiscellaneous(unittest.TestCase):
+    def test_message_from_string(self):
+        fp = openfile('msg_01.txt')
+        try:
+            text = fp.read()
+        finally:
+            fp.close()
+        msg = email.message_from_string(text)
+        s = StringIO()
+        # Don't wrap/continue long headers since we're trying to test
+        # idempotency.
+        g = Generator(s, maxheaderlen=0)
+        g(msg)
+        self.assertEqual(text, s.getvalue())
+
+    def test_message_from_file(self):
+        fp = openfile('msg_01.txt')
+        try:
+            text = fp.read()
+            fp.seek(0)
+            msg = email.message_from_file(fp)
+            s = StringIO()
+            # Don't wrap/continue long headers since we're trying to test
+            # idempotency.
+            g = Generator(s, maxheaderlen=0)
+            g(msg)
+            self.assertEqual(text, s.getvalue())
+        finally:
+            fp.close()
+
+    def test_message_from_string_with_class(self):
+        unless = self.failUnless
+        fp = openfile('msg_01.txt')
+        try:
+            text = fp.read()
+        finally:
+            fp.close()
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+        
+        msg = email.message_from_string(text, MyMessage)
+        unless(isinstance(msg, MyMessage))
+        # Try something more complicated
+        fp = openfile('msg_02.txt')
+        try:
+            text = fp.read()
+        finally:
+            fp.close()
+        msg = email.message_from_string(text, MyMessage)
+        for subpart in msg.walk():
+            unless(isinstance(subpart, MyMessage))
+
+
+    def test_message_from_file_with_class(self):
+        unless = self.failUnless
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+        
+        fp = openfile('msg_01.txt')
+        try:
+            msg = email.message_from_file(fp, MyMessage)
+        finally:
+            fp.close()
+        unless(isinstance(msg, MyMessage))
+        # Try something more complicated
+        fp = openfile('msg_02.txt')
+        try:
+            msg = email.message_from_file(fp, MyMessage)
+        finally:
+            fp.close()
+        for subpart in msg.walk():
+            unless(isinstance(subpart, MyMessage))
+
+
+
+class TestIterators(TestEmailBase):
+    def test_body_line_iterator(self):
+        eq = self.assertEqual
+        # First a simple non-multipart message
+        msg = self._msgobj('msg_01.txt')
+        it = Iterators.body_line_iterator(msg)
+        lines = []
+        for line in it:
+            lines.append(line)
+        eq(len(lines), 6)
+        eq(EMPTYSTRING.join(lines), msg.get_payload())
+        # Now a more complicated multipart
+        msg = self._msgobj('msg_02.txt')
+        it = Iterators.body_line_iterator(msg)
+        lines = []
+        for line in it:
+            lines.append(line)
+        eq(len(lines), 43)
+        eq(EMPTYSTRING.join(lines), """\
+Send Ppp mailing list submissions to
+	ppp@zzz.org
+
+To subscribe or unsubscribe via the World Wide Web, visit
+	http://www.zzz.org/mailman/listinfo/ppp
+or, via email, send a message with subject or body 'help' to
+	ppp-request@zzz.org
+
+You can reach the person managing the list at
+	ppp-admin@zzz.org
+
+When replying, please edit your Subject line so it is more specific
+than "Re: Contents of Ppp digest..."
+
+Today's Topics:
+
+   1. testing #1 (Barry A. Warsaw)
+   2. testing #2 (Barry A. Warsaw)
+   3. testing #3 (Barry A. Warsaw)
+   4. testing #4 (Barry A. Warsaw)
+   5. testing #5 (Barry A. Warsaw)
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+
+_______________________________________________
+Ppp mailing list
+Ppp@zzz.org
+http://www.zzz.org/mailman/listinfo/ppp
+
+""")
+
+    def test_typed_subpart_iterator(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_04.txt')
+        it = Iterators.typed_subpart_iterator(msg, 'text')
+        lines = []
+        subparts = 0
+        for subpart in it:
+            subparts += 1
+            lines.append(subpart.get_payload())
+        eq(subparts, 2)
+        eq(EMPTYSTRING.join(lines), """\
+a simple kind of mirror
+to reflect upon our own
+a simple kind of mirror
+to reflect upon our own
+""")
+
+
+
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(TestMessageAPI))
+    suite.addTest(unittest.makeSuite(TestEncoders))
+    suite.addTest(unittest.makeSuite(TestLongHeaders))
+    suite.addTest(unittest.makeSuite(TestFromMangling))
+    suite.addTest(unittest.makeSuite(TestImage))
+    suite.addTest(unittest.makeSuite(TestText))
+    suite.addTest(unittest.makeSuite(TestMultipartMixed))
+    suite.addTest(unittest.makeSuite(TestNonConformant))
+    suite.addTest(unittest.makeSuite(TestRFC2047))
+    suite.addTest(unittest.makeSuite(TestMessageRFC822))
+    suite.addTest(unittest.makeSuite(TestIdempotent))
+    suite.addTest(unittest.makeSuite(TestMiscellaneous))
+    suite.addTest(unittest.makeSuite(TestIterators))
+    return suite
+
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')
+else:
+    from test_support import run_suite
+    run_suite(suite())