import unittest
from test import test_support

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 test_simple(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 test_whitespace(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 test_wrap_short(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 test_hyphenated(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.'''

        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 test_funky_punc(self):
        '''Wrap text with long words and lots of punctuation.'''

        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 test_long_words(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 test_fill(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 test_initial_indent(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 test_subsequent_indent(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)


def test_main():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(WrapTestCase))
    suite.addTest(unittest.makeSuite(IndentTestCases))
    test_support.run_suite(suite)

if __name__ == '__main__':
    test_main()
