| "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) |
