mirror of
https://github.com/python/cpython.git
synced 2025-07-08 03:45:36 +00:00
6bf644ec82
Extra newlines are removed at the end of non-shell files. If the file only has newlines after stripping other trailing whitespace, all are removed, as is done by patchcheck.py.
668 lines
23 KiB
Python
668 lines
23 KiB
Python
"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)
|