mirror of
https://github.com/python/cpython.git
synced 2025-10-31 05:31:20 +00:00
8dfe15625e
Remove 9 remaining '(object)' occurrences in class headers in idlelib and 25 '()' occurrences in idlelib.idle_test class headers.
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)
|