text: "Test paragraph, coverage 76%."
  
  from idlelib import paragraph as pg
  import unittest
  from test.support import requires
  from tkinter import Tk, Text
  from idlelib.editor import EditorWindow
  
  
  class Is_Get_Test(unittest.TestCase):
      """Test the is_ and get_ functions"""
      test_comment = '# This is a comment'
      test_nocomment = 'This is not a comment'
      trailingws_comment = '# This is a comment   '
      leadingws_comment = '    # This is a comment'
      leadingws_nocomment = '    This is not a comment'
  
      def test_is_all_white(self):
          self.assertTrue(pg.is_all_white(''))
          self.assertTrue(pg.is_all_white('\t\n\r\f\v'))
          self.assertFalse(pg.is_all_white(self.test_comment))
  
      def test_get_indent(self):
          Equal = self.assertEqual
          Equal(pg.get_indent(self.test_comment), '')
          Equal(pg.get_indent(self.trailingws_comment), '')
          Equal(pg.get_indent(self.leadingws_comment), '    ')
          Equal(pg.get_indent(self.leadingws_nocomment), '    ')
  
      def test_get_comment_header(self):
          Equal = self.assertEqual
          # Test comment strings
          Equal(pg.get_comment_header(self.test_comment), '#')
          Equal(pg.get_comment_header(self.trailingws_comment), '#')
          Equal(pg.get_comment_header(self.leadingws_comment), '    #')
          # Test non-comment strings
          Equal(pg.get_comment_header(self.leadingws_nocomment), '    ')
          Equal(pg.get_comment_header(self.test_nocomment), '')
  
  
  class FindTest(unittest.TestCase):
      """Test the find_paragraph function in paragraph module.
  
      Using the runcase() function, find_paragraph() is called with 'mark' set at
      multiple indexes before and inside the test paragraph.
  
      It appears that code with the same indentation as a quoted string is grouped
      as part of the same paragraph, which is probably incorrect behavior.
      """
  
      @classmethod
      def setUpClass(cls):
          from idlelib.idle_test.mock_tk import Text
          cls.text = Text()
  
      def runcase(self, inserttext, stopline, expected):
          # Check that find_paragraph returns the expected paragraph when
          # the mark index is set to beginning, middle, end of each line
          # up to but not including the stop line
          text = self.text
          text.insert('1.0', inserttext)
          for line in range(1, stopline):
              linelength = int(text.index("%d.end" % line).split('.')[1])
              for col in (0, linelength//2, linelength):
                  tempindex = "%d.%d" % (line, col)
                  self.assertEqual(pg.find_paragraph(text, tempindex), expected)
          text.delete('1.0', 'end')
  
      def test_find_comment(self):
          comment = (
              "# Comment block with no blank lines before\n"
              "# Comment line\n"
              "\n")
          self.runcase(comment, 3, ('1.0', '3.0', '#', comment[0:58]))
  
          comment = (
              "\n"
              "# Comment block with whitespace line before and after\n"
              "# Comment line\n"
              "\n")
          self.runcase(comment, 4, ('2.0', '4.0', '#', comment[1:70]))
  
          comment = (
              "\n"
              "    # Indented comment block with whitespace before and after\n"
              "    # Comment line\n"
              "\n")
          self.runcase(comment, 4, ('2.0', '4.0', '    #', comment[1:82]))
  
          comment = (
              "\n"
              "# Single line comment\n"
              "\n")
          self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:23]))
  
          comment = (
              "\n"
              "    # Single line comment with leading whitespace\n"
              "\n")
          self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:51]))
  
          comment = (
              "\n"
              "# Comment immediately followed by code\n"
              "x = 42\n"
              "\n")
          self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:40]))
  
          comment = (
              "\n"
              "    # Indented comment immediately followed by code\n"
              "x = 42\n"
              "\n")
          self.runcase(comment, 3, ('2.0', '3.0', '    #', comment[1:53]))
  
          comment = (
              "\n"
              "# Comment immediately followed by indented code\n"
              "    x = 42\n"
              "\n")
          self.runcase(comment, 3, ('2.0', '3.0', '#', comment[1:49]))
  
      def test_find_paragraph(self):
          teststring = (
              '"""String with no blank lines before\n'
              'String line\n'
              '"""\n'
              '\n')
          self.runcase(teststring, 4, ('1.0', '4.0', '', teststring[0:53]))
  
          teststring = (
              "\n"
              '"""String with whitespace line before and after\n'
              'String line.\n'
              '"""\n'
              '\n')
          self.runcase(teststring, 5, ('2.0', '5.0', '', teststring[1:66]))
  
          teststring = (
              '\n'
              '    """Indented string with whitespace before and after\n'
              '    Comment string.\n'
              '    """\n'
              '\n')
          self.runcase(teststring, 5, ('2.0', '5.0', '    ', teststring[1:85]))
  
          teststring = (
              '\n'
              '"""Single line string."""\n'
              '\n')
          self.runcase(teststring, 3, ('2.0', '3.0', '', teststring[1:27]))
  
          teststring = (
              '\n'
              '    """Single line string with leading whitespace."""\n'
              '\n')
          self.runcase(teststring, 3, ('2.0', '3.0', '    ', teststring[1:55]))
  
  
  class ReformatFunctionTest(unittest.TestCase):
      """Test the reformat_paragraph function without the editor window."""
  
      def test_reformat_paragraph(self):
          Equal = self.assertEqual
          reform = pg.reformat_paragraph
          hw = "O hello world"
          Equal(reform(' ', 1), ' ')
          Equal(reform("Hello    world", 20), "Hello  world")
  
          # Test without leading newline
          Equal(reform(hw, 1), "O\nhello\nworld")
          Equal(reform(hw, 6), "O\nhello\nworld")
          Equal(reform(hw, 7), "O hello\nworld")
          Equal(reform(hw, 12), "O hello\nworld")
          Equal(reform(hw, 13), "O hello world")
  
          # Test with leading newline
          hw = "\nO hello world"
          Equal(reform(hw, 1), "\nO\nhello\nworld")
          Equal(reform(hw, 6), "\nO\nhello\nworld")
          Equal(reform(hw, 7), "\nO hello\nworld")
          Equal(reform(hw, 12), "\nO hello\nworld")
          Equal(reform(hw, 13), "\nO hello world")
  
  
  class ReformatCommentTest(unittest.TestCase):
      """Test the reformat_comment function without the editor window."""
  
      def test_reformat_comment(self):
          Equal = self.assertEqual
  
          # reformat_comment formats to a minimum of 20 characters
          test_string = (
              "    \"\"\"this is a test of a reformat for a triple quoted string"
              " will it reformat to less than 70 characters for me?\"\"\"")
          result = pg.reformat_comment(test_string, 70, "    ")
          expected = (
              "    \"\"\"this is a test of a reformat for a triple quoted string will it\n"
              "    reformat to less than 70 characters for me?\"\"\"")
          Equal(result, expected)
  
          test_comment = (
              "# this is a test of a reformat for a triple quoted string will "
              "it reformat to less than 70 characters for me?")
          result = pg.reformat_comment(test_comment, 70, "#")
          expected = (
              "# this is a test of a reformat for a triple quoted string will it\n"
              "# reformat to less than 70 characters for me?")
          Equal(result, expected)
  
  
  class FormatClassTest(unittest.TestCase):
      def test_init_close(self):
          instance = pg.FormatParagraph('editor')
          self.assertEqual(instance.editwin, 'editor')
          instance.close()
          self.assertEqual(instance.editwin, None)
  
  
  # For testing format_paragraph_event, Initialize FormatParagraph with
  # a mock Editor with .text and  .get_selection_indices.  The text must
  # be a Text wrapper that adds two methods
  
  # A real EditorWindow creates unneeded, time-consuming baggage and
  # sometimes emits shutdown warnings like this:
  # "warning: callback failed in WindowList <class '_tkinter.TclError'>
  # : invalid command name ".55131368.windows".
  # Calling EditorWindow._close in tearDownClass prevents this but causes
  # other problems (windows left open).
  
  class TextWrapper:
      def __init__(self, master):
          self.text = Text(master=master)
      def __getattr__(self, name):
          return getattr(self.text, name)
      def undo_block_start(self): pass
      def undo_block_stop(self): pass
  
  class Editor:
      def __init__(self, root):
          self.text = TextWrapper(root)
      get_selection_indices = EditorWindow. get_selection_indices
  
  class FormatEventTest(unittest.TestCase):
      """Test the formatting of text inside a Text widget.
  
      This is done with FormatParagraph.format.paragraph_event,
      which calls functions in the module as appropriate.
      """
      test_string = (
          "    '''this is a test of a reformat for a triple "
          "quoted string will it reformat to less than 70 "
          "characters for me?'''\n")
      multiline_test_string = (
          "    '''The first line is under the max width.\n"
          "    The second line's length is way over the max width. It goes "
          "on and on until it is over 100 characters long.\n"
          "    Same thing with the third line. It is also way over the max "
          "width, but FormatParagraph will fix it.\n"
          "    '''\n")
      multiline_test_comment = (
          "# The first line is under the max width.\n"
          "# The second line's length is way over the max width. It goes on "
          "and on until it is over 100 characters long.\n"
          "# Same thing with the third line. It is also way over the max "
          "width, but FormatParagraph will fix it.\n"
          "# The fourth line is short like the first line.")
  
      @classmethod
      def setUpClass(cls):
          requires('gui')
          cls.root = Tk()
          cls.root.withdraw()
          editor = Editor(root=cls.root)
          cls.text = editor.text.text  # Test code does not need the wrapper.
          cls.formatter = pg.FormatParagraph(editor).format_paragraph_event
          # Sets the insert mark just after the re-wrapped and inserted  text.
  
      @classmethod
      def tearDownClass(cls):
          del cls.text, cls.formatter
          cls.root.update_idletasks()
          cls.root.destroy()
          del cls.root
  
      def test_short_line(self):
          self.text.insert('1.0', "Short line\n")
          self.formatter("Dummy")
          self.assertEqual(self.text.get('1.0', 'insert'), "Short line\n" )
          self.text.delete('1.0', 'end')
  
      def test_long_line(self):
          text = self.text
  
          # Set cursor ('insert' mark) to '1.0', within text.
          text.insert('1.0', self.test_string)
          text.mark_set('insert', '1.0')
          self.formatter('ParameterDoesNothing', limit=70)
          result = text.get('1.0', 'insert')
          # find function includes \n
          expected = (
  "    '''this is a test of a reformat for a triple quoted string will it\n"
  "    reformat to less than 70 characters for me?'''\n")  # yes
          self.assertEqual(result, expected)
          text.delete('1.0', 'end')
  
          # Select from 1.11 to line end.
          text.insert('1.0', self.test_string)
          text.tag_add('sel', '1.11', '1.end')
          self.formatter('ParameterDoesNothing', limit=70)
          result = text.get('1.0', 'insert')
          # selection excludes \n
          expected = (
  "    '''this is a test of a reformat for a triple quoted string will it reformat\n"
  " to less than 70 characters for me?'''")  # no
          self.assertEqual(result, expected)
          text.delete('1.0', 'end')
  
      def test_multiple_lines(self):
          text = self.text
          #  Select 2 long lines.
          text.insert('1.0', self.multiline_test_string)
          text.tag_add('sel', '2.0', '4.0')
          self.formatter('ParameterDoesNothing', limit=70)
          result = text.get('2.0', 'insert')
          expected = (
  "    The second line's length is way over the max width. It goes on and\n"
  "    on until it is over 100 characters long. Same thing with the third\n"
  "    line. It is also way over the max width, but FormatParagraph will\n"
  "    fix it.\n")
          self.assertEqual(result, expected)
          text.delete('1.0', 'end')
  
      def test_comment_block(self):
          text = self.text
  
          # Set cursor ('insert') to '1.0', within block.
          text.insert('1.0', self.multiline_test_comment)
          self.formatter('ParameterDoesNothing', limit=70)
          result = text.get('1.0', 'insert')
          expected = (
  "# The first line is under the max width. The second line's length is\n"
  "# way over the max width. It goes on and on until it is over 100\n"
  "# characters long. Same thing with the third line. It is also way over\n"
  "# the max width, but FormatParagraph will fix it. The fourth line is\n"
  "# short like the first line.\n")
          self.assertEqual(result, expected)
          text.delete('1.0', 'end')
  
          # Select line 2, verify line 1 unaffected.
          text.insert('1.0', self.multiline_test_comment)
          text.tag_add('sel', '2.0', '3.0')
          self.formatter('ParameterDoesNothing', limit=70)
          result = text.get('1.0', 'insert')
          expected = (
  "# The first line is under the max width.\n"
  "# The second line's length is way over the max width. It goes on and\n"
  "# on until it is over 100 characters long.\n")
          self.assertEqual(result, expected)
          text.delete('1.0', 'end')
  
  # The following block worked with EditorWindow but fails with the mock.
  # Lines 2 and 3 get pasted together even though the previous block left
  # the previous line alone. More investigation is needed.
  ##        # Select lines 3 and 4
  ##        text.insert('1.0', self.multiline_test_comment)
  ##        text.tag_add('sel', '3.0', '5.0')
  ##        self.formatter('ParameterDoesNothing')
  ##        result = text.get('3.0', 'insert')
  ##        expected = (
  ##"# Same thing with the third line. It is also way over the max width,\n"
  ##"# but FormatParagraph will fix it. The fourth line is short like the\n"
  ##"# first line.\n")
  ##        self.assertEqual(result, expected)
  ##        text.delete('1.0', 'end')
  
  
  if __name__ == '__main__':
      unittest.main(verbosity=2, exit=2)
  