Test script for the textwrap module. Kindly provided by Peter Hansen

<peter@engcorp.com> based on a test script that's been kicking around my
home directory for a couple of months now and only saw the light of day
because I included it when I sent textwrap.py to python-dev for review.

1 files changed, 261 insertions, 0 deletions

diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py
new file mode 100644
index 0000000..0074d3f
--- /dev/null
+++ b/Lib/test/test_textwrap.py
@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+
+import unittest
+
+# import item under test
+from textwrap import TextWrapper, wrap, fill
+
+
+class WrapperTestCase(unittest.TestCase):
+    '''Parent class with utility methods for textwrap tests.'''
+
+    def show(self, textin):
+        if isinstance(textin, list):
+            result = []
+            for i in range(len(textin)):
+                result.append("  %d: %r" % (i, textin[i]))
+            result = '\n'.join(result)
+        elif isinstance(textin, (str, unicode)):
+            result = "  %s\n" % repr(textin)
+        return result
+
+
+    def check(self, result, expect):
+        self.assertEquals(result, expect, 
+            'Expected:\n%s\nbut got:\n%s' % (
+                self.show(result), self.show(expect)))
+
+
+
+# Note: a new TestCase instance is created before running each
+# test method.
+class WrapTestCase(WrapperTestCase):
+
+    # called before each test method
+    def setUp(self):
+        self.wrapper = TextWrapper(width=45, fix_sentence_endings=True)
+
+
+    # Note: any methods that start with "test" are called automatically
+    # by the unittest framework.
+
+    def testSimpleCases(self):
+        '''Simple case: just words, spaces, and a bit of punctuation.'''
+
+        t = "Hello there, how are you this fine day?  I'm glad to hear it!"
+
+        # bizarre formatting intended to increase maintainability
+        subcases = [
+            ( (t, 12), [
+                "Hello there,",
+                "how are you",
+                "this fine",
+                "day?  I'm",
+                "glad to hear",
+                "it!" 
+                ] ),
+            ( (t, 42), [ 
+                "Hello there, how are you this fine day?",
+                "I'm glad to hear it!"
+                ] ),
+            ( (t, 80), [ 
+                t 
+                ] ),
+            ]
+
+        for test, expect in subcases:
+            result = wrap(*test)
+            self.check(result, expect)
+
+
+    def testWhitespace(self):
+        '''Whitespace munging and end-of-sentence detection.'''
+
+        t = """\
+This is a paragraph that already has
+line breaks.  But some of its lines are much longer than the others,
+so it needs to be wrapped.
+Some lines are \ttabbed too.
+What a mess!
+"""
+
+        # bizarre formatting intended to increase maintainability
+        expect = [
+                "This is a paragraph that already has line",
+                "breaks.  But some of its lines are much",
+                "longer than the others, so it needs to be",
+                "wrapped.  Some lines are  tabbed too.  What a",
+                "mess!"
+                ]
+
+        result = self.wrapper.wrap(t)
+        self.check(result, expect)
+
+        result = self.wrapper.fill(t)
+        self.check(result, '\n'.join(expect))
+
+
+    def testWrappingShortToLong(self):
+        '''Wrapping to make short lines longer.'''
+
+        t = "This is a\nshort paragraph."
+
+        # bizarre formatting intended to increase maintainability
+        subcases = [
+            ( (t, 20), [
+                "This is a short",
+                "paragraph."
+                ] ),
+            ( (t, 40), [
+                "This is a short paragraph."
+                ] ),
+            ]
+
+        for test, expect in subcases:
+            result = wrap(*test)
+            self.check(result, expect)
+
+
+    def testHyphenated(self):
+        '''Test breaking hyphenated words.'''
+
+        t = "this-is-a-useful-feature-for-reformatting-posts-from-tim-peters'ly"
+
+        subcases = [
+            ( (t, 40), [
+                "this-is-a-useful-feature-for-",
+                "reformatting-posts-from-tim-peters'ly"
+                ] ),
+            ( (t, 41), [
+                "this-is-a-useful-feature-for-",
+                "reformatting-posts-from-tim-peters'ly"
+                ] ),
+            ( (t, 42), [
+                "this-is-a-useful-feature-for-reformatting-",
+                "posts-from-tim-peters'ly"
+                ] ),
+            ]
+
+        for test, expect in subcases:
+            result = wrap(*test)
+            self.check(result, expect)
+
+
+    def test_split(self):
+        '''Ensure that the standard _split() method works as advertised 
+           in the comments (don't you hate it when code and comments diverge?).'''
+
+        t = "Hello there -- you goof-ball, use the -b option!"
+
+        result = self.wrapper._split(t)
+        self.check(result,
+             ["Hello", " ", "there", " ", "--", " ", "you", " ", "goof-",
+              "ball,", " ", "use", " ", "the", " ", "-b", " ",  "option!"])
+
+
+    def testPoppins(self):
+        '''Please rename this test based on its purpose.'''
+
+        t = '''
+Did you say "supercalifragilisticexpialidocious?"
+How *do* you spell that odd word, anyways?
+'''
+        # bizarre formatting intended to increase maintainability
+        subcases = [
+            ( (t, 30), [
+                'Did you say "supercalifragilis',
+                'ticexpialidocious?" How *do*',
+                'you spell that odd word,',
+                'anyways?' 
+                ] ),
+            ( (t, 50), [
+                'Did you say "supercalifragilisticexpialidocious?"',
+                'How *do* you spell that odd word, anyways?'
+                ] ),
+            ]
+
+        for test, expect in subcases:
+            result = wrap(*test)
+            self.check(result, expect)
+
+
+    def testBreakLongWordsOff(self):        
+        '''Test with break_long_words disabled.'''
+        t = '''
+Did you say "supercalifragilisticexpialidocious?"
+How *do* you spell that odd word, anyways?
+'''
+        self.wrapper.break_long_words = 0
+        self.wrapper.width = 30
+        result = self.wrapper.wrap(t)
+        expect = [
+                'Did you say',
+                '"supercalifragilisticexpialidocious?"',
+                'How *do* you spell that odd',
+                'word, anyways?'
+                ] 
+        self.check(result, expect)
+
+        # Same thing with kwargs passed to standalone wrap() function.
+        result = wrap(t, width=30, break_long_words=0)
+        self.check(result, expect)
+
+
+
+class IndentTestCases(WrapperTestCase):
+
+    # called before each test method
+    def setUp(self):
+        self.testString = '''\
+This paragraph will be filled, first without any indentation,
+and then with some (including a hanging indent).'''
+
+
+    def testFill(self):
+        '''Test the fill() method.'''
+
+        expect = '''\
+This paragraph will be filled, first
+without any indentation, and then with
+some (including a hanging indent).'''
+
+        result = fill(self.testString, 40)
+        self.check(result, expect)
+
+
+    def testInitialIndent(self):
+        '''Test initial_indent parameter.'''
+
+        expect = [
+            "     This paragraph will be filled,",
+            "first without any indentation, and then",
+            "with some (including a hanging indent)."]
+
+        result = wrap(self.testString, 40, initial_indent="     ")
+        self.check(result, expect)
+
+        expect = '''\
+     This paragraph will be filled,
+first without any indentation, and then
+with some (including a hanging indent).'''
+
+        result = fill(self.testString, 40, initial_indent="     ")
+        self.check(result, expect)
+
+
+    def testSubsequentIndent(self):
+        '''Test subsequent_indent parameter.'''
+
+        expect = '''\
+  * This paragraph will be filled, first
+    without any indentation, and then
+    with some (including a hanging
+    indent).'''
+
+        result = fill(self.testString, 40, initial_indent="  * ", 
+            subsequent_indent="    ")
+        self.check(result, expect)
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file