text: "Test format, coverage 99%."
  
  from idlelib import format as ft
  import unittest
  from unittest import mock
  from test.support import requires
  from tkinter import Tk, Text
  from idlelib.editor import EditorWindow
  from idlelib.idle_test.mock_idle import Editor as MockEditor
  
  
  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(ft.is_all_white(''))
          self.assertTrue(ft.is_all_white('\t\n\r\f\v'))
          self.assertFalse(ft.is_all_white(self.test_comment))
  
      def test_get_indent(self):
          Equal = self.assertEqual
          Equal(ft.get_indent(self.test_comment), '')
          Equal(ft.get_indent(self.trailingws_comment), '')
          Equal(ft.get_indent(self.leadingws_comment), '    ')
          Equal(ft.get_indent(self.leadingws_nocomment), '    ')
  
      def test_get_comment_header(self):
          Equal = self.assertEqual
          # Test comment strings
          Equal(ft.get_comment_header(self.test_comment), '#')
          Equal(ft.get_comment_header(self.trailingws_comment), '#')
          Equal(ft.get_comment_header(self.leadingws_comment), '    #')
          # Test non-comment strings
          Equal(ft.get_comment_header(self.leadingws_nocomment), '    ')
          Equal(ft.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(ft.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 = ft.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 = ft.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 = ft.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 = ft.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 = ft.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')
  
  
  class DummyEditwin:
      def __init__(self, root, text):
          self.root = root
          self.text = text
          self.indentwidth = 4
          self.tabwidth = 4
          self.usetabs = False
          self.context_use_ps1 = True
  
      _make_blanks = EditorWindow._make_blanks
      get_selection_indices = EditorWindow.get_selection_indices
  
  
  class FormatRegionTest(unittest.TestCase):
  
      @classmethod
      def setUpClass(cls):
          requires('gui')
          cls.root = Tk()
          cls.root.withdraw()
          cls.text = Text(cls.root)
          cls.text.undo_block_start = mock.Mock()
          cls.text.undo_block_stop = mock.Mock()
          cls.editor = DummyEditwin(cls.root, cls.text)
          cls.formatter = ft.FormatRegion(cls.editor)
  
      @classmethod
      def tearDownClass(cls):
          del cls.text, cls.formatter, cls.editor
          cls.root.update_idletasks()
          cls.root.destroy()
          del cls.root
  
      def setUp(self):
          self.text.insert('1.0', self.code_sample)
  
      def tearDown(self):
          self.text.delete('1.0', 'end')
  
      code_sample = """\
  # WS line needed for test.
  class C1():
      # Class comment.
      def __init__(self, a, b):
          self.a = a
          self.b = b
  
      def compare(self):
          if a > b:
              return a
          elif a < b:
              return b
          else:
              return None
  """
  
      def test_get_region(self):
          get = self.formatter.get_region
          text = self.text
          eq = self.assertEqual
  
          # Add selection.
          text.tag_add('sel', '7.0', '10.0')
          expected_lines = ['',
                            '    def compare(self):',
                            '        if a > b:',
                            '']
          eq(get(), ('7.0', '10.0', '\n'.join(expected_lines), expected_lines))
  
          # Remove selection.
          text.tag_remove('sel', '1.0', 'end')
          eq(get(), ('15.0', '16.0', '\n', ['', '']))
  
      def test_set_region(self):
          set_ = self.formatter.set_region
          text = self.text
          eq = self.assertEqual
  
          save_bell = text.bell
          text.bell = mock.Mock()
          line6 = self.code_sample.splitlines()[5]
          line10 = self.code_sample.splitlines()[9]
  
          text.tag_add('sel', '6.0', '11.0')
          head, tail, chars, lines = self.formatter.get_region()
  
          # No changes.
          set_(head, tail, chars, lines)
          text.bell.assert_called_once()
          eq(text.get('6.0', '11.0'), chars)
          eq(text.get('sel.first', 'sel.last'), chars)
          text.tag_remove('sel', '1.0', 'end')
  
          # Alter selected lines by changing lines and adding a newline.
          newstring = 'added line 1\n\n\n\n'
          newlines = newstring.split('\n')
          set_('7.0', '10.0', chars, newlines)
          # Selection changed.
          eq(text.get('sel.first', 'sel.last'), newstring)
          # Additional line added, so last index is changed.
          eq(text.get('7.0', '11.0'), newstring)
          # Before and after lines unchanged.
          eq(text.get('6.0', '7.0-1c'), line6)
          eq(text.get('11.0', '12.0-1c'), line10)
          text.tag_remove('sel', '1.0', 'end')
  
          text.bell = save_bell
  
      def test_indent_region_event(self):
          indent = self.formatter.indent_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          indent()
          # Blank lines aren't affected by indent.
          eq(text.get('7.0', '10.0'), ('\n        def compare(self):\n            if a > b:\n'))
  
      def test_dedent_region_event(self):
          dedent = self.formatter.dedent_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          dedent()
          # Blank lines aren't affected by dedent.
          eq(text.get('7.0', '10.0'), ('\ndef compare(self):\n    if a > b:\n'))
  
      def test_comment_region_event(self):
          comment = self.formatter.comment_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          comment()
          eq(text.get('7.0', '10.0'), ('##\n##    def compare(self):\n##        if a > b:\n'))
  
      def test_uncomment_region_event(self):
          comment = self.formatter.comment_region_event
          uncomment = self.formatter.uncomment_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          comment()
          uncomment()
          eq(text.get('7.0', '10.0'), ('\n    def compare(self):\n        if a > b:\n'))
  
          # Only remove comments at the beginning of a line.
          text.tag_remove('sel', '1.0', 'end')
          text.tag_add('sel', '3.0', '4.0')
          uncomment()
          eq(text.get('3.0', '3.end'), ('    # Class comment.'))
  
          self.formatter.set_region('3.0', '4.0', '', ['# Class comment.', ''])
          uncomment()
          eq(text.get('3.0', '3.end'), (' Class comment.'))
  
      @mock.patch.object(ft.FormatRegion, "_asktabwidth")
      def test_tabify_region_event(self, _asktabwidth):
          tabify = self.formatter.tabify_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          # No tabwidth selected.
          _asktabwidth.return_value = None
          self.assertIsNone(tabify())
  
          _asktabwidth.return_value = 3
          self.assertIsNotNone(tabify())
          eq(text.get('7.0', '10.0'), ('\n\t def compare(self):\n\t\t  if a > b:\n'))
  
      @mock.patch.object(ft.FormatRegion, "_asktabwidth")
      def test_untabify_region_event(self, _asktabwidth):
          untabify = self.formatter.untabify_region_event
          text = self.text
          eq = self.assertEqual
  
          text.tag_add('sel', '7.0', '10.0')
          # No tabwidth selected.
          _asktabwidth.return_value = None
          self.assertIsNone(untabify())
  
          _asktabwidth.return_value = 2
          self.formatter.tabify_region_event()
          _asktabwidth.return_value = 3
          self.assertIsNotNone(untabify())
          eq(text.get('7.0', '10.0'), ('\n      def compare(self):\n            if a > b:\n'))
  
      @mock.patch.object(ft, "askinteger")
      def test_ask_tabwidth(self, askinteger):
          ask = self.formatter._asktabwidth
          askinteger.return_value = 10
          self.assertEqual(ask(), 10)
  
  
  class IndentsTest(unittest.TestCase):
  
      @mock.patch.object(ft, "askyesno")
      def test_toggle_tabs(self, askyesno):
          editor = DummyEditwin(None, None)  # usetabs == False.
          indents = ft.Indents(editor)
          askyesno.return_value = True
  
          indents.toggle_tabs_event(None)
          self.assertEqual(editor.usetabs, True)
          self.assertEqual(editor.indentwidth, 8)
  
          indents.toggle_tabs_event(None)
          self.assertEqual(editor.usetabs, False)
          self.assertEqual(editor.indentwidth, 8)
  
      @mock.patch.object(ft, "askinteger")
      def test_change_indentwidth(self, askinteger):
          editor = DummyEditwin(None, None)  # indentwidth == 4.
          indents = ft.Indents(editor)
  
          askinteger.return_value = None
          indents.change_indentwidth_event(None)
          self.assertEqual(editor.indentwidth, 4)
  
          askinteger.return_value = 3
          indents.change_indentwidth_event(None)
          self.assertEqual(editor.indentwidth, 3)
  
          askinteger.return_value = 5
          editor.usetabs = True
          indents.change_indentwidth_event(None)
          self.assertEqual(editor.indentwidth, 3)
  
  
  class RstripTest(unittest.TestCase):
  
      @classmethod
      def setUpClass(cls):
          requires('gui')
          cls.root = Tk()
          cls.root.withdraw()
          cls.text = Text(cls.root)
          cls.editor = MockEditor(text=cls.text)
          cls.do_rstrip = ft.Rstrip(cls.editor).do_rstrip
  
      @classmethod
      def tearDownClass(cls):
          del cls.text, cls.do_rstrip, cls.editor
          cls.root.update_idletasks()
          cls.root.destroy()
          del cls.root
  
      def tearDown(self):
          self.text.delete('1.0', 'end-1c')
  
      def test_rstrip_lines(self):
          original = (
              "Line with an ending tab    \n"
              "Line ending in 5 spaces     \n"
              "Linewithnospaces\n"
              "    indented line\n"
              "    indented line with trailing space \n"
              "    \n")
          stripped = (
              "Line with an ending tab\n"
              "Line ending in 5 spaces\n"
              "Linewithnospaces\n"
              "    indented line\n"
              "    indented line with trailing space\n")
  
          self.text.insert('1.0', original)
          self.do_rstrip()
          self.assertEqual(self.text.get('1.0', 'insert'), stripped)
  
      def test_rstrip_end(self):
          text = self.text
          for code in ('', '\n', '\n\n\n'):
              with self.subTest(code=code):
                  text.insert('1.0', code)
                  self.do_rstrip()
                  self.assertEqual(text.get('1.0','end-1c'), '')
          for code in ('a\n', 'a\n\n', 'a\n\n\n'):
              with self.subTest(code=code):
                  text.delete('1.0', 'end-1c')
                  text.insert('1.0', code)
                  self.do_rstrip()
                  self.assertEqual(text.get('1.0','end-1c'), 'a\n')
  
  
  if __name__ == '__main__':
      unittest.main(verbosity=2, exit=2)
  